dfb61f01db
Support for Xtensa emitter and assembler, and upgraded F4 and F7 STM HAL This release adds support for the Xtensa architecture as a target for the native emitter, as well as Xtensa inline assembler. The int.from_bytes and int.to_bytes methods now require a second argument (the byte order) per CPython (only "little" is supported at this time). The "readall" method has been removed from all stream classes that used it; "read" with no arguments should be used instead. There is now support for importing packages from compiled .mpy files. Test coverage is increased to 96%. The generic I2C driver has improvements: configurable clock stretching timeout, "stop" argument added to readfrom/writeto methods, "nack" argument added to readinto, and write[to] now returns num of ACKs received. The framebuf module now handles 16-bit depth (generic colour format) and has hline, vline, rect, line methods. A new utimeq module is added for efficient queue ordering defined by modulo time (to be compatible with time.ticks_xxx functions). The pyboard.py script has been modified so that the target board is not reset between scripts or commands that are given on a single command line. For the stmhal port the STM Cube HAL has been upgraded: Cube F4 HAL to v1.13.1 (CMSIS 2.5.1, HAL v1.5.2) and Cube F7 HAL to v1.1.2. There is a more robust pyb.I2C implementation (DMA is now disabled by default, can be enabled via an option), and there is an implementation of machine.I2C with robust error handling and hardware acceleration on F4 MCUs. It is now recommended to use machine.I2C instead of pyb.I2C. The UART class is now more robust with better handling of errors/timeouts. There is also more accurate VBAT and VREFINT measurements for the ADC. New boards that are supported include: NUCLEO_F767ZI, STM32F769DISC and NUCLEO_L476RG. For the esp8266 port select/poll is now supported for sockets using the uselect module. There is support for native and viper emitters, as well as an inline assembler (with limited iRAM for storage of native functions, or the option to store code to flash). There is improved software I2C with a slight API change: scl/sda pins can be specified as positional only when "-1" is passed as the first argument to indicate the use of software I2C. It is recommended to use keyword arguments for scl/sda. There is very early support for over-the-air (OTA) updates using the yaota8266 project. A detailed list of changes follows. py core: - emitnative: fix native import emitter when in viper mode - remove readall() method, which is equivalent to read() w/o args - objexcept: allow clearing traceback with 'exc.__traceback__ = None' - runtime: mp_resume: handle exceptions in Python __next__() - mkrules.mk: rework find command so it works on OSX - *.mk: replace uses of 'sed' with $(SED) - parse: move function to check for const parse node to parse.[ch] - parse: make mp_parse_node_new_leaf an inline function - parse: add code to fold logical constants in or/and/not operations - factor persistent code load/save funcs into persistentcode.[ch] - factor out persistent-code reader into separate files - lexer: rewrite mp_lexer_new_from_str_len in terms of mp_reader_mem - lexer: provide generic mp_lexer_new_from_file based on mp_reader - lexer: rewrite mp_lexer_new_from_fd in terms of mp_reader - lexer: make lexer use an mp_reader as its source - objtype: implement __call__ handling for an instance w/o heap alloc - factor out common code from assemblers into asmbase.[ch] - stream: move ad-hoc ioctl constants to stream.h and rename them - compile: simplify configuration of native emitter - emit.h: remove long-obsolete declarations for cpython emitter - move arch-specific assembler macros from emitnative to asmXXX.h - asmbase: add MP_PLAT_COMMIT_EXEC option for handling exec code - asmxtensa: add low-level Xtensa assembler - integrate Xtensa assembler into native emitter - allow inline-assembler emitter to be generic - add inline Xtensa assembler - emitinline: embed entire asm struct instead of a pointer to it - emitinline: move inline-asm align and data methods to compiler - emitinline: move common code for end of final pass to compiler - asm: remove need for dummy_data when doing initial assembler passes - objint: from_bytes, to_bytes: require byteorder arg, require "little" - binary: do zero extension when storing a value larger than word size - builtinimport: support importing packages from compiled .mpy files - mpz: remove unreachable code in mpn_or_neg functions - runtime: zero out fs_user_mount array in mp_init - mpconfig.h: enable MICROPY_PY_SYS_EXIT by default - add MICROPY_KBD_EXCEPTION config option to provide mp_kbd_exception - compile: add an extra pass for Xtensa inline assembler - modbuiltins: remove unreachable code - objint: rename mp_obj_int_as_float to mp_obj_int_as_float_impl - emitglue: refactor to remove assert(0), to improve coverage - lexer: remove unreachable code in string tokeniser - lexer: remove unnecessary check for EOF in lexer's next_char func - lexer: permanently disable the mp_lexer_show_token function - parsenum: simplify and generalise decoding of digit values - mpz: fix assertion in mpz_set_from_str which checks value of base - mpprint: add assertion for, and comment about, valid base values - objint: simplify mp_int_format_size and remove unreachable code - unicode: comment-out unused function unichar_isprint - consistently update signatures of .make_new and .call methods - mkrules.mk: add MPY_CROSS_FLAGS option to pass flags to mpy-cross - builtinimport: fix bug when importing names from frozen packages extmod: - machine_i2c: make the clock stretching timeout configurable - machine_i2c: raise an error when clock stretching times out - machine_i2c: release SDA on bus error - machine_i2c: add a C-level I2C-protocol, refactoring soft I2C - machine_i2c: add argument to C funcs to control stop generation - machine_i2c: rewrite i2c.scan in terms of C-level protocol - machine_i2c: rewrite mem xfer funcs in terms of C-level protocol - machine_i2c: remove unneeded i2c_write_mem/i2c_read_mem funcs - machine_i2c: make C-level functions return -errno on I2C error - machine_i2c: add 'nack' argument to i2c.readinto - machine_i2c: make i2c.write[to] methods return num of ACKs recvd - machine_i2c: add 'stop' argument to i2c readfrom/writeto meths - machine_i2c: remove trivial function wrappers - machine_i2c: expose soft I2C obj and readfrom/writeto funcs - machine_i2c: add hook to constructor to call port-specific code - modurandom: allow to build with float disabled - modframebuf: make FrameBuffer handle 16bit depth - modframebuf: add back legacy FrameBuffer1 "class" - modframebuf: optimise fill and fill_rect methods - vfs_fat: implement POSIX behaviour of rename, allow to overwrite - moduselect: use stream helper function instead of ad-hoc code - moduselect: use configurable EVENT_POLL_HOOK instead of WFI - modlwip: add ioctl method to socket, with poll implementation - vfs_fat_file: allow file obj to respond to ioctl flush request - modbtree: add method to sync the database - modbtree: rename "sync" method to "flush" for consistency - modframebuf: add hline, vline, rect and line methods - machine_spi: provide reusable software SPI class - modframebuf: make framebuf implement the buffer protocol - modframebuf: store underlying buffer object to prevent GC free - modutimeq: copy of current moduheapq with timeq support for refactoring - modutimeq: refactor into optimized class - modutimeq: make time_less_than be actually "less than", not less/eq lib: - utils/interrupt_char: use core-provided mp_kbd_exception if enabled drivers: - display/ssd1306.py: update to use FrameBuffer not FrameBuffer1 - onewire: enable pull up on data pin - onewire/ds18x20: fix negative temperature calc for DS18B20 tools: - tinytest-codegen: blacklist recently added uheapq_timeq test (qemu-arm) - pyboard.py: refactor so target is not reset between scripts/cmd - mpy-tool.py: add support for OPT_CACHE_MAP_LOOKUP_IN_BYTECODE tests: - micropython: add test for import from within viper function - use read() instead of readall() - basics: add test for logical constant folding - micropython: add test for creating traceback without allocation - micropython: move alloc-less traceback test to separate test file - extmod: improve ujson coverage - basics: improve user class coverage - basics: add test for dict.fromkeys where arg is a generator - basics: add tests for if-expressions - basics: change dict_fromkeys test so it doesn't use generators - basics: enable tests for list slice getting with 3rd arg - extmod/vfs_fat_fileio: add test for constructor of FileIO type - extmod/btree1: exercise btree.flush() - extmod/framebuf1: add basics tests for hline, vline, rect, line - update for required byteorder arg for int.from_bytes()/to_bytes() - extmod: improve moductypes test coverage - extmod: improve modframebuf test coverage - micropython: get heapalloc_traceback test running on baremetal - struct*: make skippable - basics: improve mpz test coverage - float/builtin_float_round: test round() with second arg - basics/builtin_dir: add test for dir() of a type - basics: add test for builtin locals() - basics/set_pop: improve coverage of set functions - run-tests: for REPL tests make sure the REPL is exited at the end - basics: improve test coverage for generators - import: add a test which uses ... in from-import statement - add tests to improve coverage of runtime.c - add tests to improve coverage of objarray.c - extmod: add test for utimeq module - basics/lexer: add a test for newline-escaping within a string - add a coverage test for printing the parse-tree - utimeq_stable: test for partial stability of utimeq queuing - heapalloc_inst_call: test for no alloc for simple object calls - basics: add tests for parsing of ints with base 36 - basics: add tests to improve coverage of binary.c - micropython: add test for micropython.stack_use() function - extmod: improve ubinascii.c test coverage - thread: improve modthread.c test coverage - cmdline: improve repl.c autocomplete test coverage - unix: improve runtime_utils.c test coverage - pyb/uart: update test to match recent change to UART timeout_char - run-tests: allow to skip set tests - improve warning.c test coverage - float: improve formatfloat.c test coverage using Python - unix: improve formatfloat.c test coverage using C - unix/extra_coverage: add basic tests to import frozen str and mpy - types1: split out set type test to set_types - array: allow to skip test if "array" is unavailable - unix/extra_coverage: add tests for importing frozen packages unix port: - rename define for unix moduselect to MICROPY_PY_USELECT_POSIX - Makefile: update freedos target for change of USELECT config name - enable utimeq module - main: allow to print the parse tree in coverage build - Makefile: make "coverage_test" target mirror Travis test actions - moduselect: if file object passed to .register(), return it in .poll() - Makefile: split long line for coverage target, easier to modify - enable and add basic frozen str and frozen mpy in coverage build - Makefile: allow cache-map-lookup optimisation with frozen bytecode windows port: - enable READER_POSIX to get access to lexer_new_from_file stmhal port: - dma: de-init the DMA peripheral properly before initialising - i2c: add option to I2C to enable/disable use of DMA transfers - i2c: reset the I2C peripheral if there was an error on the bus - rename mp_hal_pin_set_af to _config_alt, to simplify alt config - upgrade to STM32CubeF4 v1.13.0 - CMSIS/Device 2.5.1 - upgrade to STM32CubeF4 v1.13.0 - HAL v1.5.1 - apply STM32CubeF4 v1.13.1 patch - upgrade HAL driver to v1.5.2 - hal/i2c: reapply HAL commitea040a4
for f4 - hal/sd: reapply HAL commit1d7fb82
for f4 - hal: reapply HAL commit9db719b
for f4 - hal/rcc: reapply HAL commitc568a2b
for f4 - hal/sd: reapply HAL commit09de030
for f4 - boards: configure all F4 boards to work with new HAL - make-stmconst.py: fix regex's to work with current CMSIS - i2c: handle I2C IRQs - dma: precalculate register base and bitshift on handle init - dma: mark DMA sate as READY even if HAL_DMA_Init is skipped - can: clear FIFO flags in IRQ handler - i2c: provide custom IRQ handlers - hal: do not include <stdio.h> in HAL headers - mphalport.h: use single GPIOx->BSRR register - make-stmconst.py: add support for files with invalid utf8 bytes - update HALCOMMITS due to change to hal - make-stmconst.py: restore Python 2 compatibility - update HALCOMMITS due to change to hal - moduselect: move to extmod/ for reuse by other ports - i2c: use the HAL's I2C IRQ handler for F7 and L4 MCUs - updates to get F411 MCUs compiling with latest ST HAL - i2c: remove use of legacy I2C_NOSTRETCH_DISABLED option - add beginnings of port-specific machine.I2C implementation - i2c: add support for I2C4 hardware block on F7 MCUs - i2c: expose the pyb_i2c_obj_t struct and some relevant functions - machine_i2c: provide HW implementation of I2C peripherals for F4 - add support for flash storage on STM32F415 - add back GPIO_BSRRL and GPIO_BSRRH constants to stm module - add OpenOCD configuration for STM32L4 - add address parameters to openocd config files - adc: add "mask" selection parameter to pyb.ADCAll constructor - adc: provide more accurate measure of VBAT and VREFINT - adc: make ADCAll.read_core_temp return accurate float value - adc: add ADCAll.read_vref method, returning "3.3v" value - adc: add support for F767 MCU - adc: make channel "16" always map to the temperature sensor - sdcard: clean/invalidate cache before DMA transfers with SD card - moduos: implement POSIX behaviour of rename, allow to overwrite - adc: use constants from new HAL version - refactor UART configuration to use pin objects - uart: add support for UART7 and UART8 on F7 MCUs - uart: add check that UART id is valid for the given board - cmsis: update STM32F7 CMSIS device include files to V1.1.2 - hal: update ST32CubeF7 HAL files to V1.1.2 - port of f4 hal commitc568a2b
to updated f7 hal - port of f4 hal commit09de030
to updated f7 hal - port of f4 hal commit1d7fb82
to updated f7 hal - declare and initialise PrescTables for F7 MCUs - boards/STM32F7DISC: define LSE_STARTUP_TIMEOUT - hal: update HALCOMMITS due to change in f7 hal files - refactor to use extmod implementation of software SPI class - cmsis: add CMSIS file stm32f767xx.h, V1.1.2 - add NUCLEO_F767ZI board, with openocd config for stm32f7 - cmsis: add CMSIS file stm32f769xx.h, V1.1.2 - add STM32F769DISC board files - move PY_SYS_PLATFORM config from board to general config file - mpconfigport: add weak-module links for io, collections, random - rename mp_const_vcp_interrupt to mp_kbd_exception - usb: always use the mp_kbd_exception object for VCP interrupt - use core-provided keyboard exception object - led: properly initialise timer handle to zero before using it - mphalport.h: explicitly use HAL's GPIO constants for pull modes - usrsw: use mp_hal_pin_config function instead of HAL_GPIO_Init - led: use mp_hal_pin_config function instead of HAL_GPIO_Init - sdcard: use mp_hal_pin_config function instead of HAL_GPIO_Init - add support for STM32 Nucleo64 L476RG - uart: provide a custom function to transmit over UART - uart: increase inter-character timeout by 1ms - enable utimeq module cc3200 port: - tools/smoke.py: change readall() to read() - pybspi: remove static mode=SPI.MASTER parameter for latest HW API - mods/pybspi: remove SPI.MASTER constant, it's no longer needed - update for moduselect moved to extmod/ - re-add support for UART REPL (MICROPY_STDIO_UART setting) - enable UART REPL by default - README: (re)add information about accessing REPL on serial - make: rename "deploy" target to "deploy-ota" - add targets to erase flash, deploy firmware using cc3200tool - README: reorganize and update to the current state of affairs - modwlan: add network.WLAN.print_ver() diagnostic function esp8266 port: - enable uselect module - move websocket_helper.py from scripts to modules for frozen BC - refactor to use extmod implementation of software SPI class - mpconfigport_512k: disable framebuf module for 512k build - enable native emitter for Xtensa arch - enable inline Xtensa assembler - add "ota" target to produce firmware binary for use with yaota8266 - use core-provided keyboard exception object - add "erase" target to Makefile, to erase entire flash - when doing GC be sure to trace the memory holding native code - modesp: flash_user_start(): support configuration with yaota8266 - force relinking OTA firmware image if built after normal one - scripts/inisetup: dump FS starting sector/size on error - Makefile: produce OTA firmware as firmware-ota.bin - modesp: make check_fw() work with OTA firmware - enable utimeq module - Makefile: put firmware-ota.bin in build/, for consistency - modules/flashbdev: add RESERVED_SECS before the filesystem - modules/flashbdev: remove code to patch bootloader flash size - modules/flashbdev: remove now-unused function set_bl_flash_size - modules/flashbdev: change RESERVED_SECS to 0 zephyr port: - add .gitignore to ignore Zephyr's "outdir" directory - zephyr_getchar: update to Zephyr 1.6 unified kernel API - switch to Zephyr 1.6 unified kernel API - support raw REPL - implement soft reset feature - main: initialize sys.path and sys.argv - use core-provided keyboard exception object - uart_core: access console UART directly instead of printk() hack - enable slice subscription docs: - remove references to readall() and update stream read() docs - library/index: elaborate on u-modules - library/machine.I2C: refine definitions of I2C methods - library/pyb.Accel: add hardware note about pins used by accel - library/pyb.UART: added clarification about timeouts - library/pyb.UART: moved writechar doc to sit with other writes - esp8266/tutorial: update intro to add Getting the firmware section - library/machine.I2C: fix I2C constructor docs to match impl - esp8266/tutorial: close socket after reading page content - esp8266/general: add "Scarcity of runtime resources" section - library/esp: document esp.set_native_code_location() function - library/esp: remove para and add further warning about flash - usocket: clarify that socket timeout raises OSError exception travis: - build STM32 F7 and L4 boards under Travis CI - include persistent bytecode with floats in coverage tests examples: - hwapi: button_led: Add GPIO pin read example - hwapi: add soft_pwm example converted to uasyncio - http_client: use read() instead of readall() - hwapi: add uasyncio example of fading 2 LEDs in parallel - hwapi: add example for machine.time_pulse_us() - hwapi: add hwconfig for console tracing of LED operations - accellog.py: change 1: to /sd/, and update comment about FS - hwapi/hwconfig_console: don't alloc memory in value()
1138 lines
42 KiB
C
1138 lines
42 KiB
C
/*
|
||
* This file is part of the Micro Python project, http://micropython.org/
|
||
*
|
||
* The MIT License (MIT)
|
||
*
|
||
* Copyright (c) 2013, 2014 Damien P. George
|
||
* Copyright (c) 2014-2016 Paul Sokolovsky
|
||
*
|
||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
* of this software and associated documentation files (the "Software"), to deal
|
||
* in the Software without restriction, including without limitation the rights
|
||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
* copies of the Software, and to permit persons to whom the Software is
|
||
* furnished to do so, subject to the following conditions:
|
||
*
|
||
* The above copyright notice and this permission notice shall be included in
|
||
* all copies or substantial portions of the Software.
|
||
*
|
||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
* THE SOFTWARE.
|
||
*/
|
||
|
||
#include <stdio.h>
|
||
#include <stddef.h>
|
||
#include <string.h>
|
||
#include <assert.h>
|
||
|
||
#include "py/nlr.h"
|
||
#include "py/objtype.h"
|
||
#include "py/runtime0.h"
|
||
#include "py/runtime.h"
|
||
|
||
#if 0 // print debugging info
|
||
#define DEBUG_PRINT (1)
|
||
#define DEBUG_printf DEBUG_printf
|
||
#else // don't print debugging info
|
||
#define DEBUG_PRINT (0)
|
||
#define DEBUG_printf(...) (void)0
|
||
#endif
|
||
|
||
STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self_in, size_t n_args, size_t n_kw, const mp_obj_t *args);
|
||
|
||
/******************************************************************************/
|
||
// instance object
|
||
|
||
STATIC mp_obj_t mp_obj_new_instance(const mp_obj_type_t *class, uint subobjs) {
|
||
mp_obj_instance_t *o = m_new_obj_var(mp_obj_instance_t, mp_obj_t, subobjs);
|
||
o->base.type = class;
|
||
mp_map_init(&o->members, 0);
|
||
mp_seq_clear(o->subobj, 0, subobjs, sizeof(*o->subobj));
|
||
return MP_OBJ_FROM_PTR(o);
|
||
}
|
||
|
||
STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_type_t **last_native_base) {
|
||
mp_uint_t len = type->bases_tuple->len;
|
||
mp_obj_t *items = type->bases_tuple->items;
|
||
|
||
int count = 0;
|
||
for (uint i = 0; i < len; i++) {
|
||
assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
|
||
const mp_obj_type_t *bt = (const mp_obj_type_t *)MP_OBJ_TO_PTR(items[i]);
|
||
if (bt == &mp_type_object) {
|
||
// Not a "real" type
|
||
continue;
|
||
}
|
||
if (mp_obj_is_native_type(bt)) {
|
||
*last_native_base = bt;
|
||
count++;
|
||
} else {
|
||
count += instance_count_native_bases(bt, last_native_base);
|
||
}
|
||
}
|
||
|
||
return count;
|
||
}
|
||
|
||
// TODO
|
||
// This implements depth-first left-to-right MRO, which is not compliant with Python3 MRO
|
||
// http://python-history.blogspot.com/2010/06/method-resolution-order.html
|
||
// https://www.python.org/download/releases/2.3/mro/
|
||
//
|
||
// will keep lookup->dest[0]'s value (should be MP_OBJ_NULL on invocation) if attribute
|
||
// is not found
|
||
// will set lookup->dest[0] to MP_OBJ_SENTINEL if special method was found in a native
|
||
// type base via slot id (as specified by lookup->meth_offset). As there can be only one
|
||
// native base, it's known that it applies to instance->subobj[0]. In most cases, we also
|
||
// don't need to know which type it was - because instance->subobj[0] is of that type.
|
||
// The only exception is when object is not yet constructed, then we need to know base
|
||
// native type to construct its instance->subobj[0] from. But this case is handled via
|
||
// instance_count_native_bases(), which returns a native base which it saw.
|
||
struct class_lookup_data {
|
||
mp_obj_instance_t *obj;
|
||
qstr attr;
|
||
mp_uint_t meth_offset;
|
||
mp_obj_t *dest;
|
||
bool is_type;
|
||
};
|
||
|
||
STATIC void mp_obj_class_lookup(struct class_lookup_data *lookup, const mp_obj_type_t *type) {
|
||
assert(lookup->dest[0] == MP_OBJ_NULL);
|
||
assert(lookup->dest[1] == MP_OBJ_NULL);
|
||
for (;;) {
|
||
// Optimize special method lookup for native types
|
||
// This avoids extra method_name => slot lookup. On the other hand,
|
||
// this should not be applied to class types, as will result in extra
|
||
// lookup either.
|
||
if (lookup->meth_offset != 0 && mp_obj_is_native_type(type)) {
|
||
#pragma GCC diagnostic push
|
||
#pragma GCC diagnostic ignored "-Wcast-align"
|
||
if (*(void**)((char*)type + lookup->meth_offset) != NULL) {
|
||
#pragma GCC diagnostic pop
|
||
DEBUG_printf("mp_obj_class_lookup: matched special meth slot for %s\n", qstr_str(lookup->attr));
|
||
lookup->dest[0] = MP_OBJ_SENTINEL;
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (type->locals_dict != NULL) {
|
||
// search locals_dict (the set of methods/attributes)
|
||
assert(type->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
|
||
mp_map_t *locals_map = &type->locals_dict->map;
|
||
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(lookup->attr), MP_MAP_LOOKUP);
|
||
if (elem != NULL) {
|
||
if (lookup->is_type) {
|
||
// If we look up a class method, we need to return original type for which we
|
||
// do a lookup, not a (base) type in which we found the class method.
|
||
const mp_obj_type_t *org_type = (const mp_obj_type_t*)lookup->obj;
|
||
mp_convert_member_lookup(MP_OBJ_NULL, org_type, elem->value, lookup->dest);
|
||
} else {
|
||
mp_obj_instance_t *obj = lookup->obj;
|
||
mp_obj_t obj_obj;
|
||
if (obj != NULL && mp_obj_is_native_type(type) && type != &mp_type_object /* object is not a real type */) {
|
||
// If we're dealing with native base class, then it applies to native sub-object
|
||
obj_obj = obj->subobj[0];
|
||
} else {
|
||
obj_obj = MP_OBJ_FROM_PTR(obj);
|
||
}
|
||
mp_convert_member_lookup(obj_obj, type, elem->value, lookup->dest);
|
||
}
|
||
#if DEBUG_PRINT
|
||
printf("mp_obj_class_lookup: Returning: ");
|
||
mp_obj_print(lookup->dest[0], PRINT_REPR); printf(" ");
|
||
mp_obj_print(lookup->dest[1], PRINT_REPR); printf("\n");
|
||
#endif
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Previous code block takes care about attributes defined in .locals_dict,
|
||
// but some attributes of native types may be handled using .load_attr method,
|
||
// so make sure we try to lookup those too.
|
||
if (lookup->obj != NULL && !lookup->is_type && mp_obj_is_native_type(type) && type != &mp_type_object /* object is not a real type */) {
|
||
mp_load_method_maybe(lookup->obj->subobj[0], lookup->attr, lookup->dest);
|
||
if (lookup->dest[0] != MP_OBJ_NULL) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
// attribute not found, keep searching base classes
|
||
|
||
// for a const struct, this entry might be NULL
|
||
if (type->bases_tuple == NULL) {
|
||
return;
|
||
}
|
||
|
||
mp_uint_t len = type->bases_tuple->len;
|
||
mp_obj_t *items = type->bases_tuple->items;
|
||
if (len == 0) {
|
||
return;
|
||
}
|
||
for (uint i = 0; i < len - 1; i++) {
|
||
assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
|
||
mp_obj_type_t *bt = (mp_obj_type_t*)MP_OBJ_TO_PTR(items[i]);
|
||
if (bt == &mp_type_object) {
|
||
// Not a "real" type
|
||
continue;
|
||
}
|
||
mp_obj_class_lookup(lookup, bt);
|
||
if (lookup->dest[0] != MP_OBJ_NULL) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
// search last base (simple tail recursion elimination)
|
||
assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_type_type));
|
||
type = (mp_obj_type_t*)MP_OBJ_TO_PTR(items[len - 1]);
|
||
if (type == &mp_type_object) {
|
||
// Not a "real" type
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
STATIC void instance_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__;
|
||
mp_obj_t member[2] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.attr = meth,
|
||
.meth_offset = offsetof(mp_obj_type_t, print),
|
||
.dest = member,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
if (member[0] == MP_OBJ_NULL && kind == PRINT_STR) {
|
||
// If there's no __str__, fall back to __repr__
|
||
lookup.attr = MP_QSTR___repr__;
|
||
lookup.meth_offset = 0;
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
}
|
||
|
||
if (member[0] == MP_OBJ_SENTINEL) {
|
||
// Handle Exception subclasses specially
|
||
if (mp_obj_is_native_exception_instance(self->subobj[0])) {
|
||
if (kind != PRINT_STR) {
|
||
mp_print_str(print, qstr_str(self->base.type->name));
|
||
}
|
||
mp_obj_print_helper(print, self->subobj[0], kind | PRINT_EXC_SUBCLASS);
|
||
} else {
|
||
mp_obj_print_helper(print, self->subobj[0], kind);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (member[0] != MP_OBJ_NULL) {
|
||
mp_obj_t r = mp_call_function_1(member[0], self_in);
|
||
mp_obj_print_helper(print, r, PRINT_STR);
|
||
return;
|
||
}
|
||
|
||
// TODO: CPython prints fully-qualified type name
|
||
mp_printf(print, "<%s object at %p>", mp_obj_get_type_str(self_in), self);
|
||
}
|
||
|
||
mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||
assert(mp_obj_is_instance_type(self));
|
||
|
||
const mp_obj_type_t *native_base;
|
||
uint num_native_bases = instance_count_native_bases(self, &native_base);
|
||
assert(num_native_bases < 2);
|
||
|
||
mp_obj_instance_t *o = MP_OBJ_TO_PTR(mp_obj_new_instance(self, num_native_bases));
|
||
|
||
// This executes only "__new__" part of obejection creation.
|
||
// TODO: This won't work will for classes with native bases.
|
||
// TODO: This is hack, should be resolved along the lines of
|
||
// https://github.com/micropython/micropython/issues/606#issuecomment-43685883
|
||
if (n_args == 1 && *args == MP_OBJ_SENTINEL) {
|
||
return MP_OBJ_FROM_PTR(o);
|
||
}
|
||
|
||
// look for __new__ function
|
||
mp_obj_t init_fn[2] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = NULL,
|
||
.attr = MP_QSTR___new__,
|
||
.meth_offset = offsetof(mp_obj_type_t, make_new),
|
||
.dest = init_fn,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self);
|
||
|
||
mp_obj_t new_ret = MP_OBJ_FROM_PTR(o);
|
||
if (init_fn[0] == MP_OBJ_SENTINEL) {
|
||
// Native type's constructor is what wins - it gets all our arguments,
|
||
// and none Python classes are initialized at all.
|
||
o->subobj[0] = native_base->make_new(native_base, n_args, n_kw, args);
|
||
} else if (init_fn[0] != MP_OBJ_NULL) {
|
||
// now call Python class __new__ function with all args
|
||
if (n_args == 0 && n_kw == 0) {
|
||
mp_obj_t args2[1] = {MP_OBJ_FROM_PTR(self)};
|
||
new_ret = mp_call_function_n_kw(init_fn[0], 1, 0, args2);
|
||
} else {
|
||
mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw);
|
||
args2[0] = MP_OBJ_FROM_PTR(self);
|
||
memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
|
||
new_ret = mp_call_function_n_kw(init_fn[0], n_args + 1, n_kw, args2);
|
||
m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
|
||
}
|
||
|
||
}
|
||
|
||
// https://docs.python.org/3.4/reference/datamodel.html#object.__new__
|
||
// "If __new__() does not return an instance of cls, then the new instance’s __init__() method will not be invoked."
|
||
if (mp_obj_get_type(new_ret) != self) {
|
||
return new_ret;
|
||
}
|
||
|
||
o = MP_OBJ_TO_PTR(new_ret);
|
||
|
||
// now call Python class __init__ function with all args
|
||
init_fn[0] = init_fn[1] = MP_OBJ_NULL;
|
||
lookup.obj = o;
|
||
lookup.attr = MP_QSTR___init__;
|
||
lookup.meth_offset = 0;
|
||
mp_obj_class_lookup(&lookup, self);
|
||
if (init_fn[0] != MP_OBJ_NULL) {
|
||
mp_obj_t init_ret;
|
||
if (n_args == 0 && n_kw == 0) {
|
||
init_ret = mp_call_method_n_kw(0, 0, init_fn);
|
||
} else {
|
||
mp_obj_t *args2 = m_new(mp_obj_t, 2 + n_args + 2 * n_kw);
|
||
args2[0] = init_fn[0];
|
||
args2[1] = init_fn[1];
|
||
memcpy(args2 + 2, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
|
||
init_ret = mp_call_method_n_kw(n_args, n_kw, args2);
|
||
m_del(mp_obj_t, args2, 2 + n_args + 2 * n_kw);
|
||
}
|
||
if (init_ret != mp_const_none) {
|
||
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
||
mp_raise_msg(&mp_type_TypeError, "__init__() should return None");
|
||
} else {
|
||
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
||
"__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
return MP_OBJ_FROM_PTR(o);
|
||
}
|
||
|
||
const qstr mp_unary_op_method_name[] = {
|
||
[MP_UNARY_OP_BOOL] = MP_QSTR___bool__,
|
||
[MP_UNARY_OP_LEN] = MP_QSTR___len__,
|
||
[MP_UNARY_OP_HASH] = MP_QSTR___hash__,
|
||
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
||
[MP_UNARY_OP_POSITIVE] = MP_QSTR___pos__,
|
||
[MP_UNARY_OP_NEGATIVE] = MP_QSTR___neg__,
|
||
[MP_UNARY_OP_INVERT] = MP_QSTR___invert__,
|
||
#endif
|
||
[MP_UNARY_OP_NOT] = MP_QSTR_, // don't need to implement this, used to make sure array has full size
|
||
};
|
||
|
||
STATIC mp_obj_t instance_unary_op(mp_uint_t op, mp_obj_t self_in) {
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
qstr op_name = mp_unary_op_method_name[op];
|
||
/* Still try to lookup native slot
|
||
if (op_name == 0) {
|
||
return MP_OBJ_NULL;
|
||
}
|
||
*/
|
||
mp_obj_t member[2] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.attr = op_name,
|
||
.meth_offset = offsetof(mp_obj_type_t, unary_op),
|
||
.dest = member,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
if (member[0] == MP_OBJ_SENTINEL) {
|
||
return mp_unary_op(op, self->subobj[0]);
|
||
} else if (member[0] != MP_OBJ_NULL) {
|
||
mp_obj_t val = mp_call_function_1(member[0], self_in);
|
||
// __hash__ must return a small int
|
||
if (op == MP_UNARY_OP_HASH) {
|
||
val = MP_OBJ_NEW_SMALL_INT(mp_obj_get_int_truncated(val));
|
||
}
|
||
return val;
|
||
} else {
|
||
if (op == MP_UNARY_OP_HASH) {
|
||
lookup.attr = MP_QSTR___eq__;
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
if (member[0] == MP_OBJ_NULL) {
|
||
// https://docs.python.org/3/reference/datamodel.html#object.__hash__
|
||
// "User-defined classes have __eq__() and __hash__() methods by default;
|
||
// with them, all objects compare unequal (except with themselves) and
|
||
// x.__hash__() returns an appropriate value such that x == y implies
|
||
// both that x is y and hash(x) == hash(y)."
|
||
return MP_OBJ_NEW_SMALL_INT((mp_uint_t)self_in);
|
||
}
|
||
// "A class that overrides __eq__() and does not define __hash__() will have its __hash__() implicitly set to None.
|
||
// When the __hash__() method of a class is None, instances of the class will raise an appropriate TypeError"
|
||
}
|
||
|
||
return MP_OBJ_NULL; // op not supported
|
||
}
|
||
}
|
||
|
||
const qstr mp_binary_op_method_name[] = {
|
||
/*
|
||
MP_BINARY_OP_OR,
|
||
MP_BINARY_OP_XOR,
|
||
MP_BINARY_OP_AND,
|
||
MP_BINARY_OP_LSHIFT,
|
||
MP_BINARY_OP_RSHIFT,
|
||
*/
|
||
[MP_BINARY_OP_ADD] = MP_QSTR___add__,
|
||
[MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
|
||
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
||
[MP_BINARY_OP_MULTIPLY] = MP_QSTR___mul__,
|
||
[MP_BINARY_OP_FLOOR_DIVIDE] = MP_QSTR___floordiv__,
|
||
[MP_BINARY_OP_TRUE_DIVIDE] = MP_QSTR___truediv__,
|
||
#endif
|
||
/*
|
||
MP_BINARY_OP_MODULO,
|
||
MP_BINARY_OP_POWER,
|
||
MP_BINARY_OP_DIVMOD,
|
||
MP_BINARY_OP_INPLACE_OR,
|
||
MP_BINARY_OP_INPLACE_XOR,
|
||
MP_BINARY_OP_INPLACE_AND,
|
||
MP_BINARY_OP_INPLACE_LSHIFT,
|
||
MP_BINARY_OP_INPLACE_RSHIFT,*/
|
||
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
||
[MP_BINARY_OP_INPLACE_ADD] = MP_QSTR___iadd__,
|
||
[MP_BINARY_OP_INPLACE_SUBTRACT] = MP_QSTR___isub__,
|
||
#endif
|
||
/*MP_BINARY_OP_INPLACE_MULTIPLY,
|
||
MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
|
||
MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
|
||
MP_BINARY_OP_INPLACE_MODULO,
|
||
MP_BINARY_OP_INPLACE_POWER,*/
|
||
[MP_BINARY_OP_LESS] = MP_QSTR___lt__,
|
||
[MP_BINARY_OP_MORE] = MP_QSTR___gt__,
|
||
[MP_BINARY_OP_EQUAL] = MP_QSTR___eq__,
|
||
[MP_BINARY_OP_LESS_EQUAL] = MP_QSTR___le__,
|
||
[MP_BINARY_OP_MORE_EQUAL] = MP_QSTR___ge__,
|
||
/*
|
||
MP_BINARY_OP_NOT_EQUAL, // a != b calls a == b and inverts result
|
||
*/
|
||
[MP_BINARY_OP_IN] = MP_QSTR___contains__,
|
||
/*
|
||
MP_BINARY_OP_IS,
|
||
*/
|
||
[MP_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
|
||
};
|
||
|
||
STATIC mp_obj_t instance_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
|
||
// Note: For ducktyping, CPython does not look in the instance members or use
|
||
// __getattr__ or __getattribute__. It only looks in the class dictionary.
|
||
mp_obj_instance_t *lhs = MP_OBJ_TO_PTR(lhs_in);
|
||
qstr op_name = mp_binary_op_method_name[op];
|
||
/* Still try to lookup native slot
|
||
if (op_name == 0) {
|
||
return MP_OBJ_NULL;
|
||
}
|
||
*/
|
||
mp_obj_t dest[3] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = lhs,
|
||
.attr = op_name,
|
||
.meth_offset = offsetof(mp_obj_type_t, binary_op),
|
||
.dest = dest,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, lhs->base.type);
|
||
if (dest[0] == MP_OBJ_SENTINEL) {
|
||
return mp_binary_op(op, lhs->subobj[0], rhs_in);
|
||
} else if (dest[0] != MP_OBJ_NULL) {
|
||
dest[2] = rhs_in;
|
||
return mp_call_method_n_kw(1, 0, dest);
|
||
} else {
|
||
return MP_OBJ_NULL; // op not supported
|
||
}
|
||
}
|
||
|
||
STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
||
// logic: look in instance members then class locals
|
||
assert(mp_obj_is_instance_type(mp_obj_get_type(self_in)));
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
||
mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
|
||
if (elem != NULL) {
|
||
// object member, always treated as a value
|
||
// TODO should we check for properties?
|
||
dest[0] = elem->value;
|
||
return;
|
||
}
|
||
#if MICROPY_CPYTHON_COMPAT
|
||
if (attr == MP_QSTR___dict__) {
|
||
// Create a new dict with a copy of the instance's map items.
|
||
// This creates, unlike CPython, a 'read-only' __dict__: modifying
|
||
// it will not result in modifications to the actual instance members.
|
||
mp_map_t *map = &self->members;
|
||
mp_obj_t attr_dict = mp_obj_new_dict(map->used);
|
||
for (mp_uint_t i = 0; i < map->alloc; ++i) {
|
||
if (MP_MAP_SLOT_IS_FILLED(map, i)) {
|
||
mp_obj_dict_store(attr_dict, map->table[i].key, map->table[i].value);
|
||
}
|
||
}
|
||
dest[0] = attr_dict;
|
||
return;
|
||
}
|
||
#endif
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.attr = attr,
|
||
.meth_offset = 0,
|
||
.dest = dest,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
mp_obj_t member = dest[0];
|
||
if (member != MP_OBJ_NULL) {
|
||
#if MICROPY_PY_BUILTINS_PROPERTY
|
||
if (MP_OBJ_IS_TYPE(member, &mp_type_property)) {
|
||
// object member is a property; delegate the load to the property
|
||
// Note: This is an optimisation for code size and execution time.
|
||
// The proper way to do it is have the functionality just below
|
||
// in a __get__ method of the property object, and then it would
|
||
// be called by the descriptor code down below. But that way
|
||
// requires overhead for the nested mp_call's and overhead for
|
||
// the code.
|
||
const mp_obj_t *proxy = mp_obj_property_get(member);
|
||
if (proxy[0] == mp_const_none) {
|
||
mp_raise_msg(&mp_type_AttributeError, "unreadable attribute");
|
||
} else {
|
||
dest[0] = mp_call_function_n_kw(proxy[0], 1, 0, &self_in);
|
||
}
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
#if MICROPY_PY_DESCRIPTORS
|
||
// found a class attribute; if it has a __get__ method then call it with the
|
||
// class instance and class as arguments and return the result
|
||
// Note that this is functionally correct but very slow: each load_attr
|
||
// requires an extra mp_load_method_maybe to check for the __get__.
|
||
mp_obj_t attr_get_method[4];
|
||
mp_load_method_maybe(member, MP_QSTR___get__, attr_get_method);
|
||
if (attr_get_method[0] != MP_OBJ_NULL) {
|
||
attr_get_method[2] = self_in;
|
||
attr_get_method[3] = MP_OBJ_FROM_PTR(mp_obj_get_type(self_in));
|
||
dest[0] = mp_call_method_n_kw(2, 0, attr_get_method);
|
||
}
|
||
#endif
|
||
return;
|
||
}
|
||
|
||
// try __getattr__
|
||
if (attr != MP_QSTR___getattr__) {
|
||
mp_obj_t dest2[3];
|
||
mp_load_method_maybe(self_in, MP_QSTR___getattr__, dest2);
|
||
if (dest2[0] != MP_OBJ_NULL) {
|
||
// __getattr__ exists, call it and return its result
|
||
// XXX if this fails to load the requested attr, should we catch the attribute error and return silently?
|
||
dest2[2] = MP_OBJ_NEW_QSTR(attr);
|
||
dest[0] = mp_call_method_n_kw(1, 0, dest2);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
||
#if MICROPY_PY_BUILTINS_PROPERTY || MICROPY_PY_DESCRIPTORS
|
||
// With property and/or descriptors enabled we need to do a lookup
|
||
// first in the class dict for the attribute to see if the store should
|
||
// be delegated.
|
||
// Note: this makes all stores slow... how to fix?
|
||
mp_obj_t member[2] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.attr = attr,
|
||
.meth_offset = 0,
|
||
.dest = member,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
|
||
if (member[0] != MP_OBJ_NULL) {
|
||
#if MICROPY_PY_BUILTINS_PROPERTY
|
||
if (MP_OBJ_IS_TYPE(member[0], &mp_type_property)) {
|
||
// attribute exists and is a property; delegate the store/delete
|
||
// Note: This is an optimisation for code size and execution time.
|
||
// The proper way to do it is have the functionality just below in
|
||
// a __set__/__delete__ method of the property object, and then it
|
||
// would be called by the descriptor code down below. But that way
|
||
// requires overhead for the nested mp_call's and overhead for
|
||
// the code.
|
||
const mp_obj_t *proxy = mp_obj_property_get(member[0]);
|
||
mp_obj_t dest[2] = {self_in, value};
|
||
if (value == MP_OBJ_NULL) {
|
||
// delete attribute
|
||
if (proxy[2] == mp_const_none) {
|
||
// TODO better error message?
|
||
return false;
|
||
} else {
|
||
mp_call_function_n_kw(proxy[2], 1, 0, dest);
|
||
return true;
|
||
}
|
||
} else {
|
||
// store attribute
|
||
if (proxy[1] == mp_const_none) {
|
||
// TODO better error message?
|
||
return false;
|
||
} else {
|
||
mp_call_function_n_kw(proxy[1], 2, 0, dest);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if MICROPY_PY_DESCRIPTORS
|
||
// found a class attribute; if it has a __set__/__delete__ method then
|
||
// call it with the class instance (and value) as arguments
|
||
if (value == MP_OBJ_NULL) {
|
||
// delete attribute
|
||
mp_obj_t attr_delete_method[3];
|
||
mp_load_method_maybe(member[0], MP_QSTR___delete__, attr_delete_method);
|
||
if (attr_delete_method[0] != MP_OBJ_NULL) {
|
||
attr_delete_method[2] = self_in;
|
||
mp_call_method_n_kw(1, 0, attr_delete_method);
|
||
return true;
|
||
}
|
||
} else {
|
||
// store attribute
|
||
mp_obj_t attr_set_method[4];
|
||
mp_load_method_maybe(member[0], MP_QSTR___set__, attr_set_method);
|
||
if (attr_set_method[0] != MP_OBJ_NULL) {
|
||
attr_set_method[2] = self_in;
|
||
attr_set_method[3] = value;
|
||
mp_call_method_n_kw(2, 0, attr_set_method);
|
||
return true;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
if (value == MP_OBJ_NULL) {
|
||
// delete attribute
|
||
mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
|
||
return elem != NULL;
|
||
} else {
|
||
// store attribute
|
||
mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
void mp_obj_instance_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
||
if (dest[0] == MP_OBJ_NULL) {
|
||
mp_obj_instance_load_attr(self_in, attr, dest);
|
||
} else {
|
||
if (mp_obj_instance_store_attr(self_in, attr, dest[1])) {
|
||
dest[0] = MP_OBJ_NULL; // indicate success
|
||
}
|
||
}
|
||
}
|
||
|
||
STATIC mp_obj_t instance_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
mp_obj_t member[2] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.meth_offset = offsetof(mp_obj_type_t, subscr),
|
||
.dest = member,
|
||
.is_type = false,
|
||
};
|
||
uint meth_args;
|
||
if (value == MP_OBJ_NULL) {
|
||
// delete item
|
||
lookup.attr = MP_QSTR___delitem__;
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
meth_args = 2;
|
||
} else if (value == MP_OBJ_SENTINEL) {
|
||
// load item
|
||
lookup.attr = MP_QSTR___getitem__;
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
meth_args = 2;
|
||
} else {
|
||
// store item
|
||
lookup.attr = MP_QSTR___setitem__;
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
meth_args = 3;
|
||
}
|
||
if (member[0] == MP_OBJ_SENTINEL) {
|
||
return mp_obj_subscr(self->subobj[0], index, value);
|
||
} else if (member[0] != MP_OBJ_NULL) {
|
||
mp_obj_t args[3] = {self_in, index, value};
|
||
// TODO probably need to call mp_convert_member_lookup, and use mp_call_method_n_kw
|
||
mp_obj_t ret = mp_call_function_n_kw(member[0], meth_args, 0, args);
|
||
if (value == MP_OBJ_SENTINEL) {
|
||
return ret;
|
||
} else {
|
||
return mp_const_none;
|
||
}
|
||
} else {
|
||
return MP_OBJ_NULL; // op not supported
|
||
}
|
||
}
|
||
|
||
STATIC mp_obj_t mp_obj_instance_get_call(mp_obj_t self_in, mp_obj_t *member) {
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.attr = MP_QSTR___call__,
|
||
.meth_offset = offsetof(mp_obj_type_t, call),
|
||
.dest = member,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
return member[0];
|
||
}
|
||
|
||
bool mp_obj_instance_is_callable(mp_obj_t self_in) {
|
||
mp_obj_t member[2] = {MP_OBJ_NULL, MP_OBJ_NULL};
|
||
return mp_obj_instance_get_call(self_in, member) != MP_OBJ_NULL;
|
||
}
|
||
|
||
mp_obj_t mp_obj_instance_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||
mp_obj_t member[2] = {MP_OBJ_NULL, MP_OBJ_NULL};
|
||
mp_obj_t call = mp_obj_instance_get_call(self_in, member);
|
||
if (call == MP_OBJ_NULL) {
|
||
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
||
mp_raise_msg(&mp_type_TypeError, "object not callable");
|
||
} else {
|
||
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
||
"'%s' object is not callable", mp_obj_get_type_str(self_in)));
|
||
}
|
||
}
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
if (call == MP_OBJ_SENTINEL) {
|
||
return mp_call_function_n_kw(self->subobj[0], n_args, n_kw, args);
|
||
}
|
||
|
||
return mp_call_method_self_n_kw(member[0], member[1], n_args, n_kw, args);
|
||
}
|
||
|
||
STATIC mp_obj_t instance_getiter(mp_obj_t self_in) {
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
mp_obj_t member[2] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.attr = MP_QSTR___iter__,
|
||
.meth_offset = offsetof(mp_obj_type_t, getiter),
|
||
.dest = member,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
if (member[0] == MP_OBJ_NULL) {
|
||
return MP_OBJ_NULL;
|
||
} else if (member[0] == MP_OBJ_SENTINEL) {
|
||
mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
|
||
return type->getiter(self->subobj[0]);
|
||
} else {
|
||
return mp_call_method_n_kw(0, 0, member);
|
||
}
|
||
}
|
||
|
||
STATIC mp_int_t instance_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
|
||
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
||
mp_obj_t member[2] = {MP_OBJ_NULL};
|
||
struct class_lookup_data lookup = {
|
||
.obj = self,
|
||
.attr = MP_QSTR_, // don't actually look for a method
|
||
.meth_offset = offsetof(mp_obj_type_t, buffer_p.get_buffer),
|
||
.dest = member,
|
||
.is_type = false,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self->base.type);
|
||
if (member[0] == MP_OBJ_SENTINEL) {
|
||
mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
|
||
return type->buffer_p.get_buffer(self->subobj[0], bufinfo, flags);
|
||
} else {
|
||
return 1; // object does not support buffer protocol
|
||
}
|
||
}
|
||
|
||
/******************************************************************************/
|
||
// type object
|
||
// - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
|
||
// - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
|
||
// - creating a new class (a new type) creates a new mp_obj_type_t
|
||
|
||
STATIC void type_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
||
(void)kind;
|
||
mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
|
||
mp_printf(print, "<class '%q'>", self->name);
|
||
}
|
||
|
||
STATIC mp_obj_t type_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||
(void)type_in;
|
||
|
||
mp_arg_check_num(n_args, n_kw, 1, 3, false);
|
||
|
||
switch (n_args) {
|
||
case 1:
|
||
return MP_OBJ_FROM_PTR(mp_obj_get_type(args[0]));
|
||
|
||
case 3:
|
||
// args[0] = name
|
||
// args[1] = bases tuple
|
||
// args[2] = locals dict
|
||
return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
|
||
|
||
default:
|
||
mp_raise_msg(&mp_type_TypeError, "type takes 1 or 3 arguments");
|
||
}
|
||
}
|
||
|
||
STATIC mp_obj_t type_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||
// instantiate an instance of a class
|
||
|
||
mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
||
if (self->make_new == NULL) {
|
||
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
||
mp_raise_msg(&mp_type_TypeError, "cannot create instance");
|
||
} else {
|
||
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
||
"cannot create '%q' instances", self->name));
|
||
}
|
||
}
|
||
|
||
// make new instance
|
||
mp_obj_t o = self->make_new(self, n_args, n_kw, args);
|
||
|
||
// return new instance
|
||
return o;
|
||
}
|
||
|
||
STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
||
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
|
||
mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
||
if (dest[0] == MP_OBJ_NULL) {
|
||
// load attribute
|
||
#if MICROPY_CPYTHON_COMPAT
|
||
if (attr == MP_QSTR___name__) {
|
||
dest[0] = MP_OBJ_NEW_QSTR(self->name);
|
||
return;
|
||
}
|
||
#endif
|
||
struct class_lookup_data lookup = {
|
||
.obj = (mp_obj_instance_t*)self,
|
||
.attr = attr,
|
||
.meth_offset = 0,
|
||
.dest = dest,
|
||
.is_type = true,
|
||
};
|
||
mp_obj_class_lookup(&lookup, self);
|
||
} else {
|
||
// delete/store attribute
|
||
|
||
// TODO CPython allows STORE_ATTR to a class, but is this the correct implementation?
|
||
|
||
if (self->locals_dict != NULL) {
|
||
assert(self->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
|
||
mp_map_t *locals_map = &self->locals_dict->map;
|
||
if (dest[1] == MP_OBJ_NULL) {
|
||
// delete attribute
|
||
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
|
||
// note that locals_map may be in ROM, so remove will fail in that case
|
||
if (elem != NULL) {
|
||
dest[0] = MP_OBJ_NULL; // indicate success
|
||
}
|
||
} else {
|
||
// store attribute
|
||
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
|
||
// note that locals_map may be in ROM, so add will fail in that case
|
||
if (elem != NULL) {
|
||
elem->value = dest[1];
|
||
dest[0] = MP_OBJ_NULL; // indicate success
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
const mp_obj_type_t mp_type_type = {
|
||
{ &mp_type_type },
|
||
.name = MP_QSTR_type,
|
||
.print = type_print,
|
||
.make_new = type_make_new,
|
||
.call = type_call,
|
||
.unary_op = mp_generic_unary_op,
|
||
.attr = type_attr,
|
||
};
|
||
|
||
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
|
||
assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now
|
||
assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now
|
||
|
||
// TODO might need to make a copy of locals_dict; at least that's how CPython does it
|
||
|
||
// Basic validation of base classes
|
||
mp_uint_t len;
|
||
mp_obj_t *items;
|
||
mp_obj_tuple_get(bases_tuple, &len, &items);
|
||
for (uint i = 0; i < len; i++) {
|
||
assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
|
||
mp_obj_type_t *t = MP_OBJ_TO_PTR(items[i]);
|
||
// TODO: Verify with CPy, tested on function type
|
||
if (t->make_new == NULL) {
|
||
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
||
mp_raise_msg(&mp_type_TypeError, "type is not an acceptable base type");
|
||
} else {
|
||
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
||
"type '%q' is not an acceptable base type", t->name));
|
||
}
|
||
}
|
||
}
|
||
|
||
mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
|
||
o->base.type = &mp_type_type;
|
||
o->name = name;
|
||
o->print = instance_print;
|
||
o->make_new = mp_obj_instance_make_new;
|
||
o->call = mp_obj_instance_call;
|
||
o->unary_op = instance_unary_op;
|
||
o->binary_op = instance_binary_op;
|
||
o->attr = mp_obj_instance_attr;
|
||
o->subscr = instance_subscr;
|
||
o->getiter = instance_getiter;
|
||
//o->iternext = ; not implemented
|
||
o->buffer_p.get_buffer = instance_get_buffer;
|
||
// Inherit protocol from a base class. This allows to define an
|
||
// abstract base class which would translate C-level protocol to
|
||
// Python method calls, and any subclass inheriting from it will
|
||
// support this feature.
|
||
if (len > 0) {
|
||
o->protocol = ((mp_obj_type_t*)MP_OBJ_TO_PTR(items[0]))->protocol;
|
||
}
|
||
o->bases_tuple = MP_OBJ_TO_PTR(bases_tuple);
|
||
o->locals_dict = MP_OBJ_TO_PTR(locals_dict);
|
||
|
||
const mp_obj_type_t *native_base;
|
||
uint num_native_bases = instance_count_native_bases(o, &native_base);
|
||
if (num_native_bases > 1) {
|
||
mp_raise_msg(&mp_type_TypeError, "multiple bases have instance lay-out conflict");
|
||
}
|
||
|
||
mp_map_t *locals_map = &o->locals_dict->map;
|
||
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(MP_QSTR___new__), MP_MAP_LOOKUP);
|
||
if (elem != NULL) {
|
||
// __new__ slot exists; check if it is a function
|
||
if (MP_OBJ_IS_FUN(elem->value)) {
|
||
// __new__ is a function, wrap it in a staticmethod decorator
|
||
elem->value = static_class_method_make_new(&mp_type_staticmethod, 1, 0, &elem->value);
|
||
}
|
||
}
|
||
|
||
return MP_OBJ_FROM_PTR(o);
|
||
}
|
||
|
||
/******************************************************************************/
|
||
// super object
|
||
|
||
typedef struct _mp_obj_super_t {
|
||
mp_obj_base_t base;
|
||
mp_obj_t type;
|
||
mp_obj_t obj;
|
||
} mp_obj_super_t;
|
||
|
||
STATIC void super_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
||
(void)kind;
|
||
mp_obj_super_t *self = MP_OBJ_TO_PTR(self_in);
|
||
mp_print_str(print, "<super: ");
|
||
mp_obj_print_helper(print, self->type, PRINT_STR);
|
||
mp_print_str(print, ", ");
|
||
mp_obj_print_helper(print, self->obj, PRINT_STR);
|
||
mp_print_str(print, ">");
|
||
}
|
||
|
||
STATIC mp_obj_t super_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||
(void)type_in;
|
||
// 0 arguments are turned into 2 in the compiler
|
||
// 1 argument is not yet implemented
|
||
mp_arg_check_num(n_args, n_kw, 2, 2, false);
|
||
return mp_obj_new_super(args[0], args[1]);
|
||
}
|
||
|
||
STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
||
if (dest[0] != MP_OBJ_NULL) {
|
||
// not load attribute
|
||
return;
|
||
}
|
||
|
||
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
|
||
mp_obj_super_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
||
assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
|
||
|
||
mp_obj_type_t *type = MP_OBJ_TO_PTR(self->type);
|
||
|
||
// for a const struct, this entry might be NULL
|
||
if (type->bases_tuple == NULL) {
|
||
return;
|
||
}
|
||
|
||
mp_uint_t len = type->bases_tuple->len;
|
||
mp_obj_t *items = type->bases_tuple->items;
|
||
struct class_lookup_data lookup = {
|
||
.obj = MP_OBJ_TO_PTR(self->obj),
|
||
.attr = attr,
|
||
.meth_offset = 0,
|
||
.dest = dest,
|
||
.is_type = false,
|
||
};
|
||
for (uint i = 0; i < len; i++) {
|
||
assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
|
||
mp_obj_class_lookup(&lookup, (mp_obj_type_t*)MP_OBJ_TO_PTR(items[i]));
|
||
if (dest[0] != MP_OBJ_NULL) {
|
||
return;
|
||
}
|
||
}
|
||
mp_obj_class_lookup(&lookup, &mp_type_object);
|
||
}
|
||
|
||
const mp_obj_type_t mp_type_super = {
|
||
{ &mp_type_type },
|
||
.name = MP_QSTR_super,
|
||
.print = super_print,
|
||
.make_new = super_make_new,
|
||
.attr = super_attr,
|
||
};
|
||
|
||
mp_obj_t mp_obj_new_super(mp_obj_t type, mp_obj_t obj) {
|
||
mp_obj_super_t *o = m_new_obj(mp_obj_super_t);
|
||
*o = (mp_obj_super_t){{&mp_type_super}, type, obj};
|
||
return MP_OBJ_FROM_PTR(o);
|
||
}
|
||
|
||
/******************************************************************************/
|
||
// subclassing and built-ins specific to types
|
||
|
||
// object and classinfo should be type objects
|
||
// (but the function will fail gracefully if they are not)
|
||
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
|
||
for (;;) {
|
||
if (object == classinfo) {
|
||
return true;
|
||
}
|
||
|
||
// not equivalent classes, keep searching base classes
|
||
|
||
// object should always be a type object, but just return false if it's not
|
||
if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
|
||
return false;
|
||
}
|
||
|
||
const mp_obj_type_t *self = MP_OBJ_TO_PTR(object);
|
||
|
||
// for a const struct, this entry might be NULL
|
||
if (self->bases_tuple == NULL) {
|
||
return false;
|
||
}
|
||
|
||
// get the base objects (they should be type objects)
|
||
mp_uint_t len = self->bases_tuple->len;
|
||
mp_obj_t *items = self->bases_tuple->items;
|
||
if (len == 0) {
|
||
return false;
|
||
}
|
||
|
||
// iterate through the base objects
|
||
for (uint i = 0; i < len - 1; i++) {
|
||
if (mp_obj_is_subclass_fast(items[i], classinfo)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// search last base (simple tail recursion elimination)
|
||
object = items[len - 1];
|
||
}
|
||
}
|
||
|
||
STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) {
|
||
mp_uint_t len;
|
||
mp_obj_t *items;
|
||
if (MP_OBJ_IS_TYPE(classinfo, &mp_type_type)) {
|
||
len = 1;
|
||
items = &classinfo;
|
||
} else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
|
||
mp_obj_tuple_get(classinfo, &len, &items);
|
||
} else {
|
||
mp_raise_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes");
|
||
}
|
||
|
||
for (uint i = 0; i < len; i++) {
|
||
// We explicitly check for 'object' here since no-one explicitly derives from it
|
||
if (items[i] == MP_OBJ_FROM_PTR(&mp_type_object) || mp_obj_is_subclass_fast(object, items[i])) {
|
||
return mp_const_true;
|
||
}
|
||
}
|
||
return mp_const_false;
|
||
}
|
||
|
||
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
|
||
if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
|
||
mp_raise_msg(&mp_type_TypeError, "issubclass() arg 1 must be a class");
|
||
}
|
||
return mp_obj_is_subclass(object, classinfo);
|
||
}
|
||
|
||
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);
|
||
|
||
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
|
||
return mp_obj_is_subclass(MP_OBJ_FROM_PTR(mp_obj_get_type(object)), classinfo);
|
||
}
|
||
|
||
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
|
||
|
||
mp_obj_t mp_instance_cast_to_native_base(mp_const_obj_t self_in, mp_const_obj_t native_type) {
|
||
mp_obj_type_t *self_type = mp_obj_get_type(self_in);
|
||
if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(self_type), native_type)) {
|
||
return MP_OBJ_NULL;
|
||
}
|
||
mp_obj_instance_t *self = (mp_obj_instance_t*)MP_OBJ_TO_PTR(self_in);
|
||
return self->subobj[0];
|
||
}
|
||
|
||
/******************************************************************************/
|
||
// staticmethod and classmethod types (probably should go in a different file)
|
||
|
||
STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||
assert(self == &mp_type_staticmethod || self == &mp_type_classmethod);
|
||
|
||
mp_arg_check_num(n_args, n_kw, 1, 1, false);
|
||
|
||
mp_obj_static_class_method_t *o = m_new_obj(mp_obj_static_class_method_t);
|
||
*o = (mp_obj_static_class_method_t){{self}, args[0]};
|
||
return MP_OBJ_FROM_PTR(o);
|
||
}
|
||
|
||
const mp_obj_type_t mp_type_staticmethod = {
|
||
{ &mp_type_type },
|
||
.name = MP_QSTR_staticmethod,
|
||
.make_new = static_class_method_make_new,
|
||
};
|
||
|
||
const mp_obj_type_t mp_type_classmethod = {
|
||
{ &mp_type_type },
|
||
.name = MP_QSTR_classmethod,
|
||
.make_new = static_class_method_make_new,
|
||
};
|