01cabb0324
Boosted performance, board.json metadata, more mimxrt, rp2, samd features
This release of MicroPython sees a boost to the overall performance of the
VM and runtime. This is achieved by the addition of an optional cache to
speed up general hash table lookups, as well as a fast path in the VM for
the LOAD_ATTR opcode on instance types. The new configuration options are
MICROPY_OPT_MAP_LOOKUP_CACHE and MICROPY_OPT_LOAD_ATTR_FAST_PATH. As part
of this improvement the MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE option has
been removed, which provided a similar map caching mechanism but with the
cache stored in the bytecode, which made it not useful on bare metal ports.
The new mechanism is measured to be at least as good as the old one,
applies to more map lookups, has a constant RAM overhead, and applies to
native code as well as bytecode.
These performance options are enabled on the esp32, mimxrt, rp2, stm32 and
unix ports. For esp32 and mimxrt some code is also moved to RAM to further
boost performance. On stm32, performance increases by about 20% for
benchmarks that are heavy on name lookups, like misc_pystone.py and
misc_raytrace.py. On esp32 performance can increase by 2-3x, and on mimxrt
it is up to 6x.
All boards in all ports now have a board.json metadata file, which is used
to automatically build firmware and generate a webpage for that board
(among other possibilities). Auto-build scripts have been added for this
purpose and they build all esp32, mimxrt, rp2, samd and stm32 boards. The
generated output is available at https://micropython.org/download.
Support for FROZEN_DIR and FROZEN_MPY_DIR has been deprecated for some time
and was finally removed in this release. Instead of these, FROZEN_MANIFEST
can be used. The io.resource_stream() function is also removed, replaced
by the pure Python version in micropython-lib.
The search order for importing frozen Python modules is now controlled by
the ".frozen" entry in sys.path. This string is added by default in the
second position in sys.path. User code should adjust sys.path depending on
the desired behaviour. Putting ".frozen" first in sys.path will speed up
importing frozen modules.
A bug in multiple precision integers with bitwise of -0 was fixed in commit
2c139bbf4e
.
The platform module has been added to allow querying the compiler and
underlying SDK/HAL/libc version. This is enabled on esp32, mimxrt and
stm32 ports.
The mpremote tool now supports seek, flush, mkdir and rmdir on PC-mounted
filesystems. And a help command has been added.
The documentation has seen many additions and improvements thanks (for a
second time) to the Google Season of Docs project. The rp2 documentation
now includes a reference for PIO assembly instructions, a PIO quick
reference and a PIO tutorial. The random and stm modules have been
documented, along with sys.settrace, manifest.py files and mpremote. There
is also now more detail about the differences between MicroPython and
standard Python 3.5 and above.
The esp32 port sees support for ESP32-S3 SoCs, and new boards GENERIC_S3,
ESP32_S2_WROVER, LOLIN_S2_MINI, LOLIN_S2_PICO and UM_FEATHERS2NEO. The PWM
driver has been improved and now supports all PWM timers and channels, and
the duty_u16() and duty_ns() methods, and it keeps the duty constant when
changing frequency. The machine.bitstream() function has been improved to
use RMT, with an option to select the original bit-banging implementation.
The mimxrt port gained new hardware features: SDRAM and SD card support, as
well as network integration with a LAN driver. The machine.WDT class was
added along with the machine.reset_cause(), machine.soft_reset(),
machine.unique_id() add machine.bitstream() functions. DHT sensor support
was added, and f-strings were enabled.
The rp2 port now has support for networking, and bluetooth using NimBLE.
The Nina-W10 WiFi/BT driver is fully integrated and supported by the new
Arduino Nano RP2040 connect board. I2S protocol support is added along
with a machine.bitstream() driver and DHT sensor support. The PWM driver
had a bug fix with the accuracy of setting/getting the frequency, and the
duty value is now retained when changing the frequency.
On the samd port there is now support for the internal flash being a block
device, and for filesystems and the os module. Pin and LED classes have
been implemented. There are more time functions, more Python features
enabled, and the help() function is added. SEEED_WIO_TERMINAL and
SEEED_XIAO board definitions are now available.
The stm32 port now has support for F427, F479 and H7A3(Q)/H7B3(Q) MCUs, and
new board definitions for VCC_GND_H743VI, OLIMEX_H407, MIKROE_QUAIL,
GARATRONIC_PYBSTICK26_F411, STM32H73B3I_DK. A bug was fixed in the SPI
driver where a SPI transfer could fail if the CYW43 WiFi driver was also
active at the same time.
On the windows port the help() function has been enabled, and support for
build variants added, to match the unix port.
The zephyr port upgraded Zephyr to v2.7.0.
The change in code size since the previous release for various ports is
(absolute and percentage change in the text section):
bare-arm: -1520 -2.605%
minimal x86: -2256 -1.531%
unix x64: -457 -0.089%
unix nanbox: -925 -0.204%
stm32: +312 +0.079% PYBV10
cc3200: -176 -0.096%
esp8266: +532 +0.076% GENERIC
esp32: +27096 +1.820% GENERIC
nrf: -212 -0.121% pca10040
rp2: +9904 +2.051% PICO
samd: +35332 +33.969% ADAFRUIT_ITSYBITSY_M4_EXPRESS
The changes that dominate these numbers are:
- bare-arm, minimal: use of new MICROPY_CONFIG_ROM_LEVEL_MINIMUM option and
subsequent disabling of remaining optional features
- unix, cc3200, nrf: general code size reductions of the core
- stm32: performance improvements, addition of platform module
- esp8266: enabling f-strings
- esp32: use of -O2 instead of -Os
- rp2: machine.I2S and other new hardware features
- samd: filesystem support and other new hardware features
Thanks to everyone who contributed to this release: Alan Dragomirecký,
Alexey Shvetsov, Andrew Leech, Andrew Scheller, Antoine Aubert, Boris
Vinogradov, Chris Boudacoff, Chris Fiege, Christian Decker, Damien George,
Daniel Gorny, Dave Hylands, David Michieli, Emilie Feral, Frédéric Pierson,
gibbonsc, Henk Vergonet, iabdalkader, Ihor Nehrutsa, Jan Hrudka, Jan Staal,
jc_.kim, Jim Mussared, Jonathan Hogg, Laurens Valk, leo chung, Lorenzo
Cappelletti, Magnus von Wachenfeldt, Matt Trentini, Matt van de Werken,
Maureen Helm, Michael Bentley, Michael Buesch, Mike Causer, Mike Teachman,
Mike Wadsten, Ned Konz, NitiKaur, oli, patrick, Patrick Van Oosterwijck,
Peter Boin, Peter Hinch, Peter van der Burg, Philipp Ebensberger, Pooya
Moradi, retsyo, robert-hh, roland van straten, Scott Armitage, Sebastian
Wicki, Seon Rozenblum, Sergei Silnov, Simon Baatz, Stewart Bonnick, stijn,
Tobias Thyrrestrup, Tomas Vanek, YoungJoon Chun.
What follows is a detailed list of changes, generated from the git commit
history, and organised into sections.
Main components
===============
all:
- remove MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE
- update Python formatting to latest Black version 21.12b0
- remove support for FROZEN_DIR and FROZEN_MPY_DIR
py core:
- parse: simplify parse nodes representing a list
- emitnative: ensure load_subscr does not clobber existing REG_RET
- mpconfig.h: define initial templates for "feature levels"
- vm: add a fast path for LOAD_ATTR on instance types
- map: add an optional cache of (map+index) to speed up map lookups
- builtinimport: forward all debug printing to MICROPY_DEBUG_PRINTER
- add wrapper macros so hot VM functions can go in fast code location
- runtime: fix crash when exc __new__ doesn't return an exc instance
- mpconfig.h: define the "extra" feature level
- mpconfig.h: revert MICROPY_REPL_INFO to disabled at all levels
- gc: add hook to run code during time consuming GC operations
- showbc: print unary-op string when dumping bytecode
- modsys: replace non-ASCII quote char with ASCII char
- runtime: allow types to use both .attr and .locals_dict
- lexer: support nested [] and {} characters within f-string params
- objfun.h: remove obsolete comments about entries in extra_args
- builtinimport: refactor module importing
- showbc: fix printing of raw bytecode header on nanbox builds
- modio: remove io.resource_stream function
- only search frozen modules when '.frozen' is found in sys.path
- mkrules.cmake: set frozen preprocessor defs early
- runtime: allow initialising sys.path/argv with defaults
- mpstate.h: only include sys.path/argv objects in state when enabled
- mpz: fix bugs with bitwise of -0 by ensuring all 0's are positive
- qstr: reset mpstate.qstr_last_chunk before raising an error
- modbuiltins: add additional macro for extending builtins
- mpconfig.h: define MICROPY_PY_USSL_FINALISER only if not defined
extmod:
- machine_i2c: make SoftI2C configurable via macro option
- machine_spi: make SoftSPI configurable via macro option
- modonewire: make _onewire module configurable via macro option
- machine_pwm: factor out machine.PWM bindings to common code
- move modnetwork and modusocket from stm32 to extmod
- modnetwork: add STA_IF and AP_IF constants
- modnetwork: add extended socket state
- modusocket: add read/write stream methods to socket object
- modnetwork: define network interfaces in port config files
- network_cyw43: make consistent use of STA and AP constants
- modnetwork: remove STM32 references
- modnetwork: remove modnetwork socket u_state member
- mpbthci.h: add mp_bluetooth_hci_uart_any prototype
- nimble: add nimble CMake fragment file
- add platform module
- moduplatform: improve implementation for PC ports
- vfs_posix_file: support MP_STREAM_POLL in vfs_posix_file_ioctl
- modbluetooth: add connection interval to gap_connect
- nimble: update to NimBLE v1.4
- nimble: remove workaround for OS_ENOMEM
- uasyncio: fix gather returning exceptions from a cancelled task
- uplatform: remove unused definitions
- uplatform: use generic custom platform string
- network_ninaw10: fix scan list order to match other NICs
- modbluetooth: support gap_connect(None) to cancel a connection
- modure: redirect regex debug printing to mp_printf
- network_ninaw10: fix config of AP mode
- network_ninaw10: disable active connections before connecting
- network_ninaw10: make NIC state persistent
- network_ninaw10: return -1 on timeout from recv/send
- network_ninaw10: make recv/recvfrom interchangeable
- moduplatform: detect xtensa arch
- modusocket: allow setting timeout on unbound sockets
- modusocket: initialise accepted socket state
- network_ninaw10: use socket timeout preset in modusocket
- modbluetooth: fix conditional compilation of ringbuf_put_uuid
- modbluetooth: put declaration of connect_cancel in correct place
shared:
- libc/string0: don't include string.h, and provide __memcpy_chk
- runtime/pyexec: cleanup EXEC_FLAG flag constants
drivers:
- ninaw10: add ublox Nina-W10 WiFi/BT module driver
- lsm6dsox: add LSM6DSOX driver and examples
- neopixel: avoid heap alloc in fill()
- ninaw10: fix BSSID byte order, and add null byte to ESSID
- ninaw10/nina_wifi_drv: fix DNS resolution
mpy-cross: no changes specific to this component/port
lib:
- mynewt-nimble: switch to the MicroPython fork of NimBLE
- asf4: point submodule to latest commit on circuitpython branch
- update pico-sdk to 1.3.0 and tinyusb to 0.12.0
- stm32lib: update library for L4 v1.17.0, new G4, WL, and MMC fixes
- stm32lib: update library for fix to F7 USB HS
Support components
==================
docs:
- library/os.rst: clarify littlefs requirements for block erase
- library/bluetooth.rst: update incorrect link to gatts_write
- make.bat: change Windows output dir from '_build' to 'build'
- library/machine.I2S.rst: specify that I2S.shift args are kw-only
- esp32: explain ESP32 PWM modes, timers, and channels
- rp2: add reference for PIO assembly instructions, and PIO tutorial
- library/random.rst: document the random module
- reference/mpremote.rst: add docs for mpremote
- reference/manifest.rst: add docs for manifest.py files
- library/stm.rst: document the stm module
- esp32/tutorial: add an example of peripheral control via regs
- rp2/general.rst: fix typo with missing spaces
- library/framebuf.rst: adjust dimensions in example
- library/rp2.rst: update function asm_pio_encode to add sideset_opt
- reference/filesystem.rst: add detail on how to use littlefs fuse
- rp2/quickref.rst: add section on PIO
- library/sys.rst: add docs for sys.settrace
- esp8266/tutorial: fix comments of FrameBuffer examples
- library/uasyncio.rst: detail exception behaviour in cancel/timeout
- library/machine.Timer.rst: document 'id' as positional-only arg
- library/machine.SPI.rst: add example SPI usage
- library/machine.Timer.rst: document `period` and `callback` args
- library/machine.Pin.rst: add Pin.ANALOG mode constant
- remove trailing spaces and convert tabs to spaces
- library/sys.rst: add note about '.frozen' as an entry in sys.path
- differences: document details of new PEPs/features in Python 3.5+
- update copyright year range to include 2022
- esp32: update RMT quickref example to match latest code
examples: no changes specific to this component/port
tests:
- perf_bench: use math.log instead of math.log2
- basics: add tests for type-checking subclassed exc instances
- micropython/const.py: add comment about required config for test
- cpydiff: clarify f-string diffs regarding concatenation
- basics/int_big_cmp.py: add more tests for big-int comparison
- extmod: skip uselect_poll_udp when poll() is not available
tools:
- autobuild: add auto build for GENERIC_C3_USB
- ci.sh: use IDF v4.4 as part of esp32 CI and build GENERIC_S3
- autobuild: add the MIMXRT1010_EVK board to autobuild
- ci.sh: use a specific ESP IDF v4.4 commit
- autobuild: add script to generate website board metadata
- dfu.py: make tool work with python3 when parsing DFU files
- autobuild: automatically build all mimxrt, rp2 and samd boards
- autobuild: automatically build all stm32 boards
- mpremote: implement seek and flush in ioctl method
- autobuild: automatically build all esp32 boards
- upip.py: support == to specify exact package version
- makemanifest.py: make str conversion compatible with Python 2
- makemanifest.py: merge make-frozen.py
- mpremote: add mkdir and rmdir to RemoteFS
- mpremote: add help command
- mpremote: add link to mpremote docs URL in help message
- upip.py: skip '.frozen' entry in sys.path for install path
- autobuild: build esp8266 OTA image with GENERIC_1M board
- ci.sh: upgrade Zephyr docker image to v0.21.0
- ci.sh: build zephyr nucleo_wb55rg to test zephyr bluetooth build
CI:
- workflows: use Python 3.8 for macos workflow
- workflows: add new workflow to build ports download metadata
The ports
=========
all ports:
- add board.json for all boards
- add images, features and urls to board.json
- add '.frozen' as the first entry in sys.path
- move '.frozen' to second entry in sys.path
bare-arm port:
- mpconfigport.h: use MICROPY_CONFIG_ROM_LEVEL_MINIMUM
- mpconfigport.h: disable remaining optional features
cc3200 port: no changes specific to this component/port
esp8266 port:
- boards/GENERIC: enable f-strings
- extract qstr from object when comparing keys in config()
- etshal.h: remove unneeded function declarations
- allow building a board to any dest directory
esp32 port:
- boards: add new FeatherS2-Neo board definition
- machine_timer: use tx_update member for IDF 4.4 and above
- add support for ESP32-S3 SoCs
- boards: add new GENERIC_S3 board definition
- machine_hw_spi: fix hardware SPI DMA channels for S2/S3
- boards: add board definition for ESP32-S2-WROVER module
- boards: add LOLIN_S2_MINI ESP32-S2 board
- machine_pwm: add support for all PWM timers and channels
- README: updated readme with req IDF vers for ESP32-S2, C3 and S3
- usb: add USB host connection detection for CDC serial output
- machine_pin: block out IO16 and IO17 when using SPIRAM on ESP32
- mpthreadport: fix TCB cleanup function so thread_mutex is ready
- main: add option for a board to hook code into startup sequence
- split out WLAN code from modnetwork.c to network_wlan.c
- enable optimisations and move code to iRAM to boost performance
- usb: improve speed of USB CDC output
- add specific deploy_s2.md instructions for esp32-s2
- boards/LOLIN_S2_MINI: add image to board.json
- boards: update board and deploy metadata for UM_xxx boards
- usb: further improve speed of USB CDC output
- boards/LOLIN_S2_PICO: add LOLIN_S2_PICO board definition files
- boards/ESP32_S2_WROVER: link to specific deploy_s2 instructions
- support building with latest IDF v5
- in machine_i2s, send null samples in underflow situations
- in machine_i2s, make object reference arrays root pointers
- add SDCard support for S3, and a GENERIC_S3_SPIRAM board
- boards/GENERIC_S3: enable BLE on ESP32 S3
- machine_pwm: implement duty_u16() and duty_ns() PWM methods
- extract qstr from object when comparing keys in config()
- machine_pin: make GPIO 26 usable for S2,S3 if SPIRAM not config'd
- machine_hw_spi: fix SPI default pins reordering on ESP32-S2/S3
- machine_hw_spi: set proper default SPI(id=1) pins on S2,S3 and C3
- machine_hw_spi: set proper default SPI(id=2) pins on S2 and S3
- boards: remove SPI pin defaults from GENERIC S2/S3 boards
- modnetwork: synchronize WiFi AUTH_xxx constants with IDF values
- machine_pwm: keep duty constant when changing frequency
- machine_bitstream: replace bit-bang code with RMT-based driver
- machine_i2s: add support for ESP-IDF 4.4
- machine_bitstream: fix signal duplication on output pins
- esp32: enable platform module with IDF version
- boards/GENERIC_D2WD: build with -Os optimisation
- esp32_rmt: install RMT driver on core 1
- machine_bitstream: reinstate bitstream bit-bang implementation
javascript port: no changes specific to this component/port
mimxrt port:
- sdcard: implement SDCard driver
- machine_bitstream: add bitstream function to machine module
- rework flash configuration
- sdram: add SDRAM support
- eth: add LAN support and integrate the network module
- modmachine: implement machine.WDT() and machine.reset_cause()
- boards: fix the D14/D15 pin assignment of MIMXRT1050/60/64_EVK
- hal: remove duplicate definitions from flexspi_hyper_flash.h
- dma_channel: fix the DMA channel management
- fix cycle counter for time.ticks_cpu() and machine.bitstream()
- add dht_readinto() to the mimxrt module, and freeze dht.py
- extend the help() message and README.md
- mpconfigport.h: enable f-strings
- modmachine: implement soft_reset() and unique_id() functions
- boards/make-pins.py: allow empty lines and comments in pins.csv
- optimize the runtime speed
- enable the platform module
- boards: add the Seeed ARCH MIX board
- boards: update the board.json files and add deploy_xx.md files
- fix mp_hal_quiet_timing_enter()/exit() so timer still runs
- support PWM using the FLEXPWM and QTMR modules
- define UART 0 on MIMXRT boards
- support selection of PHY type and address
- re-enable eth checksum creation by HW
- fix a tiny unnoticed bug in sdcard.c
- add a driver for the DP83848 PHY device
- refactor the reading of the machine id
- enable ticks_cpu at boot time for NDEBUG builds only
- use -Og instead of -O0 for DEBUG builds
- tidy up the board flash related files
- hal: allow readSampleClkSrc to be configured by a board
- enable MICROPY_PY_USSL_FINALISER
minimal port:
- mpconfigport.h: use MICROPY_CONFIG_ROM_LEVEL_MINIMUM
- Makefile: don't force a 32-bit build
- mpconfigport.h: disable features that are not needed
nrf port:
- Makefile: improve Black Magic Probe commands
- main: use VFS helper function to mount fs and chdir
pic16bit port: no changes specific to this component/port
powerpc port: no changes specific to this component/port
qemu-arm port: no changes specific to this component/port
rp2 port:
- mpconfigport.h: enable heapq module
- add support for bluetooth module using NimBLE
- add framework for networking
- mpconfigport.h: use the "extra" feature level
- enable optimisations (comp goto, map cache, fast attr)
- machine_i2s: add I2S protocol support
- add support for Nina-W10 WiFi/BT module
- boards: add support for Arduino Nano RP2040
- machine_bitstream: implement the machine.bitstream driver
- boards: add neopixel.py to manifest.py
- rp2_pio: support exec with sideset
- boards/PIMORONI_PICOLIPO_16MB: fix 16MB flash size
- boards: add PYBSTICK26 RP2040 board definition
- machine_uart: handle and clear UART RX timeout IRQ
- boards/ARDUINO_NANO_RP2040_CONNECT: set default I2C pins
- machine_pwm: fix PWM frequency setting
- machine_pwm: keep duty value when changing the frequency
- add support for DHT11 and DHT22 sensors
- CMakeLists.txt: allow a board to override PICO_BOARD
- boards/GARATRONIC_PYBSTICK26_RP2040: use correct pico-sdk board cfg
samd port:
- integrate latest asf4, add help, more time funcs and uPy features
- samd_soc: allow a board to configure the low-level MCU config
- add internal flash block device, filesystem and uos support
- add Pin and LED classes, and machine.unique_id
- boards/ADAFRUIT_FEATHER_M0_EXPRESS: update for flash and pins
- boards/ADAFRUIT_ITSYBITSY_M4_EXPRESS: update for flash and pins
- boards/MINISAM_M4: update for flash and pins
- boards/ADAFRUIT_TRINKET_M0: update for flash and pins
- boards/SAMD21_XPLAINED_PRO: update for flash and pins
- boards/SEEED_WIO_TERMINAL: add new board definition
- boards/SEEED_XIAO: add new board definition
- README.md: update README to reflect new features and boards
stm32 port:
- pin: enable GPIO clock of pin if it's constructed without init
- main: don't unconditionally enable GPIO A,B,C,D clocks
- boards/VCC_GND_H743VI: add board definition for VCC_GND_H743VI
- boards/OLIMEX_E407: add Ethernet RMII support
- boards/LEGO_HUB_NO6: remove user paths from cc2564 init file
- boards: remove trailing spaces, and add newline at end of file
- add basic support for STM32H750
- add support for H7A3(Q)/H7B3(Q), and STM32H73B3I_DK board defn
- suggest putting code in main.py not boot.py
- boards/make-pins.py: allow a CPU pin to be hidden
- boards/make-pins.py: allow empty lines and comments in pins.csv
- dma: add functions for external users of DMA to enable clock
- enable LOAD_ATTR fast path, and map lookup caching on >M0
- boards: add OLIMEX H407 board definition
- enable platform module
- extended flash filesystem space to 512K on H743 boards
- boards/NUCLEO_H743ZI: enable VfsLfs2 on NUCLEO_H743ZI(2) boards
- boards: add PF11-BOOT0 to stm32f091_af.csv
- machine_i2c: use hardware I2C for STM32H7
- sdram: enforce gcc opt, and use volatile and DSB in sdram_test
- usbd_cdc_interface: allow a board to hook into USBD CDC RX events
- mpbthciport: allow a board to hook BT HCI poll functions
- pendsv: allow a board to add entries for pendsv_schedule_dispatch
- boards: add images to board.json for Adafruit and VCC_GND boards
- uart: fix race conditions and clearing status in IRQ handler
- mpconfigport.h: use the "extra" feature level
- in machine_i2s, send null samples in underflow situations
- in machine_i2s, make object reference arrays root pointers
- led: support an extra 2 LEDs in board configuration
- boards/MIKROE_CLICKER2_STM32: add more detail to board.json
- boards: add new board MikroElektronika Quail, and F427 support
- main: run optional frozen module at boot
- sdio: don't explicitly disable DMA2 on deinit of SDIO
- dma: make DMA2_Stream3 exclusive to SDIO when CYW43 enabled
- boards: build NUCLEO_WB55 and STM32F769DISC without mboot enabled
- boards: add PYBSTICK26 F411 board definition
- boards/NADHAT_PYBF405: rename board to GARATRONIC_NADHAT_F405
- usb: use a table of allowed values to simplify usb_mode get/set
- boards/NUCLEO_WB55: update rfcore_firmwre for new WS
- flashbdev: support generic flash storage config via link symbols
- boards: convert F413,F439,H743,L4xx,WB55 to new flash FS config
- add support for F479 MCUs
- include HAL MMC code in F4 builds
- boards/make-pins.py: use cpu pins to define static alt-fun macros
- boards/NUCLEO_WB55: fix LED ordering
- boards/LEGO_HUB_NO6: set filesystem label as HUB_NO6
- boards: remove stray '+' characters at start of lines in ld files
- boards: remove unused MICROPY_HW_ENABLE_TIMER config
- boards: enable MICROPY_HW_ENABLE_SERVO on various boards
- update L4 code to build with latest stm32lib and L4 HAL 1.17.0
- main: call sdcard_init when only MICROPY_HW_ENABLE_MMCARD enabled
- sdcard: support 8-bit wide SDIO bus
- sdcard: add config option to force MM card capacity
- factoryreset: init vfs flags before calling pyb_flash_init_vfs
- qspi: fix typo in address comment
- boards/make-pins.py: generate empty ADC table if needed
- boards/OLIMEX_H407: fix typo in OLIMEX H407 board.json
- network_wiznet5k: fix build error with wiznet5k and lwip enabled
- enable MICROPY_PY_USSL_FINALISER
teensy port:
- switch to use manifest.py instead of FROZEN_DIR
unix port:
- enable LOAD_ATTR fast path, and map lookup caching
- modusocket: support MP_STREAM_POLL in unix socket_ioctl
- modos: add support for uos.urandom(n)
- coverage: change remaining printf to mp_printf
- Makefile: use -Og instead of -O0 for debug builds
windows port:
- README: remove unsupported Python instructions for Cygwin
- mpconfigport.h: enable help and help("modules")
- add support for build variants to windows port
- run tests via Makefile
- appveyor: build both standard and dev variants
- appveyor: build mpy-cross only once for mingw-w64
- msvc: run qstr preprocessing phase in parallel
zephyr port:
- mphalport.h: remove unused and unimplemented C-level pin API
- increase minimum CMake version to 3.20.0
- update include path to reboot.h
- get UART console device from devicetree instead of Kconfig
- use CONFIG_USB_DEVICE_STACK for conditional USB device support
- upgrade to Zephyr v2.7.0
- modbluetooth_zephyr: provide dummy connect_cancel function
3612 lines
143 KiB
C
3612 lines
143 KiB
C
/*
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
|
*
|
|
* The MIT License (MIT)
|
|
*
|
|
* SPDX-FileCopyrightText: Copyright (c) 2013-2020 Damien P. George
|
|
*
|
|
* 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 <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#include "py/scope.h"
|
|
#include "py/emit.h"
|
|
#include "py/compile.h"
|
|
#include "py/runtime.h"
|
|
#include "py/asmbase.h"
|
|
#include "py/persistentcode.h"
|
|
|
|
#include "supervisor/shared/translate.h"
|
|
|
|
#if MICROPY_ENABLE_COMPILER
|
|
|
|
// TODO need to mangle __attr names
|
|
|
|
#define INVALID_LABEL (0xffff)
|
|
|
|
typedef enum {
|
|
// define rules with a compile function
|
|
#define DEF_RULE(rule, comp, kind, ...) PN_##rule,
|
|
#define DEF_RULE_NC(rule, kind, ...)
|
|
#include "py/grammar.h"
|
|
#undef DEF_RULE
|
|
#undef DEF_RULE_NC
|
|
PN_const_object, // special node for a constant, generic Python object
|
|
// define rules without a compile function
|
|
#define DEF_RULE(rule, comp, kind, ...)
|
|
#define DEF_RULE_NC(rule, kind, ...) PN_##rule,
|
|
#include "py/grammar.h"
|
|
#undef DEF_RULE
|
|
#undef DEF_RULE_NC
|
|
} pn_kind_t;
|
|
|
|
// Whether a mp_parse_node_struct_t that has pns->kind == PN_testlist_comp
|
|
// corresponds to a list comprehension or generator.
|
|
#define MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns) \
|
|
(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2 && \
|
|
MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for))
|
|
|
|
#define NEED_METHOD_TABLE MICROPY_EMIT_NATIVE
|
|
|
|
#if NEED_METHOD_TABLE
|
|
|
|
// we need a method table to do the lookup for the emitter functions
|
|
#define EMIT(fun) (comp->emit_method_table->fun(comp->emit))
|
|
#define EMIT_ARG(fun, ...) (comp->emit_method_table->fun(comp->emit, __VA_ARGS__))
|
|
#define EMIT_LOAD_FAST(qst, local_num) (comp->emit_method_table->load_id.local(comp->emit, qst, local_num, MP_EMIT_IDOP_LOCAL_FAST))
|
|
#define EMIT_LOAD_GLOBAL(qst) (comp->emit_method_table->load_id.global(comp->emit, qst, MP_EMIT_IDOP_GLOBAL_GLOBAL))
|
|
|
|
#else
|
|
|
|
// if we only have the bytecode emitter enabled then we can do a direct call to the functions
|
|
#define EMIT(fun) (mp_emit_bc_##fun(comp->emit))
|
|
#define EMIT_ARG(fun, ...) (mp_emit_bc_##fun(comp->emit, __VA_ARGS__))
|
|
#define EMIT_LOAD_FAST(qst, local_num) (mp_emit_bc_load_local(comp->emit, qst, local_num, MP_EMIT_IDOP_LOCAL_FAST))
|
|
#define EMIT_LOAD_GLOBAL(qst) (mp_emit_bc_load_global(comp->emit, qst, MP_EMIT_IDOP_GLOBAL_GLOBAL))
|
|
|
|
#endif
|
|
|
|
#if MICROPY_EMIT_NATIVE && MICROPY_DYNAMIC_COMPILER
|
|
|
|
#define NATIVE_EMITTER(f) emit_native_table[mp_dynamic_compiler.native_arch]->emit_##f
|
|
#define NATIVE_EMITTER_TABLE emit_native_table[mp_dynamic_compiler.native_arch]
|
|
|
|
STATIC const emit_method_table_t *emit_native_table[] = {
|
|
NULL,
|
|
&emit_native_x86_method_table,
|
|
&emit_native_x64_method_table,
|
|
&emit_native_arm_method_table,
|
|
&emit_native_thumb_method_table,
|
|
&emit_native_thumb_method_table,
|
|
&emit_native_thumb_method_table,
|
|
&emit_native_thumb_method_table,
|
|
&emit_native_thumb_method_table,
|
|
&emit_native_xtensa_method_table,
|
|
&emit_native_xtensawin_method_table,
|
|
};
|
|
|
|
#elif MICROPY_EMIT_NATIVE
|
|
// define a macro to access external native emitter
|
|
#if MICROPY_EMIT_X64
|
|
#define NATIVE_EMITTER(f) emit_native_x64_##f
|
|
#elif MICROPY_EMIT_X86
|
|
#define NATIVE_EMITTER(f) emit_native_x86_##f
|
|
#elif MICROPY_EMIT_THUMB
|
|
#define NATIVE_EMITTER(f) emit_native_thumb_##f
|
|
#elif MICROPY_EMIT_ARM
|
|
#define NATIVE_EMITTER(f) emit_native_arm_##f
|
|
#elif MICROPY_EMIT_XTENSA
|
|
#define NATIVE_EMITTER(f) emit_native_xtensa_##f
|
|
#elif MICROPY_EMIT_XTENSAWIN
|
|
#define NATIVE_EMITTER(f) emit_native_xtensawin_##f
|
|
#else
|
|
#error "unknown native emitter"
|
|
#endif
|
|
#define NATIVE_EMITTER_TABLE &NATIVE_EMITTER(method_table)
|
|
#endif
|
|
|
|
#if MICROPY_EMIT_INLINE_ASM && MICROPY_DYNAMIC_COMPILER
|
|
|
|
#define ASM_EMITTER(f) emit_asm_table[mp_dynamic_compiler.native_arch]->asm_##f
|
|
#define ASM_EMITTER_TABLE emit_asm_table[mp_dynamic_compiler.native_arch]
|
|
|
|
STATIC const emit_inline_asm_method_table_t *emit_asm_table[] = {
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&emit_inline_thumb_method_table,
|
|
&emit_inline_thumb_method_table,
|
|
&emit_inline_thumb_method_table,
|
|
&emit_inline_thumb_method_table,
|
|
&emit_inline_thumb_method_table,
|
|
&emit_inline_thumb_method_table,
|
|
&emit_inline_xtensa_method_table,
|
|
NULL,
|
|
};
|
|
|
|
#elif MICROPY_EMIT_INLINE_ASM
|
|
// define macros for inline assembler
|
|
#if MICROPY_EMIT_INLINE_THUMB
|
|
#define ASM_DECORATOR_QSTR MP_QSTR_asm_thumb
|
|
#define ASM_EMITTER(f) emit_inline_thumb_##f
|
|
#elif MICROPY_EMIT_INLINE_XTENSA
|
|
#define ASM_DECORATOR_QSTR MP_QSTR_asm_xtensa
|
|
#define ASM_EMITTER(f) emit_inline_xtensa_##f
|
|
#else
|
|
#error "unknown asm emitter"
|
|
#endif
|
|
#define ASM_EMITTER_TABLE &ASM_EMITTER(method_table)
|
|
#endif
|
|
|
|
#define EMIT_INLINE_ASM(fun) (comp->emit_inline_asm_method_table->fun(comp->emit_inline_asm))
|
|
#define EMIT_INLINE_ASM_ARG(fun, ...) (comp->emit_inline_asm_method_table->fun(comp->emit_inline_asm, __VA_ARGS__))
|
|
|
|
// elements in this struct are ordered to make it compact
|
|
typedef struct _compiler_t {
|
|
qstr source_file;
|
|
|
|
uint8_t is_repl;
|
|
uint8_t pass; // holds enum type pass_kind_t
|
|
uint8_t have_star;
|
|
|
|
// try to keep compiler clean from nlr
|
|
mp_obj_t compile_error; // set to an exception object if there's an error
|
|
size_t compile_error_line; // set to best guess of line of error
|
|
|
|
uint next_label;
|
|
|
|
uint16_t num_dict_params;
|
|
uint16_t num_default_params;
|
|
|
|
uint16_t break_label; // highest bit set indicates we are breaking out of a for loop
|
|
uint16_t continue_label;
|
|
uint16_t cur_except_level; // increased for SETUP_EXCEPT, SETUP_FINALLY; decreased for POP_BLOCK, POP_EXCEPT
|
|
uint16_t break_continue_except_level;
|
|
|
|
scope_t *scope_head;
|
|
scope_t *scope_cur;
|
|
|
|
emit_t *emit; // current emitter
|
|
#if NEED_METHOD_TABLE
|
|
const emit_method_table_t *emit_method_table; // current emit method table
|
|
#endif
|
|
|
|
#if MICROPY_EMIT_INLINE_ASM
|
|
emit_inline_asm_t *emit_inline_asm; // current emitter for inline asm
|
|
const emit_inline_asm_method_table_t *emit_inline_asm_method_table; // current emit method table for inline asm
|
|
#endif
|
|
} compiler_t;
|
|
|
|
STATIC void compile_error_set_line(compiler_t *comp, mp_parse_node_t pn) {
|
|
// if the line of the error is unknown then try to update it from the pn
|
|
if (comp->compile_error_line == 0 && MP_PARSE_NODE_IS_STRUCT(pn)) {
|
|
comp->compile_error_line = ((mp_parse_node_struct_t *)pn)->source_line;
|
|
}
|
|
}
|
|
|
|
STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, const compressed_string_t *msg) {
|
|
// only register the error if there has been no other error
|
|
if (comp->compile_error == MP_OBJ_NULL) {
|
|
comp->compile_error = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg);
|
|
compile_error_set_line(comp, pn);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_arglist, bool is_method_call, int n_positional_extra);
|
|
STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind);
|
|
STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *pns, bool create_map);
|
|
STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn);
|
|
|
|
STATIC uint comp_next_label(compiler_t *comp) {
|
|
return comp->next_label++;
|
|
}
|
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
STATIC void reserve_labels_for_native(compiler_t *comp, int n) {
|
|
if (comp->scope_cur->emit_options != MP_EMIT_OPT_BYTECODE) {
|
|
comp->next_label += n;
|
|
}
|
|
}
|
|
#else
|
|
#define reserve_labels_for_native(comp, n)
|
|
#endif
|
|
|
|
STATIC void compile_increase_except_level(compiler_t *comp, uint label, int kind) {
|
|
EMIT_ARG(setup_block, label, kind);
|
|
comp->cur_except_level += 1;
|
|
if (comp->cur_except_level > comp->scope_cur->exc_stack_size) {
|
|
comp->scope_cur->exc_stack_size = comp->cur_except_level;
|
|
}
|
|
}
|
|
|
|
STATIC void compile_decrease_except_level(compiler_t *comp) {
|
|
assert(comp->cur_except_level > 0);
|
|
comp->cur_except_level -= 1;
|
|
EMIT(end_finally);
|
|
reserve_labels_for_native(comp, 1);
|
|
}
|
|
|
|
STATIC scope_t *scope_new_and_link(compiler_t *comp, scope_kind_t kind, mp_parse_node_t pn, uint emit_options) {
|
|
scope_t *scope = scope_new(kind, pn, comp->source_file, emit_options);
|
|
scope->parent = comp->scope_cur;
|
|
scope->next = NULL;
|
|
if (comp->scope_head == NULL) {
|
|
comp->scope_head = scope;
|
|
} else {
|
|
scope_t *s = comp->scope_head;
|
|
while (s->next != NULL) {
|
|
s = s->next;
|
|
}
|
|
s->next = scope;
|
|
}
|
|
return scope;
|
|
}
|
|
|
|
typedef void (*apply_list_fun_t)(compiler_t *comp, mp_parse_node_t pn);
|
|
|
|
STATIC void apply_to_single_or_list(compiler_t *comp, mp_parse_node_t pn, pn_kind_t pn_list_kind, apply_list_fun_t f) {
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, pn_list_kind)) {
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
for (int i = 0; i < num_nodes; i++) {
|
|
f(comp, pns->nodes[i]);
|
|
}
|
|
} else if (!MP_PARSE_NODE_IS_NULL(pn)) {
|
|
f(comp, pn);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_generic_all_nodes(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
for (int i = 0; i < num_nodes; i++) {
|
|
compile_node(comp, pns->nodes[i]);
|
|
if (comp->compile_error != MP_OBJ_NULL) {
|
|
// add line info for the error in case it didn't have a line number
|
|
compile_error_set_line(comp, pns->nodes[i]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC void compile_load_id(compiler_t *comp, qstr qst) {
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
mp_emit_common_get_id_for_load(comp->scope_cur, qst);
|
|
} else {
|
|
#if NEED_METHOD_TABLE
|
|
mp_emit_common_id_op(comp->emit, &comp->emit_method_table->load_id, comp->scope_cur, qst);
|
|
#else
|
|
mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_load_id_ops, comp->scope_cur, qst);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
STATIC void compile_store_id(compiler_t *comp, qstr qst) {
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
mp_emit_common_get_id_for_modification(comp->scope_cur, qst);
|
|
} else {
|
|
#if NEED_METHOD_TABLE
|
|
mp_emit_common_id_op(comp->emit, &comp->emit_method_table->store_id, comp->scope_cur, qst);
|
|
#else
|
|
mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_store_id_ops, comp->scope_cur, qst);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
STATIC void compile_delete_id(compiler_t *comp, qstr qst) {
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
mp_emit_common_get_id_for_modification(comp->scope_cur, qst);
|
|
} else {
|
|
#if NEED_METHOD_TABLE
|
|
mp_emit_common_id_op(comp->emit, &comp->emit_method_table->delete_id, comp->scope_cur, qst);
|
|
#else
|
|
mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_delete_id_ops, comp->scope_cur, qst);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
STATIC void compile_generic_tuple(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// a simple tuple expression
|
|
size_t num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
for (size_t i = 0; i < num_nodes; i++) {
|
|
compile_node(comp, pns->nodes[i]);
|
|
}
|
|
EMIT_ARG(build, num_nodes, MP_EMIT_BUILD_TUPLE);
|
|
}
|
|
|
|
STATIC void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label) {
|
|
if (mp_parse_node_is_const_false(pn)) {
|
|
if (jump_if == false) {
|
|
EMIT_ARG(jump, label);
|
|
}
|
|
return;
|
|
} else if (mp_parse_node_is_const_true(pn)) {
|
|
if (jump_if == true) {
|
|
EMIT_ARG(jump, label);
|
|
}
|
|
return;
|
|
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
|
|
if (jump_if == false) {
|
|
and_or_logic1:;
|
|
uint label2 = comp_next_label(comp);
|
|
for (int i = 0; i < n - 1; i++) {
|
|
c_if_cond(comp, pns->nodes[i], !jump_if, label2);
|
|
}
|
|
c_if_cond(comp, pns->nodes[n - 1], jump_if, label);
|
|
EMIT_ARG(label_assign, label2);
|
|
} else {
|
|
and_or_logic2:
|
|
for (int i = 0; i < n; i++) {
|
|
c_if_cond(comp, pns->nodes[i], jump_if, label);
|
|
}
|
|
}
|
|
return;
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
|
|
if (jump_if == false) {
|
|
goto and_or_logic2;
|
|
} else {
|
|
goto and_or_logic1;
|
|
}
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
|
|
c_if_cond(comp, pns->nodes[0], !jump_if, label);
|
|
return;
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_atom_paren) {
|
|
// cond is something in parenthesis
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// empty tuple, acts as false for the condition
|
|
if (jump_if == false) {
|
|
EMIT_ARG(jump, label);
|
|
}
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
|
|
// non-empty tuple, acts as true for the condition
|
|
if (jump_if == true) {
|
|
EMIT_ARG(jump, label);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// nothing special, fall back to default compiling for node and jump
|
|
compile_node(comp, pn);
|
|
EMIT_ARG(pop_jump_if, jump_if, label);
|
|
}
|
|
|
|
typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
|
|
STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t kind);
|
|
|
|
STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, assign_kind_t assign_kind) {
|
|
if (assign_kind != ASSIGN_AUG_STORE) {
|
|
compile_node(comp, pns->nodes[0]);
|
|
}
|
|
|
|
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
|
|
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
|
|
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
|
|
if (assign_kind != ASSIGN_AUG_STORE) {
|
|
for (int i = 0; i < n - 1; i++) {
|
|
compile_node(comp, pns1->nodes[i]);
|
|
}
|
|
}
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
|
|
pns1 = (mp_parse_node_struct_t *)pns1->nodes[n - 1];
|
|
}
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
|
|
if (assign_kind == ASSIGN_AUG_STORE) {
|
|
EMIT(rot_three);
|
|
EMIT_ARG(subscr, MP_EMIT_SUBSCR_STORE);
|
|
} else {
|
|
compile_node(comp, pns1->nodes[0]);
|
|
if (assign_kind == ASSIGN_AUG_LOAD) {
|
|
EMIT(dup_top_two);
|
|
EMIT_ARG(subscr, MP_EMIT_SUBSCR_LOAD);
|
|
} else {
|
|
EMIT_ARG(subscr, MP_EMIT_SUBSCR_STORE);
|
|
}
|
|
}
|
|
return;
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
|
|
assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
|
|
if (assign_kind == ASSIGN_AUG_LOAD) {
|
|
EMIT(dup_top);
|
|
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]), MP_EMIT_ATTR_LOAD);
|
|
} else {
|
|
if (assign_kind == ASSIGN_AUG_STORE) {
|
|
EMIT(rot_two);
|
|
}
|
|
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]), MP_EMIT_ATTR_STORE);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("can't assign to expression"));
|
|
}
|
|
|
|
STATIC void c_assign_tuple(compiler_t *comp, uint num_tail, mp_parse_node_t *nodes_tail) {
|
|
// look for star expression
|
|
uint have_star_index = -1;
|
|
for (uint i = 0; i < num_tail; i++) {
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes_tail[i], PN_star_expr)) {
|
|
if (have_star_index == (uint)-1) {
|
|
EMIT_ARG(unpack_ex, i, num_tail - i - 1);
|
|
have_star_index = i;
|
|
} else {
|
|
compile_syntax_error(comp, nodes_tail[i], MP_ERROR_TEXT("multiple *x in assignment"));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (have_star_index == (uint)-1) {
|
|
EMIT_ARG(unpack_sequence, num_tail);
|
|
}
|
|
for (uint i = 0; i < num_tail; i++) {
|
|
if (i == have_star_index) {
|
|
c_assign(comp, ((mp_parse_node_struct_t *)nodes_tail[i])->nodes[0], ASSIGN_STORE);
|
|
} else {
|
|
c_assign(comp, nodes_tail[i], ASSIGN_STORE);
|
|
}
|
|
}
|
|
}
|
|
|
|
// assigns top of stack to pn
|
|
STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_kind) {
|
|
assert(!MP_PARSE_NODE_IS_NULL(pn));
|
|
if (MP_PARSE_NODE_IS_LEAF(pn)) {
|
|
if (MP_PARSE_NODE_IS_ID(pn)) {
|
|
qstr arg = MP_PARSE_NODE_LEAF_ARG(pn);
|
|
switch (assign_kind) {
|
|
case ASSIGN_STORE:
|
|
case ASSIGN_AUG_STORE:
|
|
compile_store_id(comp, arg);
|
|
break;
|
|
case ASSIGN_AUG_LOAD:
|
|
default:
|
|
compile_load_id(comp, arg);
|
|
break;
|
|
}
|
|
} else {
|
|
goto cannot_assign;
|
|
}
|
|
} else {
|
|
// pn must be a struct
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
|
|
case PN_atom_expr_normal:
|
|
// lhs is an index or attribute
|
|
c_assign_atom_expr(comp, pns, assign_kind);
|
|
break;
|
|
|
|
case PN_testlist_star_expr:
|
|
case PN_exprlist:
|
|
// lhs is a tuple
|
|
if (assign_kind != ASSIGN_STORE) {
|
|
goto cannot_assign;
|
|
}
|
|
c_assign_tuple(comp, MP_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
|
|
break;
|
|
|
|
case PN_atom_paren:
|
|
// lhs is something in parenthesis
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// empty tuple
|
|
goto cannot_assign;
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
|
|
if (assign_kind != ASSIGN_STORE) {
|
|
goto cannot_assign;
|
|
}
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
goto testlist_comp;
|
|
}
|
|
break;
|
|
|
|
case PN_atom_bracket:
|
|
// lhs is something in brackets
|
|
if (assign_kind != ASSIGN_STORE) {
|
|
goto cannot_assign;
|
|
}
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// empty list, assignment allowed
|
|
c_assign_tuple(comp, 0, NULL);
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
goto testlist_comp;
|
|
} else {
|
|
// brackets around 1 item
|
|
c_assign_tuple(comp, 1, pns->nodes);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
goto cannot_assign;
|
|
}
|
|
return;
|
|
|
|
testlist_comp:
|
|
// lhs is a sequence
|
|
if (MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns)) {
|
|
goto cannot_assign;
|
|
}
|
|
c_assign_tuple(comp, MP_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
|
|
return;
|
|
}
|
|
return;
|
|
|
|
cannot_assign:
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("can't assign to expression"));
|
|
}
|
|
|
|
// stuff for lambda and comprehensions and generators:
|
|
// if n_pos_defaults > 0 then there is a tuple on the stack with the positional defaults
|
|
// if n_kw_defaults > 0 then there is a dictionary on the stack with the keyword defaults
|
|
// if both exist, the tuple is above the dictionary (ie the first pop gets the tuple)
|
|
STATIC void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int n_pos_defaults, int n_kw_defaults) {
|
|
assert(n_pos_defaults >= 0);
|
|
assert(n_kw_defaults >= 0);
|
|
|
|
// set flags
|
|
if (n_kw_defaults > 0) {
|
|
this_scope->scope_flags |= MP_SCOPE_FLAG_DEFKWARGS;
|
|
}
|
|
this_scope->num_def_pos_args = n_pos_defaults;
|
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
// When creating a function/closure it will take a reference to the current globals
|
|
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_REFGLOBALS | MP_SCOPE_FLAG_HASCONSTS;
|
|
#endif
|
|
|
|
// make closed over variables, if any
|
|
// ensure they are closed over in the order defined in the outer scope (mainly to agree with CPython)
|
|
int nfree = 0;
|
|
if (comp->scope_cur->kind != SCOPE_MODULE) {
|
|
for (int i = 0; i < comp->scope_cur->id_info_len; i++) {
|
|
id_info_t *id = &comp->scope_cur->id_info[i];
|
|
if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
|
|
for (int j = 0; j < this_scope->id_info_len; j++) {
|
|
id_info_t *id2 = &this_scope->id_info[j];
|
|
if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {
|
|
// in MicroPython we load closures using LOAD_FAST
|
|
EMIT_LOAD_FAST(id->qst, id->local_num);
|
|
nfree += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// make the function/closure
|
|
if (nfree == 0) {
|
|
EMIT_ARG(make_function, this_scope, n_pos_defaults, n_kw_defaults);
|
|
} else {
|
|
EMIT_ARG(make_closure, this_scope, nfree, n_pos_defaults, n_kw_defaults);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn) {
|
|
// For efficiency of the code below we extract the parse-node kind here
|
|
int pn_kind;
|
|
if (MP_PARSE_NODE_IS_ID(pn)) {
|
|
pn_kind = -1;
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pn));
|
|
pn_kind = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn);
|
|
}
|
|
|
|
if (pn_kind == PN_typedargslist_star || pn_kind == PN_varargslist_star) {
|
|
comp->have_star = true;
|
|
/* don't need to distinguish bare from named star
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// bare star
|
|
} else {
|
|
// named star
|
|
}
|
|
*/
|
|
|
|
} else if (pn_kind == PN_typedargslist_dbl_star || pn_kind == PN_varargslist_dbl_star) {
|
|
// named double star
|
|
// TODO do we need to do anything with this?
|
|
|
|
} else {
|
|
mp_parse_node_t pn_id;
|
|
mp_parse_node_t pn_equal;
|
|
if (pn_kind == -1) {
|
|
// this parameter is just an id
|
|
|
|
pn_id = pn;
|
|
pn_equal = MP_PARSE_NODE_NULL;
|
|
|
|
} else if (pn_kind == PN_typedargslist_name) {
|
|
// this parameter has a colon and/or equal specifier
|
|
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
pn_id = pns->nodes[0];
|
|
// pn_colon = pns->nodes[1]; // unused
|
|
pn_equal = pns->nodes[2];
|
|
|
|
} else {
|
|
assert(pn_kind == PN_varargslist_name); // should be
|
|
// this parameter has an equal specifier
|
|
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
pn_id = pns->nodes[0];
|
|
pn_equal = pns->nodes[1];
|
|
}
|
|
|
|
if (MP_PARSE_NODE_IS_NULL(pn_equal)) {
|
|
// this parameter does not have a default value
|
|
|
|
// check for non-default parameters given after default parameters (allowed by parser, but not syntactically valid)
|
|
if (!comp->have_star && comp->num_default_params != 0) {
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("non-default argument follows default argument"));
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
// this parameter has a default value
|
|
// in CPython, None (and True, False?) as default parameters are loaded with LOAD_NAME; don't understandy why
|
|
|
|
if (comp->have_star) {
|
|
comp->num_dict_params += 1;
|
|
// in MicroPython we put the default dict parameters into a dictionary using the bytecode
|
|
if (comp->num_dict_params == 1) {
|
|
// in MicroPython we put the default positional parameters into a tuple using the bytecode
|
|
// we need to do this here before we start building the map for the default keywords
|
|
if (comp->num_default_params > 0) {
|
|
EMIT_ARG(build, comp->num_default_params, MP_EMIT_BUILD_TUPLE);
|
|
} else {
|
|
EMIT(load_null); // sentinel indicating empty default positional args
|
|
}
|
|
// first default dict param, so make the map
|
|
EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);
|
|
}
|
|
|
|
// compile value then key, then store it to the dict
|
|
compile_node(comp, pn_equal);
|
|
EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pn_id));
|
|
EMIT(store_map);
|
|
} else {
|
|
comp->num_default_params += 1;
|
|
compile_node(comp, pn_equal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC void compile_funcdef_lambdef(compiler_t *comp, scope_t *scope, mp_parse_node_t pn_params, pn_kind_t pn_list_kind) {
|
|
// When we call compile_funcdef_lambdef_param below it can compile an arbitrary
|
|
// expression for default arguments, which may contain a lambda. The lambda will
|
|
// call here in a nested way, so we must save and restore the relevant state.
|
|
bool orig_have_star = comp->have_star;
|
|
uint16_t orig_num_dict_params = comp->num_dict_params;
|
|
uint16_t orig_num_default_params = comp->num_default_params;
|
|
|
|
// compile default parameters
|
|
comp->have_star = false;
|
|
comp->num_dict_params = 0;
|
|
comp->num_default_params = 0;
|
|
apply_to_single_or_list(comp, pn_params, pn_list_kind, compile_funcdef_lambdef_param);
|
|
|
|
if (comp->compile_error != MP_OBJ_NULL) {
|
|
return;
|
|
}
|
|
|
|
// in MicroPython we put the default positional parameters into a tuple using the bytecode
|
|
// the default keywords args may have already made the tuple; if not, do it now
|
|
if (comp->num_default_params > 0 && comp->num_dict_params == 0) {
|
|
EMIT_ARG(build, comp->num_default_params, MP_EMIT_BUILD_TUPLE);
|
|
EMIT(load_null); // sentinel indicating empty default keyword args
|
|
}
|
|
|
|
// make the function
|
|
close_over_variables_etc(comp, scope, comp->num_default_params, comp->num_dict_params);
|
|
|
|
// restore state
|
|
comp->have_star = orig_have_star;
|
|
comp->num_dict_params = orig_num_dict_params;
|
|
comp->num_default_params = orig_num_default_params;
|
|
}
|
|
|
|
// leaves function object on stack
|
|
// returns function name
|
|
STATIC qstr compile_funcdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
// create a new scope for this function
|
|
scope_t *s = scope_new_and_link(comp, SCOPE_FUNCTION, (mp_parse_node_t)pns, emit_options);
|
|
// store the function scope so the compiling function can use it at each pass
|
|
pns->nodes[4] = (mp_parse_node_t)s;
|
|
}
|
|
|
|
// get the scope for this function
|
|
scope_t *fscope = (scope_t *)pns->nodes[4];
|
|
|
|
// compile the function definition
|
|
compile_funcdef_lambdef(comp, fscope, pns->nodes[1], PN_typedargslist);
|
|
|
|
// return its name (the 'f' in "def f(...):")
|
|
return fscope->simple_name;
|
|
}
|
|
|
|
// leaves class object on stack
|
|
// returns class name
|
|
STATIC qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
// create a new scope for this class
|
|
scope_t *s = scope_new_and_link(comp, SCOPE_CLASS, (mp_parse_node_t)pns, emit_options);
|
|
// store the class scope so the compiling function can use it at each pass
|
|
pns->nodes[3] = (mp_parse_node_t)s;
|
|
}
|
|
|
|
EMIT(load_build_class);
|
|
|
|
// scope for this class
|
|
scope_t *cscope = (scope_t *)pns->nodes[3];
|
|
|
|
// compile the class
|
|
close_over_variables_etc(comp, cscope, 0, 0);
|
|
|
|
// get its name
|
|
EMIT_ARG(load_const_str, cscope->simple_name);
|
|
|
|
// nodes[1] has parent classes, if any
|
|
// empty parenthesis (eg class C():) gets here as an empty PN_classdef_2 and needs special handling
|
|
mp_parse_node_t parents = pns->nodes[1];
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(parents, PN_classdef_2)) {
|
|
parents = MP_PARSE_NODE_NULL;
|
|
}
|
|
compile_trailer_paren_helper(comp, parents, false, 2);
|
|
|
|
// return its name (the 'C' in class C(...):")
|
|
return cscope->simple_name;
|
|
}
|
|
|
|
// returns true if it was a built-in decorator (even if the built-in had an error)
|
|
STATIC bool compile_built_in_decorator(compiler_t *comp, size_t name_len, mp_parse_node_t *name_nodes, uint *emit_options) {
|
|
if (MP_PARSE_NODE_LEAF_ARG(name_nodes[0]) != MP_QSTR_micropython) {
|
|
return false;
|
|
}
|
|
|
|
if (name_len != 2) {
|
|
compile_syntax_error(comp, name_nodes[0], MP_ERROR_TEXT("invalid micropython decorator"));
|
|
return true;
|
|
}
|
|
|
|
qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
|
|
if (attr == MP_QSTR_bytecode) {
|
|
*emit_options = MP_EMIT_OPT_BYTECODE;
|
|
// @micropython.native decorator.
|
|
} else if (attr == MP_QSTR_native) {
|
|
// Different from MicroPython: native doesn't raise SyntaxError if native support isn't
|
|
// compiled, it just passes through the function unmodified.
|
|
#if MICROPY_EMIT_NATIVE
|
|
*emit_options = MP_EMIT_OPT_NATIVE_PYTHON;
|
|
#else
|
|
return true;
|
|
#endif
|
|
#if MICROPY_EMIT_NATIVE
|
|
// @micropython.viper decorator.
|
|
} else if (attr == MP_QSTR_viper) {
|
|
*emit_options = MP_EMIT_OPT_VIPER;
|
|
#endif
|
|
#if MICROPY_EMIT_INLINE_ASM
|
|
#if MICROPY_DYNAMIC_COMPILER
|
|
} else if (attr == MP_QSTR_asm_thumb) {
|
|
*emit_options = MP_EMIT_OPT_ASM;
|
|
} else if (attr == MP_QSTR_asm_xtensa) {
|
|
*emit_options = MP_EMIT_OPT_ASM;
|
|
#else
|
|
} else if (attr == ASM_DECORATOR_QSTR) {
|
|
*emit_options = MP_EMIT_OPT_ASM;
|
|
#endif
|
|
#endif
|
|
} else {
|
|
compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid micropython decorator"));
|
|
}
|
|
|
|
#if MICROPY_DYNAMIC_COMPILER
|
|
if (*emit_options == MP_EMIT_OPT_NATIVE_PYTHON || *emit_options == MP_EMIT_OPT_VIPER) {
|
|
if (emit_native_table[mp_dynamic_compiler.native_arch] == NULL) {
|
|
compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid architecture"));
|
|
}
|
|
} else if (*emit_options == MP_EMIT_OPT_ASM) {
|
|
if (emit_asm_table[mp_dynamic_compiler.native_arch] == NULL) {
|
|
compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid architecture"));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// get the list of decorators
|
|
mp_parse_node_t *nodes;
|
|
size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_decorators, &nodes);
|
|
|
|
// inherit emit options for this function/class definition
|
|
uint emit_options = comp->scope_cur->emit_options;
|
|
|
|
// compile each decorator
|
|
size_t num_built_in_decorators = 0;
|
|
for (size_t i = 0; i < n; i++) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be
|
|
mp_parse_node_struct_t *pns_decorator = (mp_parse_node_struct_t *)nodes[i];
|
|
|
|
// nodes[0] contains the decorator function, which is a dotted name
|
|
mp_parse_node_t *name_nodes;
|
|
size_t name_len = mp_parse_node_extract_list(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);
|
|
|
|
// check for built-in decorators
|
|
if (compile_built_in_decorator(comp, name_len, name_nodes, &emit_options)) {
|
|
// this was a built-in
|
|
num_built_in_decorators += 1;
|
|
|
|
} else {
|
|
// not a built-in, compile normally
|
|
|
|
// compile the decorator function
|
|
compile_node(comp, name_nodes[0]);
|
|
for (size_t j = 1; j < name_len; j++) {
|
|
assert(MP_PARSE_NODE_IS_ID(name_nodes[j])); // should be
|
|
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[j]), MP_EMIT_ATTR_LOAD);
|
|
}
|
|
|
|
// nodes[1] contains arguments to the decorator function, if any
|
|
if (!MP_PARSE_NODE_IS_NULL(pns_decorator->nodes[1])) {
|
|
// call the decorator function with the arguments in nodes[1]
|
|
compile_node(comp, pns_decorator->nodes[1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// compile the body (funcdef, async funcdef or classdef) and get its name
|
|
mp_parse_node_struct_t *pns_body = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
qstr body_name = 0;
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
|
|
body_name = compile_funcdef_helper(comp, pns_body, emit_options);
|
|
#if MICROPY_PY_ASYNC_AWAIT
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_async_funcdef) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns_body->nodes[0]));
|
|
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns_body->nodes[0];
|
|
body_name = compile_funcdef_helper(comp, pns0, emit_options);
|
|
scope_t *fscope = (scope_t *)pns0->nodes[4];
|
|
fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR | MP_SCOPE_FLAG_ASYNC;
|
|
#endif
|
|
} else {
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef); // should be
|
|
body_name = compile_classdef_helper(comp, pns_body, emit_options);
|
|
}
|
|
|
|
// call each decorator
|
|
for (size_t i = 0; i < n - num_built_in_decorators; i++) {
|
|
EMIT_ARG(call_function, 1, 0, 0);
|
|
}
|
|
|
|
// store func/class object into name
|
|
compile_store_id(comp, body_name);
|
|
}
|
|
|
|
STATIC void compile_funcdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
qstr fname = compile_funcdef_helper(comp, pns, comp->scope_cur->emit_options);
|
|
// store function object into function name
|
|
compile_store_id(comp, fname);
|
|
}
|
|
|
|
STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
|
|
if (MP_PARSE_NODE_IS_ID(pn)) {
|
|
compile_delete_id(comp, MP_PARSE_NODE_LEAF_ARG(pn));
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_expr_normal)) {
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
|
|
compile_node(comp, pns->nodes[0]); // base of the atom_expr_normal node
|
|
|
|
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
|
|
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
|
|
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
|
|
for (int i = 0; i < n - 1; i++) {
|
|
compile_node(comp, pns1->nodes[i]);
|
|
}
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
|
|
pns1 = (mp_parse_node_struct_t *)pns1->nodes[n - 1];
|
|
}
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
|
|
compile_node(comp, pns1->nodes[0]);
|
|
EMIT_ARG(subscr, MP_EMIT_SUBSCR_DELETE);
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
|
|
assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
|
|
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]), MP_EMIT_ATTR_DELETE);
|
|
} else {
|
|
goto cannot_delete;
|
|
}
|
|
} else {
|
|
goto cannot_delete;
|
|
}
|
|
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {
|
|
pn = ((mp_parse_node_struct_t *)pn)->nodes[0];
|
|
if (MP_PARSE_NODE_IS_NULL(pn)) {
|
|
goto cannot_delete;
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp));
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
if (MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns)) {
|
|
goto cannot_delete;
|
|
}
|
|
for (size_t i = 0; i < MP_PARSE_NODE_STRUCT_NUM_NODES(pns); ++i) {
|
|
c_del_stmt(comp, pns->nodes[i]);
|
|
}
|
|
}
|
|
} else {
|
|
// some arbitrary statement that we can't delete (eg del 1)
|
|
goto cannot_delete;
|
|
}
|
|
|
|
return;
|
|
|
|
cannot_delete:
|
|
compile_syntax_error(comp, (mp_parse_node_t)pn, MP_ERROR_TEXT("can't delete expression"));
|
|
}
|
|
|
|
STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
apply_to_single_or_list(comp, pns->nodes[0], PN_exprlist, c_del_stmt);
|
|
}
|
|
|
|
STATIC void compile_break_cont_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
uint16_t label;
|
|
const compressed_string_t *error_msg;
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_break_stmt) {
|
|
label = comp->break_label;
|
|
error_msg = MP_ERROR_TEXT("'break' outside loop");
|
|
} else {
|
|
label = comp->continue_label;
|
|
error_msg = MP_ERROR_TEXT("'continue' outside loop");
|
|
}
|
|
if (label == INVALID_LABEL) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, error_msg);
|
|
}
|
|
assert(comp->cur_except_level >= comp->break_continue_except_level);
|
|
EMIT_ARG(unwind_jump, label, comp->cur_except_level - comp->break_continue_except_level);
|
|
}
|
|
|
|
STATIC void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
#if MICROPY_CPYTHON_COMPAT
|
|
if (comp->scope_cur->kind != SCOPE_FUNCTION) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'return' outside function"));
|
|
return;
|
|
}
|
|
#endif
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// no argument to 'return', so return None
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
} else if (MICROPY_COMP_RETURN_IF_EXPR
|
|
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
|
|
// special case when returning an if-expression; to match CPython optimisation
|
|
mp_parse_node_struct_t *pns_test_if_expr = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t *)pns_test_if_expr->nodes[1];
|
|
|
|
uint l_fail = comp_next_label(comp);
|
|
c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
|
|
compile_node(comp, pns_test_if_expr->nodes[0]); // success value
|
|
EMIT(return_value);
|
|
EMIT_ARG(label_assign, l_fail);
|
|
compile_node(comp, pns_test_if_else->nodes[1]); // failure value
|
|
} else {
|
|
compile_node(comp, pns->nodes[0]);
|
|
}
|
|
EMIT(return_value);
|
|
}
|
|
|
|
STATIC void compile_yield_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT(pop_top);
|
|
}
|
|
|
|
STATIC void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// raise
|
|
EMIT_ARG(raise_varargs, 0);
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
|
|
// raise x from y
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
compile_node(comp, pns->nodes[0]);
|
|
compile_node(comp, pns->nodes[1]);
|
|
EMIT_ARG(raise_varargs, 2);
|
|
} else {
|
|
// raise x
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT_ARG(raise_varargs, 1);
|
|
}
|
|
}
|
|
|
|
// q_base holds the base of the name
|
|
// eg a -> q_base=a
|
|
// a.b.c -> q_base=a
|
|
STATIC void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q_base) {
|
|
bool is_as = false;
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
// a name of the form x as y; unwrap it
|
|
*q_base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
|
|
pn = pns->nodes[0];
|
|
is_as = true;
|
|
}
|
|
if (MP_PARSE_NODE_IS_NULL(pn)) {
|
|
// empty name (eg, from . import x)
|
|
*q_base = MP_QSTR_;
|
|
EMIT_ARG(import, MP_QSTR_, MP_EMIT_IMPORT_NAME); // import the empty string
|
|
} else if (MP_PARSE_NODE_IS_ID(pn)) {
|
|
// just a simple name
|
|
qstr q_full = MP_PARSE_NODE_LEAF_ARG(pn);
|
|
if (!is_as) {
|
|
*q_base = q_full;
|
|
}
|
|
EMIT_ARG(import, q_full, MP_EMIT_IMPORT_NAME);
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_name)); // should be
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
{
|
|
// a name of the form a.b.c
|
|
if (!is_as) {
|
|
*q_base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
|
|
}
|
|
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
int len = n - 1;
|
|
for (int i = 0; i < n; i++) {
|
|
len += qstr_len(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
|
|
}
|
|
char *q_ptr = mp_local_alloc(len);
|
|
char *str_dest = q_ptr;
|
|
for (int i = 0; i < n; i++) {
|
|
if (i > 0) {
|
|
*str_dest++ = '.';
|
|
}
|
|
size_t str_src_len;
|
|
const byte *str_src = qstr_data(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]), &str_src_len);
|
|
memcpy(str_dest, str_src, str_src_len);
|
|
str_dest += str_src_len;
|
|
}
|
|
qstr q_full = qstr_from_strn(q_ptr, len);
|
|
mp_local_free(q_ptr);
|
|
EMIT_ARG(import, q_full, MP_EMIT_IMPORT_NAME);
|
|
if (is_as) {
|
|
for (int i = 1; i < n; i++) {
|
|
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]), MP_EMIT_ATTR_LOAD);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC void compile_dotted_as_name(compiler_t *comp, mp_parse_node_t pn) {
|
|
EMIT_ARG(load_const_small_int, 0); // level 0 import
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE); // not importing from anything
|
|
qstr q_base;
|
|
do_import_name(comp, pn, &q_base);
|
|
compile_store_id(comp, q_base);
|
|
}
|
|
|
|
STATIC void compile_import_name(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
apply_to_single_or_list(comp, pns->nodes[0], PN_dotted_as_names, compile_dotted_as_name);
|
|
}
|
|
|
|
STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
mp_parse_node_t pn_import_source = pns->nodes[0];
|
|
|
|
// extract the preceding .'s (if any) for a relative import, to compute the import level
|
|
uint import_level = 0;
|
|
do {
|
|
mp_parse_node_t pn_rel;
|
|
if (MP_PARSE_NODE_IS_TOKEN(pn_import_source) || MP_PARSE_NODE_IS_STRUCT_KIND(pn_import_source, PN_one_or_more_period_or_ellipsis)) {
|
|
// This covers relative imports with dots only like "from .. import"
|
|
pn_rel = pn_import_source;
|
|
pn_import_source = MP_PARSE_NODE_NULL;
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_import_source, PN_import_from_2b)) {
|
|
// This covers relative imports starting with dot(s) like "from .foo import"
|
|
mp_parse_node_struct_t *pns_2b = (mp_parse_node_struct_t *)pn_import_source;
|
|
pn_rel = pns_2b->nodes[0];
|
|
pn_import_source = pns_2b->nodes[1];
|
|
assert(!MP_PARSE_NODE_IS_NULL(pn_import_source)); // should not be
|
|
} else {
|
|
// Not a relative import
|
|
break;
|
|
}
|
|
|
|
// get the list of . and/or ...'s
|
|
mp_parse_node_t *nodes;
|
|
size_t n = mp_parse_node_extract_list(&pn_rel, PN_one_or_more_period_or_ellipsis, &nodes);
|
|
|
|
// count the total number of .'s
|
|
for (size_t i = 0; i < n; i++) {
|
|
if (MP_PARSE_NODE_IS_TOKEN_KIND(nodes[i], MP_TOKEN_DEL_PERIOD)) {
|
|
import_level++;
|
|
} else {
|
|
// should be an MP_TOKEN_ELLIPSIS
|
|
import_level += 3;
|
|
}
|
|
}
|
|
} while (0);
|
|
|
|
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
|
|
#if MICROPY_CPYTHON_COMPAT
|
|
if (comp->scope_cur->kind != SCOPE_MODULE) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("import * not at module level"));
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
EMIT_ARG(load_const_small_int, import_level);
|
|
|
|
// build the "fromlist" tuple
|
|
EMIT_ARG(load_const_str, MP_QSTR__star_);
|
|
EMIT_ARG(build, 1, MP_EMIT_BUILD_TUPLE);
|
|
|
|
// do the import
|
|
qstr dummy_q;
|
|
do_import_name(comp, pn_import_source, &dummy_q);
|
|
EMIT_ARG(import, MP_QSTRnull, MP_EMIT_IMPORT_STAR);
|
|
|
|
} else {
|
|
EMIT_ARG(load_const_small_int, import_level);
|
|
|
|
// build the "fromlist" tuple
|
|
mp_parse_node_t *pn_nodes;
|
|
size_t n = mp_parse_node_extract_list(&pns->nodes[1], PN_import_as_names, &pn_nodes);
|
|
for (size_t i = 0; i < n; i++) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
|
|
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pn_nodes[i];
|
|
qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
|
|
EMIT_ARG(load_const_str, id2);
|
|
}
|
|
EMIT_ARG(build, n, MP_EMIT_BUILD_TUPLE);
|
|
|
|
// do the import
|
|
qstr dummy_q;
|
|
do_import_name(comp, pn_import_source, &dummy_q);
|
|
for (size_t i = 0; i < n; i++) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
|
|
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pn_nodes[i];
|
|
qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
|
|
EMIT_ARG(import, id2, MP_EMIT_IMPORT_FROM);
|
|
if (MP_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
|
|
compile_store_id(comp, id2);
|
|
} else {
|
|
compile_store_id(comp, MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
|
|
}
|
|
}
|
|
EMIT(pop_top);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_declare_global(compiler_t *comp, mp_parse_node_t pn, id_info_t *id_info) {
|
|
if (id_info->kind != ID_INFO_KIND_UNDECIDED && id_info->kind != ID_INFO_KIND_GLOBAL_EXPLICIT) {
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("identifier redefined as global"));
|
|
return;
|
|
}
|
|
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
|
|
|
|
// if the id exists in the global scope, set its kind to EXPLICIT_GLOBAL
|
|
id_info = scope_find_global(comp->scope_cur, id_info->qst);
|
|
if (id_info != NULL) {
|
|
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
|
|
}
|
|
}
|
|
|
|
STATIC void compile_declare_nonlocal(compiler_t *comp, mp_parse_node_t pn, id_info_t *id_info) {
|
|
if (id_info->kind == ID_INFO_KIND_UNDECIDED) {
|
|
id_info->kind = ID_INFO_KIND_GLOBAL_IMPLICIT;
|
|
scope_check_to_close_over(comp->scope_cur, id_info);
|
|
if (id_info->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("no binding for nonlocal found"));
|
|
}
|
|
} else if (id_info->kind != ID_INFO_KIND_FREE) {
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("identifier redefined as nonlocal"));
|
|
}
|
|
}
|
|
|
|
STATIC void compile_global_nonlocal_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
bool is_global = MP_PARSE_NODE_STRUCT_KIND(pns) == PN_global_stmt;
|
|
|
|
if (!is_global && comp->scope_cur->kind == SCOPE_MODULE) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("can't declare nonlocal in outer code"));
|
|
return;
|
|
}
|
|
|
|
mp_parse_node_t *nodes;
|
|
size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_name_list, &nodes);
|
|
for (size_t i = 0; i < n; i++) {
|
|
qstr qst = MP_PARSE_NODE_LEAF_ARG(nodes[i]);
|
|
id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qst, ID_INFO_KIND_UNDECIDED);
|
|
if (is_global) {
|
|
compile_declare_global(comp, (mp_parse_node_t)pns, id_info);
|
|
} else {
|
|
compile_declare_nonlocal(comp, (mp_parse_node_t)pns, id_info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC void compile_assert_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// with optimisations enabled we don't compile assertions
|
|
if (MP_STATE_VM(mp_optimise_value) != 0) {
|
|
return;
|
|
}
|
|
|
|
uint l_end = comp_next_label(comp);
|
|
c_if_cond(comp, pns->nodes[0], true, l_end);
|
|
EMIT_LOAD_GLOBAL(MP_QSTR_AssertionError); // we load_global instead of load_id, to be consistent with CPython
|
|
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
|
|
// assertion message
|
|
compile_node(comp, pns->nodes[1]);
|
|
EMIT_ARG(call_function, 1, 0, 0);
|
|
}
|
|
EMIT_ARG(raise_varargs, 1);
|
|
EMIT_ARG(label_assign, l_end);
|
|
}
|
|
|
|
STATIC void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
uint l_end = comp_next_label(comp);
|
|
|
|
// optimisation: don't emit anything when "if False"
|
|
if (!mp_parse_node_is_const_false(pns->nodes[0])) {
|
|
uint l_fail = comp_next_label(comp);
|
|
c_if_cond(comp, pns->nodes[0], false, l_fail); // if condition
|
|
|
|
compile_node(comp, pns->nodes[1]); // if block
|
|
|
|
// optimisation: skip everything else when "if True"
|
|
if (mp_parse_node_is_const_true(pns->nodes[0])) {
|
|
goto done;
|
|
}
|
|
|
|
if (
|
|
// optimisation: don't jump over non-existent elif/else blocks
|
|
!(MP_PARSE_NODE_IS_NULL(pns->nodes[2]) && MP_PARSE_NODE_IS_NULL(pns->nodes[3]))
|
|
// optimisation: don't jump if last instruction was return
|
|
&& !EMIT(last_emit_was_return_value)
|
|
) {
|
|
// jump over elif/else blocks
|
|
EMIT_ARG(jump, l_end);
|
|
}
|
|
|
|
EMIT_ARG(label_assign, l_fail);
|
|
}
|
|
|
|
// compile elif blocks (if any)
|
|
mp_parse_node_t *pn_elif;
|
|
size_t n_elif = mp_parse_node_extract_list(&pns->nodes[2], PN_if_stmt_elif_list, &pn_elif);
|
|
for (size_t i = 0; i < n_elif; i++) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_elif[i], PN_if_stmt_elif)); // should be
|
|
mp_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t *)pn_elif[i];
|
|
|
|
// optimisation: don't emit anything when "if False"
|
|
if (!mp_parse_node_is_const_false(pns_elif->nodes[0])) {
|
|
uint l_fail = comp_next_label(comp);
|
|
c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition
|
|
|
|
compile_node(comp, pns_elif->nodes[1]); // elif block
|
|
|
|
// optimisation: skip everything else when "elif True"
|
|
if (mp_parse_node_is_const_true(pns_elif->nodes[0])) {
|
|
goto done;
|
|
}
|
|
|
|
// optimisation: don't jump if last instruction was return
|
|
if (!EMIT(last_emit_was_return_value)) {
|
|
EMIT_ARG(jump, l_end);
|
|
}
|
|
EMIT_ARG(label_assign, l_fail);
|
|
}
|
|
}
|
|
|
|
// compile else block
|
|
compile_node(comp, pns->nodes[3]); // can be null
|
|
|
|
done:
|
|
EMIT_ARG(label_assign, l_end);
|
|
}
|
|
|
|
#define START_BREAK_CONTINUE_BLOCK \
|
|
uint16_t old_break_label = comp->break_label; \
|
|
uint16_t old_continue_label = comp->continue_label; \
|
|
uint16_t old_break_continue_except_level = comp->break_continue_except_level; \
|
|
uint break_label = comp_next_label(comp); \
|
|
uint continue_label = comp_next_label(comp); \
|
|
comp->break_label = break_label; \
|
|
comp->continue_label = continue_label; \
|
|
comp->break_continue_except_level = comp->cur_except_level;
|
|
|
|
#define END_BREAK_CONTINUE_BLOCK \
|
|
comp->break_label = old_break_label; \
|
|
comp->continue_label = old_continue_label; \
|
|
comp->break_continue_except_level = old_break_continue_except_level;
|
|
|
|
STATIC void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
START_BREAK_CONTINUE_BLOCK
|
|
|
|
if (!mp_parse_node_is_const_false(pns->nodes[0])) { // optimisation: don't emit anything for "while False"
|
|
uint top_label = comp_next_label(comp);
|
|
if (!mp_parse_node_is_const_true(pns->nodes[0])) { // optimisation: don't jump to cond for "while True"
|
|
EMIT_ARG(jump, continue_label);
|
|
}
|
|
EMIT_ARG(label_assign, top_label);
|
|
compile_node(comp, pns->nodes[1]); // body
|
|
EMIT_ARG(label_assign, continue_label);
|
|
c_if_cond(comp, pns->nodes[0], true, top_label); // condition
|
|
}
|
|
|
|
// break/continue apply to outer loop (if any) in the else block
|
|
END_BREAK_CONTINUE_BLOCK
|
|
|
|
compile_node(comp, pns->nodes[2]); // else
|
|
|
|
EMIT_ARG(label_assign, break_label);
|
|
}
|
|
|
|
// This function compiles an optimised for-loop of the form:
|
|
// for <var> in range(<start>, <end>, <step>):
|
|
// <body>
|
|
// else:
|
|
// <else>
|
|
// <var> must be an identifier and <step> must be a small-int.
|
|
//
|
|
// Semantics of for-loop require:
|
|
// - final failing value should not be stored in the loop variable
|
|
// - if the loop never runs, the loop variable should never be assigned
|
|
// - assignments to <var>, <end> or <step> in the body do not alter the loop
|
|
// (<step> is a constant for us, so no need to worry about it changing)
|
|
//
|
|
// If <end> is a small-int, then the stack during the for-loop contains just
|
|
// the current value of <var>. Otherwise, the stack contains <end> then the
|
|
// current value of <var>.
|
|
STATIC void compile_for_stmt_optimised_range(compiler_t *comp, mp_parse_node_t pn_var, mp_parse_node_t pn_start, mp_parse_node_t pn_end, mp_parse_node_t pn_step, mp_parse_node_t pn_body, mp_parse_node_t pn_else) {
|
|
START_BREAK_CONTINUE_BLOCK
|
|
|
|
uint top_label = comp_next_label(comp);
|
|
uint entry_label = comp_next_label(comp);
|
|
|
|
// put the end value on the stack if it's not a small-int constant
|
|
bool end_on_stack = !MP_PARSE_NODE_IS_SMALL_INT(pn_end);
|
|
if (end_on_stack) {
|
|
compile_node(comp, pn_end);
|
|
}
|
|
|
|
// compile: start
|
|
compile_node(comp, pn_start);
|
|
|
|
EMIT_ARG(jump, entry_label);
|
|
EMIT_ARG(label_assign, top_label);
|
|
|
|
// duplicate next value and store it to var
|
|
EMIT(dup_top);
|
|
c_assign(comp, pn_var, ASSIGN_STORE);
|
|
|
|
// compile body
|
|
compile_node(comp, pn_body);
|
|
|
|
EMIT_ARG(label_assign, continue_label);
|
|
|
|
// compile: var + step
|
|
compile_node(comp, pn_step);
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_INPLACE_ADD);
|
|
|
|
EMIT_ARG(label_assign, entry_label);
|
|
|
|
// compile: if var <cond> end: goto top
|
|
if (end_on_stack) {
|
|
EMIT(dup_top_two);
|
|
EMIT(rot_two);
|
|
} else {
|
|
EMIT(dup_top);
|
|
compile_node(comp, pn_end);
|
|
}
|
|
assert(MP_PARSE_NODE_IS_SMALL_INT(pn_step));
|
|
if (MP_PARSE_NODE_LEAF_SMALL_INT(pn_step) >= 0) {
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_LESS);
|
|
} else {
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_MORE);
|
|
}
|
|
EMIT_ARG(pop_jump_if, true, top_label);
|
|
|
|
// break/continue apply to outer loop (if any) in the else block
|
|
END_BREAK_CONTINUE_BLOCK
|
|
|
|
// Compile the else block. We must pop the iterator variables before
|
|
// executing the else code because it may contain break/continue statements.
|
|
uint end_label = 0;
|
|
if (!MP_PARSE_NODE_IS_NULL(pn_else)) {
|
|
// discard final value of "var", and possible "end" value
|
|
EMIT(pop_top);
|
|
if (end_on_stack) {
|
|
EMIT(pop_top);
|
|
}
|
|
compile_node(comp, pn_else);
|
|
end_label = comp_next_label(comp);
|
|
EMIT_ARG(jump, end_label);
|
|
EMIT_ARG(adjust_stack_size, 1 + end_on_stack);
|
|
}
|
|
|
|
EMIT_ARG(label_assign, break_label);
|
|
|
|
// discard final value of var that failed the loop condition
|
|
EMIT(pop_top);
|
|
|
|
// discard <end> value if it's on the stack
|
|
if (end_on_stack) {
|
|
EMIT(pop_top);
|
|
}
|
|
|
|
if (!MP_PARSE_NODE_IS_NULL(pn_else)) {
|
|
EMIT_ARG(label_assign, end_label);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// this bit optimises: for <x> in range(...), turning it into an explicitly incremented variable
|
|
// this is actually slower, but uses no heap memory
|
|
// for viper it will be much, much faster
|
|
if (/*comp->scope_cur->emit_options == MP_EMIT_OPT_VIPER &&*/ MP_PARSE_NODE_IS_ID(pns->nodes[0]) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_atom_expr_normal)) {
|
|
mp_parse_node_struct_t *pns_it = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
if (MP_PARSE_NODE_IS_ID(pns_it->nodes[0])
|
|
&& MP_PARSE_NODE_LEAF_ARG(pns_it->nodes[0]) == MP_QSTR_range
|
|
&& MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pns_it->nodes[1]) == PN_trailer_paren) {
|
|
mp_parse_node_t pn_range_args = ((mp_parse_node_struct_t *)pns_it->nodes[1])->nodes[0];
|
|
mp_parse_node_t *args;
|
|
size_t n_args = mp_parse_node_extract_list(&pn_range_args, PN_arglist, &args);
|
|
mp_parse_node_t pn_range_start;
|
|
mp_parse_node_t pn_range_end;
|
|
mp_parse_node_t pn_range_step;
|
|
bool optimize = false;
|
|
if (1 <= n_args && n_args <= 3) {
|
|
optimize = true;
|
|
if (n_args == 1) {
|
|
pn_range_start = mp_parse_node_new_small_int(0);
|
|
pn_range_end = args[0];
|
|
pn_range_step = mp_parse_node_new_small_int(1);
|
|
} else if (n_args == 2) {
|
|
pn_range_start = args[0];
|
|
pn_range_end = args[1];
|
|
pn_range_step = mp_parse_node_new_small_int(1);
|
|
} else {
|
|
pn_range_start = args[0];
|
|
pn_range_end = args[1];
|
|
pn_range_step = args[2];
|
|
// the step must be a non-zero constant integer to do the optimisation
|
|
if (!MP_PARSE_NODE_IS_SMALL_INT(pn_range_step)
|
|
|| MP_PARSE_NODE_LEAF_SMALL_INT(pn_range_step) == 0) {
|
|
optimize = false;
|
|
}
|
|
}
|
|
// arguments must be able to be compiled as standard expressions
|
|
if (optimize && MP_PARSE_NODE_IS_STRUCT(pn_range_start)) {
|
|
int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_range_start);
|
|
if (k == PN_arglist_star || k == PN_arglist_dbl_star || k == PN_argument) {
|
|
optimize = false;
|
|
}
|
|
}
|
|
if (optimize && MP_PARSE_NODE_IS_STRUCT(pn_range_end)) {
|
|
int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_range_end);
|
|
if (k == PN_arglist_star || k == PN_arglist_dbl_star || k == PN_argument) {
|
|
optimize = false;
|
|
}
|
|
}
|
|
}
|
|
if (optimize) {
|
|
compile_for_stmt_optimised_range(comp, pns->nodes[0], pn_range_start, pn_range_end, pn_range_step, pns->nodes[2], pns->nodes[3]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
START_BREAK_CONTINUE_BLOCK
|
|
comp->break_label |= MP_EMIT_BREAK_FROM_FOR;
|
|
|
|
uint pop_label = comp_next_label(comp);
|
|
|
|
compile_node(comp, pns->nodes[1]); // iterator
|
|
EMIT_ARG(get_iter, true);
|
|
EMIT_ARG(label_assign, continue_label);
|
|
EMIT_ARG(for_iter, pop_label);
|
|
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
|
|
compile_node(comp, pns->nodes[2]); // body
|
|
if (!EMIT(last_emit_was_return_value)) {
|
|
EMIT_ARG(jump, continue_label);
|
|
}
|
|
EMIT_ARG(label_assign, pop_label);
|
|
EMIT(for_iter_end);
|
|
|
|
// break/continue apply to outer loop (if any) in the else block
|
|
END_BREAK_CONTINUE_BLOCK
|
|
|
|
compile_node(comp, pns->nodes[3]); // else (may be empty)
|
|
|
|
EMIT_ARG(label_assign, break_label);
|
|
}
|
|
|
|
STATIC void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_except, mp_parse_node_t *pn_excepts, mp_parse_node_t pn_else) {
|
|
// setup code
|
|
uint l1 = comp_next_label(comp);
|
|
uint success_label = comp_next_label(comp);
|
|
|
|
compile_increase_except_level(comp, l1, MP_EMIT_SETUP_BLOCK_EXCEPT);
|
|
|
|
compile_node(comp, pn_body); // body
|
|
EMIT_ARG(pop_except_jump, success_label, false); // jump over exception handler
|
|
|
|
EMIT_ARG(label_assign, l1); // start of exception handler
|
|
EMIT(start_except_handler);
|
|
|
|
// at this point the top of the stack contains the exception instance that was raised
|
|
|
|
uint l2 = comp_next_label(comp);
|
|
|
|
for (int i = 0; i < n_except; i++) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
|
|
mp_parse_node_struct_t *pns_except = (mp_parse_node_struct_t *)pn_excepts[i];
|
|
|
|
qstr qstr_exception_local = 0;
|
|
uint end_finally_label = comp_next_label(comp);
|
|
#if MICROPY_PY_SYS_SETTRACE
|
|
EMIT_ARG(set_source_line, pns_except->source_line);
|
|
#endif
|
|
|
|
if (MP_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
|
|
// this is a catch all exception handler
|
|
if (i + 1 != n_except) {
|
|
compile_syntax_error(comp, pn_excepts[i], MP_ERROR_TEXT("default 'except' must be last"));
|
|
compile_decrease_except_level(comp);
|
|
return;
|
|
}
|
|
} else {
|
|
// this exception handler requires a match to a certain type of exception
|
|
mp_parse_node_t pns_exception_expr = pns_except->nodes[0];
|
|
if (MP_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
|
|
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pns_exception_expr;
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
|
|
// handler binds the exception to a local
|
|
pns_exception_expr = pns3->nodes[0];
|
|
qstr_exception_local = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]);
|
|
}
|
|
}
|
|
EMIT(dup_top);
|
|
compile_node(comp, pns_exception_expr);
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_EXCEPTION_MATCH);
|
|
EMIT_ARG(pop_jump_if, false, end_finally_label);
|
|
}
|
|
|
|
// either discard or store the exception instance
|
|
if (qstr_exception_local == 0) {
|
|
EMIT(pop_top);
|
|
} else {
|
|
compile_store_id(comp, qstr_exception_local);
|
|
}
|
|
|
|
// If the exception is bound to a variable <e> then the <body> of the
|
|
// exception handler is wrapped in a try-finally so that the name <e> can
|
|
// be deleted (per Python semantics) even if the <body> has an exception.
|
|
// In such a case the generated code for the exception handler is:
|
|
// try:
|
|
// <body>
|
|
// finally:
|
|
// <e> = None
|
|
// del <e>
|
|
uint l3 = 0;
|
|
if (qstr_exception_local != 0) {
|
|
l3 = comp_next_label(comp);
|
|
compile_increase_except_level(comp, l3, MP_EMIT_SETUP_BLOCK_FINALLY);
|
|
}
|
|
compile_node(comp, pns_except->nodes[1]); // the <body>
|
|
if (qstr_exception_local != 0) {
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT_ARG(label_assign, l3);
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
compile_store_id(comp, qstr_exception_local);
|
|
compile_delete_id(comp, qstr_exception_local);
|
|
compile_decrease_except_level(comp);
|
|
}
|
|
|
|
EMIT_ARG(pop_except_jump, l2, true);
|
|
EMIT_ARG(label_assign, end_finally_label);
|
|
EMIT_ARG(adjust_stack_size, 1); // stack adjust for the exception instance
|
|
}
|
|
|
|
compile_decrease_except_level(comp);
|
|
EMIT(end_except_handler);
|
|
|
|
EMIT_ARG(label_assign, success_label);
|
|
compile_node(comp, pn_else); // else block, can be null
|
|
EMIT_ARG(label_assign, l2);
|
|
}
|
|
|
|
STATIC void compile_try_finally(compiler_t *comp, mp_parse_node_t pn_body, int n_except, mp_parse_node_t *pn_except, mp_parse_node_t pn_else, mp_parse_node_t pn_finally) {
|
|
uint l_finally_block = comp_next_label(comp);
|
|
|
|
compile_increase_except_level(comp, l_finally_block, MP_EMIT_SETUP_BLOCK_FINALLY);
|
|
|
|
if (n_except == 0) {
|
|
assert(MP_PARSE_NODE_IS_NULL(pn_else));
|
|
EMIT_ARG(adjust_stack_size, 3); // stack adjust for possible UNWIND_JUMP state
|
|
compile_node(comp, pn_body);
|
|
EMIT_ARG(adjust_stack_size, -3);
|
|
} else {
|
|
compile_try_except(comp, pn_body, n_except, pn_except, pn_else);
|
|
}
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT_ARG(label_assign, l_finally_block);
|
|
compile_node(comp, pn_finally);
|
|
|
|
compile_decrease_except_level(comp);
|
|
}
|
|
|
|
STATIC void compile_try_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should be
|
|
{
|
|
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
|
|
// just try-finally
|
|
compile_try_finally(comp, pns->nodes[0], 0, NULL, MP_PARSE_NODE_NULL, pns2->nodes[0]);
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_except_and_more) {
|
|
// try-except and possibly else and/or finally
|
|
mp_parse_node_t *pn_excepts;
|
|
size_t n_except = mp_parse_node_extract_list(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
|
|
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
|
|
// no finally
|
|
compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1]);
|
|
} else {
|
|
// have finally
|
|
compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((mp_parse_node_struct_t *)pns2->nodes[2])->nodes[0]);
|
|
}
|
|
} else {
|
|
// just try-except
|
|
mp_parse_node_t *pn_excepts;
|
|
size_t n_except = mp_parse_node_extract_list(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
|
|
compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, MP_PARSE_NODE_NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC void compile_with_stmt_helper(compiler_t *comp, size_t n, mp_parse_node_t *nodes, mp_parse_node_t body) {
|
|
if (n == 0) {
|
|
// no more pre-bits, compile the body of the with
|
|
compile_node(comp, body);
|
|
} else {
|
|
uint l_end = comp_next_label(comp);
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
|
|
// this pre-bit is of the form "a as b"
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)nodes[0];
|
|
compile_node(comp, pns->nodes[0]);
|
|
compile_increase_except_level(comp, l_end, MP_EMIT_SETUP_BLOCK_WITH);
|
|
c_assign(comp, pns->nodes[1], ASSIGN_STORE);
|
|
} else {
|
|
// this pre-bit is just an expression
|
|
compile_node(comp, nodes[0]);
|
|
compile_increase_except_level(comp, l_end, MP_EMIT_SETUP_BLOCK_WITH);
|
|
EMIT(pop_top);
|
|
}
|
|
// compile additional pre-bits and the body
|
|
compile_with_stmt_helper(comp, n - 1, nodes + 1, body);
|
|
// finish this with block
|
|
EMIT_ARG(with_cleanup, l_end);
|
|
reserve_labels_for_native(comp, 3); // used by native's with_cleanup
|
|
compile_decrease_except_level(comp);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
|
|
mp_parse_node_t *nodes;
|
|
size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
|
|
assert(n > 0);
|
|
|
|
// compile in a nested fashion
|
|
compile_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
|
|
}
|
|
|
|
STATIC void compile_yield_from(compiler_t *comp) {
|
|
EMIT_ARG(get_iter, false);
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT_ARG(yield, MP_EMIT_YIELD_FROM);
|
|
reserve_labels_for_native(comp, 3);
|
|
}
|
|
|
|
#if MICROPY_PY_ASYNC_AWAIT
|
|
STATIC void compile_await_object_method(compiler_t *comp, qstr method) {
|
|
EMIT_ARG(load_method, method, false);
|
|
EMIT_ARG(call_method, 0, 0, 0);
|
|
compile_yield_from(comp);
|
|
}
|
|
|
|
STATIC void compile_async_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// comp->break_label |= MP_EMIT_BREAK_FROM_FOR;
|
|
qstr context = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
|
|
uint while_else_label = comp_next_label(comp);
|
|
uint try_exception_label = comp_next_label(comp);
|
|
uint try_else_label = comp_next_label(comp);
|
|
uint try_finally_label = comp_next_label(comp);
|
|
|
|
compile_node(comp, pns->nodes[1]); // iterator
|
|
EMIT_ARG(load_method, MP_QSTR___aiter__, false);
|
|
EMIT_ARG(call_method, 0, 0, 0);
|
|
compile_store_id(comp, context);
|
|
|
|
START_BREAK_CONTINUE_BLOCK
|
|
|
|
EMIT_ARG(label_assign, continue_label);
|
|
|
|
compile_increase_except_level(comp, try_exception_label, MP_EMIT_SETUP_BLOCK_EXCEPT);
|
|
|
|
compile_load_id(comp, context);
|
|
compile_await_object_method(comp, MP_QSTR___anext__);
|
|
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
|
|
EMIT_ARG(pop_except_jump, try_else_label, false);
|
|
|
|
EMIT_ARG(label_assign, try_exception_label);
|
|
EMIT(start_except_handler);
|
|
EMIT(dup_top);
|
|
EMIT_LOAD_GLOBAL(MP_QSTR_StopAsyncIteration);
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_EXCEPTION_MATCH);
|
|
EMIT_ARG(pop_jump_if, false, try_finally_label);
|
|
EMIT(pop_top); // pop exception instance
|
|
EMIT_ARG(pop_except_jump, while_else_label, true);
|
|
|
|
EMIT_ARG(label_assign, try_finally_label);
|
|
EMIT_ARG(adjust_stack_size, 1); // if we jump here, the exc is on the stack
|
|
compile_decrease_except_level(comp);
|
|
EMIT(end_except_handler);
|
|
|
|
EMIT_ARG(label_assign, try_else_label);
|
|
compile_node(comp, pns->nodes[2]); // body
|
|
|
|
EMIT_ARG(jump, continue_label);
|
|
// break/continue apply to outer loop (if any) in the else block
|
|
END_BREAK_CONTINUE_BLOCK
|
|
|
|
EMIT_ARG(label_assign, while_else_label);
|
|
compile_node(comp, pns->nodes[3]); // else
|
|
|
|
EMIT_ARG(label_assign, break_label);
|
|
}
|
|
|
|
STATIC void compile_async_with_stmt_helper(compiler_t *comp, size_t n, mp_parse_node_t *nodes, mp_parse_node_t body) {
|
|
if (n == 0) {
|
|
// no more pre-bits, compile the body of the with
|
|
compile_node(comp, body);
|
|
} else {
|
|
uint l_finally_block = comp_next_label(comp);
|
|
uint l_aexit_no_exc = comp_next_label(comp);
|
|
uint l_ret_unwind_jump = comp_next_label(comp);
|
|
uint l_end = comp_next_label(comp);
|
|
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
|
|
// this pre-bit is of the form "a as b"
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)nodes[0];
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT(dup_top);
|
|
compile_await_object_method(comp, MP_QSTR___aenter__);
|
|
c_assign(comp, pns->nodes[1], ASSIGN_STORE);
|
|
} else {
|
|
// this pre-bit is just an expression
|
|
compile_node(comp, nodes[0]);
|
|
EMIT(dup_top);
|
|
compile_await_object_method(comp, MP_QSTR___aenter__);
|
|
EMIT(pop_top);
|
|
}
|
|
|
|
// To keep the Python stack size down, and because we can't access values on
|
|
// this stack further down than 3 elements (via rot_three), we don't preload
|
|
// __aexit__ (as per normal with) but rather wait until we need it below.
|
|
|
|
// Start the try-finally statement
|
|
compile_increase_except_level(comp, l_finally_block, MP_EMIT_SETUP_BLOCK_FINALLY);
|
|
|
|
// Compile any additional pre-bits of the "async with", and also the body
|
|
EMIT_ARG(adjust_stack_size, 3); // stack adjust for possible UNWIND_JUMP state
|
|
compile_async_with_stmt_helper(comp, n - 1, nodes + 1, body);
|
|
EMIT_ARG(adjust_stack_size, -3);
|
|
|
|
// We have now finished the "try" block and fall through to the "finally"
|
|
|
|
// At this point, after the with body has executed, we have 3 cases:
|
|
// 1. no exception, we just fall through to this point; stack: (..., ctx_mgr)
|
|
// 2. exception propagating out, we get to the finally block; stack: (..., ctx_mgr, exc)
|
|
// 3. return or unwind jump, we get to the finally block; stack: (..., ctx_mgr, X, INT)
|
|
|
|
// Handle case 1: call __aexit__
|
|
// Stack: (..., ctx_mgr)
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE); // to tell end_finally there's no exception
|
|
EMIT(rot_two);
|
|
EMIT_ARG(jump, l_aexit_no_exc); // jump to code below to call __aexit__
|
|
|
|
// Start of "finally" block
|
|
// At this point we have case 2 or 3, we detect which one by the TOS being an exception or not
|
|
EMIT_ARG(label_assign, l_finally_block);
|
|
|
|
// Detect if TOS an exception or not
|
|
EMIT(dup_top);
|
|
EMIT_LOAD_GLOBAL(MP_QSTR_BaseException);
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_EXCEPTION_MATCH);
|
|
EMIT_ARG(pop_jump_if, false, l_ret_unwind_jump); // if not an exception then we have case 3
|
|
|
|
// Handle case 2: call __aexit__ and either swallow or re-raise the exception
|
|
// Stack: (..., ctx_mgr, exc)
|
|
EMIT(dup_top);
|
|
EMIT(rot_three);
|
|
EMIT(rot_two);
|
|
EMIT_ARG(load_method, MP_QSTR___aexit__, false);
|
|
EMIT(rot_three);
|
|
EMIT(rot_three);
|
|
EMIT(dup_top);
|
|
#if MICROPY_CPYTHON_COMPAT
|
|
EMIT_ARG(attr, MP_QSTR___class__, MP_EMIT_ATTR_LOAD); // get type(exc)
|
|
#else
|
|
compile_load_id(comp, MP_QSTR_type);
|
|
EMIT(rot_two);
|
|
EMIT_ARG(call_function, 1, 0, 0); // get type(exc)
|
|
#endif
|
|
EMIT(rot_two);
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE); // dummy traceback value
|
|
// Stack: (..., exc, __aexit__, ctx_mgr, type(exc), exc, None)
|
|
EMIT_ARG(call_method, 3, 0, 0);
|
|
compile_yield_from(comp);
|
|
EMIT_ARG(pop_jump_if, false, l_end);
|
|
EMIT(pop_top); // pop exception
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE); // replace with None to swallow exception
|
|
EMIT_ARG(jump, l_end);
|
|
EMIT_ARG(adjust_stack_size, 2);
|
|
|
|
// Handle case 3: call __aexit__
|
|
// Stack: (..., ctx_mgr, X, INT)
|
|
EMIT_ARG(label_assign, l_ret_unwind_jump);
|
|
EMIT(rot_three);
|
|
EMIT(rot_three);
|
|
EMIT_ARG(label_assign, l_aexit_no_exc);
|
|
EMIT_ARG(load_method, MP_QSTR___aexit__, false);
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT(dup_top);
|
|
EMIT(dup_top);
|
|
EMIT_ARG(call_method, 3, 0, 0);
|
|
compile_yield_from(comp);
|
|
EMIT(pop_top);
|
|
EMIT_ARG(adjust_stack_size, -1);
|
|
|
|
// End of "finally" block
|
|
// Stack can have one of three configurations:
|
|
// a. (..., None) - from either case 1, or case 2 with swallowed exception
|
|
// b. (..., exc) - from case 2 with re-raised exception
|
|
// c. (..., X, INT) - from case 3
|
|
EMIT_ARG(label_assign, l_end);
|
|
compile_decrease_except_level(comp);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_async_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
|
|
mp_parse_node_t *nodes;
|
|
size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
|
|
assert(n > 0);
|
|
|
|
// compile in a nested fashion
|
|
compile_async_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
|
|
}
|
|
|
|
STATIC void compile_async_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[0]));
|
|
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_funcdef) {
|
|
// async def
|
|
compile_funcdef(comp, pns0);
|
|
scope_t *fscope = (scope_t *)pns0->nodes[4];
|
|
fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR | MP_SCOPE_FLAG_ASYNC;
|
|
} else {
|
|
// async for/with; first verify the scope is a generator
|
|
int scope_flags = comp->scope_cur->scope_flags;
|
|
if (!(scope_flags & MP_SCOPE_FLAG_GENERATOR)) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns0,
|
|
MP_ERROR_TEXT("'await', 'async for' or 'async with' outside async function"));
|
|
return;
|
|
}
|
|
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_for_stmt) {
|
|
// async for
|
|
compile_async_for_stmt(comp, pns0);
|
|
} else {
|
|
// async with
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_with_stmt);
|
|
compile_async_with_stmt(comp, pns0);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
mp_parse_node_t pn_rhs = pns->nodes[1];
|
|
if (MP_PARSE_NODE_IS_NULL(pn_rhs)) {
|
|
if (comp->is_repl && comp->scope_cur->kind == SCOPE_MODULE) {
|
|
// for REPL, evaluate then print the expression
|
|
compile_load_id(comp, MP_QSTR___repl_print__);
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT_ARG(call_function, 1, 0, 0);
|
|
EMIT(pop_top);
|
|
|
|
} else {
|
|
// for non-REPL, evaluate then discard the expression
|
|
if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !MP_PARSE_NODE_IS_ID(pns->nodes[0]))
|
|
|| MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)) {
|
|
// do nothing with a lonely constant
|
|
} else {
|
|
compile_node(comp, pns->nodes[0]); // just an expression
|
|
EMIT(pop_top); // discard last result since this is a statement and leaves nothing on the stack
|
|
}
|
|
}
|
|
} else if (MP_PARSE_NODE_IS_STRUCT(pn_rhs)) {
|
|
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pn_rhs;
|
|
int kind = MP_PARSE_NODE_STRUCT_KIND(pns1);
|
|
if (kind == PN_annassign) {
|
|
// the annotation is in pns1->nodes[0] and is ignored
|
|
if (MP_PARSE_NODE_IS_NULL(pns1->nodes[1])) {
|
|
// an annotation of the form "x: y"
|
|
// inside a function this declares "x" as a local
|
|
if (comp->scope_cur->kind == SCOPE_FUNCTION) {
|
|
if (MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
|
|
qstr lhs = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
|
|
scope_find_or_add_id(comp->scope_cur, lhs, ID_INFO_KIND_LOCAL);
|
|
}
|
|
}
|
|
} else {
|
|
// an assigned annotation of the form "x: y = z"
|
|
pn_rhs = pns1->nodes[1];
|
|
goto plain_assign;
|
|
}
|
|
} else if (kind == PN_expr_stmt_augassign) {
|
|
c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
|
|
compile_node(comp, pns1->nodes[1]); // rhs
|
|
assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
|
|
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]);
|
|
mp_binary_op_t op = MP_BINARY_OP_INPLACE_OR + (tok - MP_TOKEN_DEL_PIPE_EQUAL);
|
|
EMIT_ARG(binary_op, op);
|
|
c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
|
|
} else if (kind == PN_expr_stmt_assign_list) {
|
|
int rhs = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1) - 1;
|
|
compile_node(comp, pns1->nodes[rhs]); // rhs
|
|
// following CPython, we store left-most first
|
|
if (rhs > 0) {
|
|
EMIT(dup_top);
|
|
}
|
|
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
|
|
for (int i = 0; i < rhs; i++) {
|
|
if (i + 1 < rhs) {
|
|
EMIT(dup_top);
|
|
}
|
|
c_assign(comp, pns1->nodes[i], ASSIGN_STORE); // middle store
|
|
}
|
|
} else {
|
|
plain_assign:
|
|
#if MICROPY_COMP_DOUBLE_TUPLE_ASSIGN
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_rhs, PN_testlist_star_expr)
|
|
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)) {
|
|
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
pns1 = (mp_parse_node_struct_t *)pn_rhs;
|
|
uint32_t n_pns0 = MP_PARSE_NODE_STRUCT_NUM_NODES(pns0);
|
|
// Can only optimise a tuple-to-tuple assignment when all of the following hold:
|
|
// - equal number of items in LHS and RHS tuples
|
|
// - 2 or 3 items in the tuples
|
|
// - there are no star expressions in the LHS tuple
|
|
if (n_pns0 == MP_PARSE_NODE_STRUCT_NUM_NODES(pns1)
|
|
&& (n_pns0 == 2
|
|
#if MICROPY_COMP_TRIPLE_TUPLE_ASSIGN
|
|
|| n_pns0 == 3
|
|
#endif
|
|
)
|
|
&& !MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[0], PN_star_expr)
|
|
&& !MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[1], PN_star_expr)
|
|
#if MICROPY_COMP_TRIPLE_TUPLE_ASSIGN
|
|
&& (n_pns0 == 2 || !MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[2], PN_star_expr))
|
|
#endif
|
|
) {
|
|
// Optimisation for a, b = c, d or a, b, c = d, e, f
|
|
compile_node(comp, pns1->nodes[0]); // rhs
|
|
compile_node(comp, pns1->nodes[1]); // rhs
|
|
#if MICROPY_COMP_TRIPLE_TUPLE_ASSIGN
|
|
if (n_pns0 == 3) {
|
|
compile_node(comp, pns1->nodes[2]); // rhs
|
|
EMIT(rot_three);
|
|
}
|
|
#endif
|
|
EMIT(rot_two);
|
|
c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
|
|
c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
|
|
#if MICROPY_COMP_TRIPLE_TUPLE_ASSIGN
|
|
if (n_pns0 == 3) {
|
|
c_assign(comp, pns0->nodes[2], ASSIGN_STORE); // lhs store
|
|
}
|
|
#endif
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
compile_node(comp, pn_rhs); // rhs
|
|
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
|
|
}
|
|
} else {
|
|
goto plain_assign;
|
|
}
|
|
}
|
|
|
|
STATIC void compile_test_if_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
|
|
mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
|
|
uint l_fail = comp_next_label(comp);
|
|
uint l_end = comp_next_label(comp);
|
|
c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
|
|
compile_node(comp, pns->nodes[0]); // success value
|
|
EMIT_ARG(jump, l_end);
|
|
EMIT_ARG(label_assign, l_fail);
|
|
EMIT_ARG(adjust_stack_size, -1); // adjust stack size
|
|
compile_node(comp, pns_test_if_else->nodes[1]); // failure value
|
|
EMIT_ARG(label_assign, l_end);
|
|
}
|
|
|
|
STATIC void compile_lambdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
// create a new scope for this lambda
|
|
scope_t *s = scope_new_and_link(comp, SCOPE_LAMBDA, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
|
|
// store the lambda scope so the compiling function (this one) can use it at each pass
|
|
pns->nodes[2] = (mp_parse_node_t)s;
|
|
}
|
|
|
|
// get the scope for this lambda
|
|
scope_t *this_scope = (scope_t *)pns->nodes[2];
|
|
|
|
// compile the lambda definition
|
|
compile_funcdef_lambdef(comp, this_scope, pns->nodes[0], PN_varargslist);
|
|
}
|
|
|
|
#if MICROPY_PY_ASSIGN_EXPR
|
|
STATIC void compile_namedexpr_helper(compiler_t *comp, mp_parse_node_t pn_name, mp_parse_node_t pn_expr) {
|
|
if (!MP_PARSE_NODE_IS_ID(pn_name)) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pn_name, MP_ERROR_TEXT("can't assign to expression"));
|
|
}
|
|
compile_node(comp, pn_expr);
|
|
EMIT(dup_top);
|
|
scope_t *old_scope = comp->scope_cur;
|
|
if (SCOPE_IS_COMP_LIKE(comp->scope_cur->kind)) {
|
|
// Use parent's scope for assigned value so it can "escape"
|
|
comp->scope_cur = comp->scope_cur->parent;
|
|
}
|
|
compile_store_id(comp, MP_PARSE_NODE_LEAF_ARG(pn_name));
|
|
comp->scope_cur = old_scope;
|
|
}
|
|
|
|
STATIC void compile_namedexpr(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_namedexpr_helper(comp, pns->nodes[0], pns->nodes[1]);
|
|
}
|
|
#endif
|
|
|
|
STATIC void compile_or_and_test(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
bool cond = MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test;
|
|
uint l_end = comp_next_label(comp);
|
|
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
for (int i = 0; i < n; i += 1) {
|
|
compile_node(comp, pns->nodes[i]);
|
|
if (i + 1 < n) {
|
|
EMIT_ARG(jump_if_or_pop, cond, l_end);
|
|
}
|
|
}
|
|
EMIT_ARG(label_assign, l_end);
|
|
}
|
|
|
|
STATIC void compile_not_test_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT_ARG(unary_op, MP_UNARY_OP_NOT);
|
|
}
|
|
|
|
STATIC void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
compile_node(comp, pns->nodes[0]);
|
|
bool multi = (num_nodes > 3);
|
|
uint l_fail = 0;
|
|
if (multi) {
|
|
l_fail = comp_next_label(comp);
|
|
}
|
|
for (int i = 1; i + 1 < num_nodes; i += 2) {
|
|
compile_node(comp, pns->nodes[i + 1]);
|
|
if (i + 2 < num_nodes) {
|
|
EMIT(dup_top);
|
|
EMIT(rot_three);
|
|
}
|
|
if (MP_PARSE_NODE_IS_TOKEN(pns->nodes[i])) {
|
|
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]);
|
|
mp_binary_op_t op;
|
|
if (tok == MP_TOKEN_KW_IN) {
|
|
op = MP_BINARY_OP_IN;
|
|
} else {
|
|
op = MP_BINARY_OP_LESS + (tok - MP_TOKEN_OP_LESS);
|
|
}
|
|
EMIT_ARG(binary_op, op);
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])); // should be
|
|
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[i];
|
|
int kind = MP_PARSE_NODE_STRUCT_KIND(pns2);
|
|
if (kind == PN_comp_op_not_in) {
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_NOT_IN);
|
|
} else {
|
|
assert(kind == PN_comp_op_is); // should be
|
|
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_IS);
|
|
} else {
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_IS_NOT);
|
|
}
|
|
}
|
|
}
|
|
if (i + 2 < num_nodes) {
|
|
EMIT_ARG(jump_if_or_pop, false, l_fail);
|
|
}
|
|
}
|
|
if (multi) {
|
|
uint l_end = comp_next_label(comp);
|
|
EMIT_ARG(jump, l_end);
|
|
EMIT_ARG(label_assign, l_fail);
|
|
EMIT_ARG(adjust_stack_size, 1);
|
|
EMIT(rot_two);
|
|
EMIT(pop_top);
|
|
EMIT_ARG(label_assign, l_end);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_star_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("*x must be assignment target"));
|
|
}
|
|
|
|
STATIC void compile_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
MP_STATIC_ASSERT(MP_BINARY_OP_OR + PN_xor_expr - PN_expr == MP_BINARY_OP_XOR);
|
|
MP_STATIC_ASSERT(MP_BINARY_OP_OR + PN_and_expr - PN_expr == MP_BINARY_OP_AND);
|
|
mp_binary_op_t binary_op = MP_BINARY_OP_OR + MP_PARSE_NODE_STRUCT_KIND(pns) - PN_expr;
|
|
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
compile_node(comp, pns->nodes[0]);
|
|
for (int i = 1; i < num_nodes; ++i) {
|
|
compile_node(comp, pns->nodes[i]);
|
|
EMIT_ARG(binary_op, binary_op);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_term(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
compile_node(comp, pns->nodes[0]);
|
|
for (int i = 1; i + 1 < num_nodes; i += 2) {
|
|
compile_node(comp, pns->nodes[i + 1]);
|
|
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]);
|
|
mp_binary_op_t op = MP_BINARY_OP_LSHIFT + (tok - MP_TOKEN_OP_DBL_LESS);
|
|
EMIT_ARG(binary_op, op);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_factor_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_node(comp, pns->nodes[1]);
|
|
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
|
|
mp_unary_op_t op;
|
|
if (tok == MP_TOKEN_OP_TILDE) {
|
|
op = MP_UNARY_OP_INVERT;
|
|
} else {
|
|
assert(tok == MP_TOKEN_OP_PLUS || tok == MP_TOKEN_OP_MINUS);
|
|
op = MP_UNARY_OP_POSITIVE + (tok - MP_TOKEN_OP_PLUS);
|
|
}
|
|
EMIT_ARG(unary_op, op);
|
|
}
|
|
|
|
STATIC void compile_atom_expr_normal(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// compile the subject of the expression
|
|
compile_node(comp, pns->nodes[0]);
|
|
|
|
// compile_atom_expr_await may call us with a NULL node
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
|
|
return;
|
|
}
|
|
|
|
// get the array of trailers (known to be an array of PARSE_NODE_STRUCT)
|
|
size_t num_trail = 1;
|
|
mp_parse_node_struct_t **pns_trail = (mp_parse_node_struct_t **)&pns->nodes[1];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns_trail[0]) == PN_atom_expr_trailers) {
|
|
num_trail = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_trail[0]);
|
|
pns_trail = (mp_parse_node_struct_t **)&pns_trail[0]->nodes[0];
|
|
}
|
|
|
|
// the current index into the array of trailers
|
|
size_t i = 0;
|
|
|
|
// handle special super() call
|
|
if (comp->scope_cur->kind == SCOPE_FUNCTION
|
|
&& MP_PARSE_NODE_IS_ID(pns->nodes[0])
|
|
&& MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]) == MP_QSTR_super
|
|
&& MP_PARSE_NODE_STRUCT_KIND(pns_trail[0]) == PN_trailer_paren
|
|
&& MP_PARSE_NODE_IS_NULL(pns_trail[0]->nodes[0])) {
|
|
// at this point we have matched "super()" within a function
|
|
|
|
// load the class for super to search for a parent
|
|
compile_load_id(comp, MP_QSTR___class__);
|
|
|
|
// look for first argument to function (assumes it's "self")
|
|
bool found = false;
|
|
id_info_t *id = &comp->scope_cur->id_info[0];
|
|
for (size_t n = comp->scope_cur->id_info_len; n > 0; --n, ++id) {
|
|
if (id->flags & ID_FLAG_IS_PARAM) {
|
|
// first argument found; load it
|
|
compile_load_id(comp, id->qst);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns_trail[0],
|
|
MP_ERROR_TEXT("super() can't find self")); // really a TypeError
|
|
return;
|
|
}
|
|
|
|
if (num_trail >= 3
|
|
&& MP_PARSE_NODE_STRUCT_KIND(pns_trail[1]) == PN_trailer_period
|
|
&& MP_PARSE_NODE_STRUCT_KIND(pns_trail[2]) == PN_trailer_paren) {
|
|
// optimisation for method calls super().f(...), to eliminate heap allocation
|
|
mp_parse_node_struct_t *pns_period = pns_trail[1];
|
|
mp_parse_node_struct_t *pns_paren = pns_trail[2];
|
|
EMIT_ARG(load_method, MP_PARSE_NODE_LEAF_ARG(pns_period->nodes[0]), true);
|
|
compile_trailer_paren_helper(comp, pns_paren->nodes[0], true, 0);
|
|
i = 3;
|
|
} else {
|
|
// a super() call
|
|
EMIT_ARG(call_function, 2, 0, 0);
|
|
i = 1;
|
|
}
|
|
|
|
#if MICROPY_COMP_CONST_LITERAL && MICROPY_PY_COLLECTIONS_ORDEREDDICT
|
|
// handle special OrderedDict constructor
|
|
} else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])
|
|
&& MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]) == MP_QSTR_OrderedDict
|
|
&& MP_PARSE_NODE_STRUCT_KIND(pns_trail[0]) == PN_trailer_paren
|
|
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns_trail[0]->nodes[0], PN_atom_brace)) {
|
|
// at this point we have matched "OrderedDict({...})"
|
|
|
|
EMIT_ARG(call_function, 0, 0, 0);
|
|
mp_parse_node_struct_t *pns_dict = (mp_parse_node_struct_t *)pns_trail[0]->nodes[0];
|
|
compile_atom_brace_helper(comp, pns_dict, false);
|
|
i = 1;
|
|
#endif
|
|
}
|
|
|
|
// compile the remaining trailers
|
|
for (; i < num_trail; i++) {
|
|
if (i + 1 < num_trail
|
|
&& MP_PARSE_NODE_STRUCT_KIND(pns_trail[i]) == PN_trailer_period
|
|
&& MP_PARSE_NODE_STRUCT_KIND(pns_trail[i + 1]) == PN_trailer_paren) {
|
|
// optimisation for method calls a.f(...), following PyPy
|
|
mp_parse_node_struct_t *pns_period = pns_trail[i];
|
|
mp_parse_node_struct_t *pns_paren = pns_trail[i + 1];
|
|
EMIT_ARG(load_method, MP_PARSE_NODE_LEAF_ARG(pns_period->nodes[0]), false);
|
|
compile_trailer_paren_helper(comp, pns_paren->nodes[0], true, 0);
|
|
i += 1;
|
|
} else {
|
|
// node is one of: trailer_paren, trailer_bracket, trailer_period
|
|
compile_node(comp, (mp_parse_node_t)pns_trail[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC void compile_power(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_generic_all_nodes(comp, pns); // 2 nodes, arguments of power
|
|
EMIT_ARG(binary_op, MP_BINARY_OP_POWER);
|
|
}
|
|
|
|
STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_arglist, bool is_method_call, int n_positional_extra) {
|
|
// function to call is on top of stack
|
|
|
|
// get the list of arguments
|
|
mp_parse_node_t *args;
|
|
size_t n_args = mp_parse_node_extract_list(&pn_arglist, PN_arglist, &args);
|
|
|
|
// compile the arguments
|
|
// Rather than calling compile_node on the list, we go through the list of args
|
|
// explicitly here so that we can count the number of arguments and give sensible
|
|
// error messages.
|
|
int n_positional = n_positional_extra;
|
|
uint n_keyword = 0;
|
|
uint star_flags = 0;
|
|
mp_parse_node_struct_t *star_args_node = NULL, *dblstar_args_node = NULL;
|
|
for (size_t i = 0; i < n_args; i++) {
|
|
if (MP_PARSE_NODE_IS_STRUCT(args[i])) {
|
|
mp_parse_node_struct_t *pns_arg = (mp_parse_node_struct_t *)args[i];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_star) {
|
|
if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("can't have multiple *x"));
|
|
return;
|
|
}
|
|
star_flags |= MP_EMIT_STAR_FLAG_SINGLE;
|
|
star_args_node = pns_arg;
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_dbl_star) {
|
|
if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("can't have multiple **x"));
|
|
return;
|
|
}
|
|
star_flags |= MP_EMIT_STAR_FLAG_DOUBLE;
|
|
dblstar_args_node = pns_arg;
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_argument) {
|
|
#if MICROPY_PY_ASSIGN_EXPR
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(pns_arg->nodes[1], PN_argument_3)) {
|
|
compile_namedexpr_helper(comp, pns_arg->nodes[0], ((mp_parse_node_struct_t *)pns_arg->nodes[1])->nodes[0]);
|
|
n_positional++;
|
|
} else
|
|
#endif
|
|
if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns_arg->nodes[1], PN_comp_for)) {
|
|
if (!MP_PARSE_NODE_IS_ID(pns_arg->nodes[0])) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("LHS of keyword arg must be an id"));
|
|
return;
|
|
}
|
|
EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns_arg->nodes[0]));
|
|
compile_node(comp, pns_arg->nodes[1]);
|
|
n_keyword += 1;
|
|
} else {
|
|
compile_comprehension(comp, pns_arg, SCOPE_GEN_EXPR);
|
|
n_positional++;
|
|
}
|
|
} else {
|
|
goto normal_argument;
|
|
}
|
|
} else {
|
|
normal_argument:
|
|
if (star_flags) {
|
|
compile_syntax_error(comp, args[i], MP_ERROR_TEXT("non-keyword arg after */**"));
|
|
return;
|
|
}
|
|
if (n_keyword > 0) {
|
|
compile_syntax_error(comp, args[i], MP_ERROR_TEXT("non-keyword arg after keyword arg"));
|
|
return;
|
|
}
|
|
compile_node(comp, args[i]);
|
|
n_positional++;
|
|
}
|
|
}
|
|
|
|
// compile the star/double-star arguments if we had them
|
|
// if we had one but not the other then we load "null" as a place holder
|
|
if (star_flags != 0) {
|
|
if (star_args_node == NULL) {
|
|
EMIT(load_null);
|
|
} else {
|
|
compile_node(comp, star_args_node->nodes[0]);
|
|
}
|
|
if (dblstar_args_node == NULL) {
|
|
EMIT(load_null);
|
|
} else {
|
|
compile_node(comp, dblstar_args_node->nodes[0]);
|
|
}
|
|
}
|
|
|
|
// emit the function/method call
|
|
if (is_method_call) {
|
|
EMIT_ARG(call_method, n_positional, n_keyword, star_flags);
|
|
} else {
|
|
EMIT_ARG(call_function, n_positional, n_keyword, star_flags);
|
|
}
|
|
}
|
|
|
|
// pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node
|
|
STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind) {
|
|
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
|
|
mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
// create a new scope for this comprehension
|
|
scope_t *s = scope_new_and_link(comp, kind, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
|
|
// store the comprehension scope so the compiling function (this one) can use it at each pass
|
|
pns_comp_for->nodes[3] = (mp_parse_node_t)s;
|
|
}
|
|
|
|
// get the scope for this comprehension
|
|
scope_t *this_scope = (scope_t *)pns_comp_for->nodes[3];
|
|
|
|
// compile the comprehension
|
|
close_over_variables_etc(comp, this_scope, 0, 0);
|
|
|
|
compile_node(comp, pns_comp_for->nodes[1]); // source of the iterator
|
|
if (kind == SCOPE_GEN_EXPR) {
|
|
EMIT_ARG(get_iter, false);
|
|
}
|
|
EMIT_ARG(call_function, 1, 0, 0);
|
|
}
|
|
|
|
STATIC void compile_atom_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// an empty tuple
|
|
EMIT_ARG(build, 0, MP_EMIT_BUILD_TUPLE);
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
if (MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns)) {
|
|
// generator expression
|
|
compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
|
|
} else {
|
|
// tuple with N items
|
|
compile_generic_tuple(comp, pns);
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC void compile_atom_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// empty list
|
|
EMIT_ARG(build, 0, MP_EMIT_BUILD_LIST);
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
|
|
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
if (MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns2)) {
|
|
// list comprehension
|
|
compile_comprehension(comp, pns2, SCOPE_LIST_COMP);
|
|
} else {
|
|
// list with N items
|
|
compile_generic_all_nodes(comp, pns2);
|
|
EMIT_ARG(build, MP_PARSE_NODE_STRUCT_NUM_NODES(pns2), MP_EMIT_BUILD_LIST);
|
|
}
|
|
} else {
|
|
// list with 1 item
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT_ARG(build, 1, MP_EMIT_BUILD_LIST);
|
|
}
|
|
}
|
|
|
|
STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *pns, bool create_map) {
|
|
mp_parse_node_t pn = pns->nodes[0];
|
|
if (MP_PARSE_NODE_IS_NULL(pn)) {
|
|
// empty dict
|
|
if (create_map) {
|
|
EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);
|
|
}
|
|
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
|
|
pns = (mp_parse_node_struct_t *)pn;
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
|
|
// dict with one element
|
|
if (create_map) {
|
|
EMIT_ARG(build, 1, MP_EMIT_BUILD_MAP);
|
|
}
|
|
compile_node(comp, pn);
|
|
EMIT(store_map);
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
|
|
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
|
|
// dict/set with multiple elements
|
|
|
|
// get tail elements (2nd, 3rd, ...)
|
|
mp_parse_node_t *nodes;
|
|
size_t n = mp_parse_node_extract_list(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
|
|
|
|
// first element sets whether it's a dict or set
|
|
bool is_dict;
|
|
if (!MICROPY_PY_BUILTINS_SET || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
|
|
// a dictionary
|
|
if (create_map) {
|
|
EMIT_ARG(build, 1 + n, MP_EMIT_BUILD_MAP);
|
|
}
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT(store_map);
|
|
is_dict = true;
|
|
} else {
|
|
// a set
|
|
compile_node(comp, pns->nodes[0]); // 1st value of set
|
|
is_dict = false;
|
|
}
|
|
|
|
// process rest of elements
|
|
for (size_t i = 0; i < n; i++) {
|
|
mp_parse_node_t pn_i = nodes[i];
|
|
bool is_key_value = MP_PARSE_NODE_IS_STRUCT_KIND(pn_i, PN_dictorsetmaker_item);
|
|
compile_node(comp, pn_i);
|
|
if (is_dict) {
|
|
if (!is_key_value) {
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("invalid syntax"));
|
|
#else
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("expecting key:value for dict"));
|
|
#endif
|
|
return;
|
|
}
|
|
EMIT(store_map);
|
|
} else {
|
|
if (is_key_value) {
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("invalid syntax"));
|
|
#else
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("expecting just a value for set"));
|
|
#endif
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if MICROPY_PY_BUILTINS_SET
|
|
// if it's a set, build it
|
|
if (!is_dict) {
|
|
EMIT_ARG(build, 1 + n, MP_EMIT_BUILD_SET);
|
|
}
|
|
#endif
|
|
} else {
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for); // should be
|
|
// dict/set comprehension
|
|
if (!MICROPY_PY_BUILTINS_SET || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
|
|
// a dictionary comprehension
|
|
compile_comprehension(comp, pns, SCOPE_DICT_COMP);
|
|
} else {
|
|
// a set comprehension
|
|
compile_comprehension(comp, pns, SCOPE_SET_COMP);
|
|
}
|
|
}
|
|
} else {
|
|
// set with one element
|
|
goto set_with_one_element;
|
|
}
|
|
} else {
|
|
// set with one element
|
|
set_with_one_element:
|
|
#if MICROPY_PY_BUILTINS_SET
|
|
compile_node(comp, pn);
|
|
EMIT_ARG(build, 1, MP_EMIT_BUILD_SET);
|
|
#else
|
|
assert(0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
STATIC void compile_atom_brace(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_atom_brace_helper(comp, pns, true);
|
|
}
|
|
|
|
STATIC void compile_trailer_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
compile_trailer_paren_helper(comp, pns->nodes[0], false, 0);
|
|
}
|
|
|
|
STATIC void compile_trailer_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// object who's index we want is on top of stack
|
|
compile_node(comp, pns->nodes[0]); // the index
|
|
EMIT_ARG(subscr, MP_EMIT_SUBSCR_LOAD);
|
|
}
|
|
|
|
STATIC void compile_trailer_period(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// object who's attribute we want is on top of stack
|
|
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]), MP_EMIT_ATTR_LOAD); // attribute to get
|
|
}
|
|
|
|
#if MICROPY_PY_BUILTINS_SLICE
|
|
STATIC void compile_subscript(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_2) {
|
|
compile_node(comp, pns->nodes[0]); // start of slice
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
} else {
|
|
// pns is a PN_subscript_3, load None for start of slice
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
}
|
|
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3); // should always be
|
|
mp_parse_node_t pn = pns->nodes[0];
|
|
if (MP_PARSE_NODE_IS_NULL(pn)) {
|
|
// [?:]
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
|
|
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
|
|
pns = (mp_parse_node_struct_t *)pn;
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
pn = pns->nodes[0];
|
|
if (MP_PARSE_NODE_IS_NULL(pn)) {
|
|
// [?::]
|
|
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
|
|
} else {
|
|
// [?::x]
|
|
compile_node(comp, pn);
|
|
EMIT_ARG(build, 3, MP_EMIT_BUILD_SLICE);
|
|
}
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
|
|
compile_node(comp, pns->nodes[0]);
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// [?:x:]
|
|
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
|
|
} else {
|
|
// [?:x:x]
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT_ARG(build, 3, MP_EMIT_BUILD_SLICE);
|
|
}
|
|
} else {
|
|
// [?:x]
|
|
compile_node(comp, pn);
|
|
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
|
|
}
|
|
} else {
|
|
// [?:x]
|
|
compile_node(comp, pn);
|
|
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
|
|
}
|
|
}
|
|
#endif // MICROPY_PY_BUILTINS_SLICE
|
|
|
|
STATIC void compile_dictorsetmaker_item(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
// if this is called then we are compiling a dict key:value pair
|
|
compile_node(comp, pns->nodes[1]); // value
|
|
compile_node(comp, pns->nodes[0]); // key
|
|
}
|
|
|
|
STATIC void compile_classdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
qstr cname = compile_classdef_helper(comp, pns, comp->scope_cur->emit_options);
|
|
// store class object into class name
|
|
compile_store_id(comp, cname);
|
|
}
|
|
|
|
STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'yield' outside function"));
|
|
return;
|
|
}
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT_ARG(yield, MP_EMIT_YIELD_VALUE);
|
|
reserve_labels_for_native(comp, 1);
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
#if MICROPY_PY_ASYNC_AWAIT
|
|
if ((comp->scope_cur->scope_flags & MP_SCOPE_FLAG_ASYNC) != 0) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'yield from' inside async function"));
|
|
return;
|
|
}
|
|
#endif
|
|
compile_node(comp, pns->nodes[0]);
|
|
compile_yield_from(comp);
|
|
} else {
|
|
compile_node(comp, pns->nodes[0]);
|
|
EMIT_ARG(yield, MP_EMIT_YIELD_VALUE);
|
|
reserve_labels_for_native(comp, 1);
|
|
}
|
|
}
|
|
|
|
#if MICROPY_PY_ASYNC_AWAIT
|
|
STATIC void compile_atom_expr_await(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) {
|
|
compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'await' outside function"));
|
|
return;
|
|
}
|
|
compile_atom_expr_normal(comp, pns);
|
|
|
|
// If it's an awaitable thing, need to reach for the __await__ method for the coroutine.
|
|
// async def functions' __await__ return themselves, which are able to receive a send(),
|
|
// while other types with custom __await__ implementations return async generators.
|
|
EMIT_ARG(load_method, MP_QSTR___await__, false);
|
|
EMIT_ARG(call_method, 0, 0, 0);
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT_ARG(yield, MP_EMIT_YIELD_FROM);
|
|
reserve_labels_for_native(comp, 3);
|
|
}
|
|
#endif
|
|
|
|
STATIC mp_obj_t get_const_object(mp_parse_node_struct_t *pns) {
|
|
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
|
|
// nodes are 32-bit pointers, but need to extract 64-bit object
|
|
return (uint64_t)pns->nodes[0] | ((uint64_t)pns->nodes[1] << 32);
|
|
#else
|
|
return (mp_obj_t)pns->nodes[0];
|
|
#endif
|
|
}
|
|
|
|
STATIC void compile_const_object(compiler_t *comp, mp_parse_node_struct_t *pns) {
|
|
EMIT_ARG(load_const_obj, get_const_object(pns));
|
|
}
|
|
|
|
typedef void (*compile_function_t)(compiler_t *, mp_parse_node_struct_t *);
|
|
STATIC const compile_function_t compile_function[] = {
|
|
// only define rules with a compile function
|
|
#define c(f) compile_##f
|
|
#define DEF_RULE(rule, comp, kind, ...) comp,
|
|
#define DEF_RULE_NC(rule, kind, ...)
|
|
#include "py/grammar.h"
|
|
#undef c
|
|
#undef DEF_RULE
|
|
#undef DEF_RULE_NC
|
|
compile_const_object,
|
|
};
|
|
|
|
STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn) {
|
|
if (MP_PARSE_NODE_IS_NULL(pn)) {
|
|
// pass
|
|
} else if (MP_PARSE_NODE_IS_SMALL_INT(pn)) {
|
|
mp_int_t arg = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
|
|
#if MICROPY_DYNAMIC_COMPILER
|
|
mp_uint_t sign_mask = -((mp_uint_t)1 << (mp_dynamic_compiler.small_int_bits - 1));
|
|
if ((arg & sign_mask) == 0 || (arg & sign_mask) == sign_mask) {
|
|
// integer fits in target runtime's small-int
|
|
EMIT_ARG(load_const_small_int, arg);
|
|
} else {
|
|
// integer doesn't fit, so create a multi-precision int object
|
|
// (but only create the actual object on the last pass)
|
|
if (comp->pass != MP_PASS_EMIT) {
|
|
EMIT_ARG(load_const_obj, mp_const_none);
|
|
} else {
|
|
EMIT_ARG(load_const_obj, mp_obj_new_int_from_ll(arg));
|
|
}
|
|
}
|
|
#else
|
|
EMIT_ARG(load_const_small_int, arg);
|
|
#endif
|
|
} else if (MP_PARSE_NODE_IS_LEAF(pn)) {
|
|
uintptr_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
|
|
switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
|
|
case MP_PARSE_NODE_ID:
|
|
compile_load_id(comp, arg);
|
|
break;
|
|
case MP_PARSE_NODE_STRING:
|
|
EMIT_ARG(load_const_str, arg);
|
|
break;
|
|
case MP_PARSE_NODE_BYTES:
|
|
// only create and load the actual bytes object on the last pass
|
|
if (comp->pass != MP_PASS_EMIT) {
|
|
EMIT_ARG(load_const_obj, mp_const_none);
|
|
} else {
|
|
size_t len;
|
|
const byte *data = qstr_data(arg, &len);
|
|
EMIT_ARG(load_const_obj, mp_obj_new_bytes(data, len));
|
|
}
|
|
break;
|
|
case MP_PARSE_NODE_TOKEN:
|
|
default:
|
|
if (arg == MP_TOKEN_NEWLINE) {
|
|
// this can occur when file_input lets through a NEWLINE (eg if file starts with a newline)
|
|
// or when single_input lets through a NEWLINE (user enters a blank line)
|
|
// do nothing
|
|
} else {
|
|
EMIT_ARG(load_const_tok, arg);
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
EMIT_ARG(set_source_line, pns->source_line);
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns) <= PN_const_object);
|
|
compile_function_t f = compile_function[MP_PARSE_NODE_STRUCT_KIND(pns)];
|
|
f(comp, pns);
|
|
}
|
|
}
|
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
STATIC int compile_viper_type_annotation(compiler_t *comp, mp_parse_node_t pn_annotation) {
|
|
int native_type = MP_NATIVE_TYPE_OBJ;
|
|
if (MP_PARSE_NODE_IS_NULL(pn_annotation)) {
|
|
// No annotation, type defaults to object
|
|
} else if (MP_PARSE_NODE_IS_ID(pn_annotation)) {
|
|
qstr type_name = MP_PARSE_NODE_LEAF_ARG(pn_annotation);
|
|
native_type = mp_native_type_from_qstr(type_name);
|
|
if (native_type < 0) {
|
|
comp->compile_error = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, MP_ERROR_TEXT("unknown type '%q'"), type_name);
|
|
native_type = 0;
|
|
}
|
|
} else {
|
|
compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("annotation must be an identifier"));
|
|
}
|
|
return native_type;
|
|
}
|
|
#endif
|
|
|
|
STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn, pn_kind_t pn_name, pn_kind_t pn_star, pn_kind_t pn_dbl_star) {
|
|
(void)pn_dbl_star;
|
|
|
|
// check that **kw is last
|
|
if ((comp->scope_cur->scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) {
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("invalid syntax"));
|
|
return;
|
|
}
|
|
|
|
qstr param_name = MP_QSTRnull;
|
|
uint param_flag = ID_FLAG_IS_PARAM;
|
|
mp_parse_node_struct_t *pns = NULL;
|
|
if (MP_PARSE_NODE_IS_ID(pn)) {
|
|
param_name = MP_PARSE_NODE_LEAF_ARG(pn);
|
|
if (comp->have_star) {
|
|
// comes after a star, so counts as a keyword-only parameter
|
|
comp->scope_cur->num_kwonly_args += 1;
|
|
} else {
|
|
// comes before a star, so counts as a positional parameter
|
|
comp->scope_cur->num_pos_args += 1;
|
|
}
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pn));
|
|
pns = (mp_parse_node_struct_t *)pn;
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
|
|
// named parameter with possible annotation
|
|
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
|
|
if (comp->have_star) {
|
|
// comes after a star, so counts as a keyword-only parameter
|
|
comp->scope_cur->num_kwonly_args += 1;
|
|
} else {
|
|
// comes before a star, so counts as a positional parameter
|
|
comp->scope_cur->num_pos_args += 1;
|
|
}
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
|
|
if (comp->have_star) {
|
|
// more than one star
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("invalid syntax"));
|
|
return;
|
|
}
|
|
comp->have_star = true;
|
|
param_flag = ID_FLAG_IS_PARAM | ID_FLAG_IS_STAR_PARAM;
|
|
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
|
|
// bare star
|
|
// TODO see http://www.python.org/dev/peps/pep-3102/
|
|
// assert(comp->scope_cur->num_dict_params == 0);
|
|
pns = NULL;
|
|
} else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
|
|
// named star
|
|
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARARGS;
|
|
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
|
|
pns = NULL;
|
|
} else {
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)); // should be
|
|
// named star with possible annotation
|
|
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARARGS;
|
|
pns = (mp_parse_node_struct_t *)pns->nodes[0];
|
|
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
|
|
}
|
|
} else {
|
|
// double star with possible annotation
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == pn_dbl_star); // should be
|
|
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
|
|
param_flag = ID_FLAG_IS_PARAM | ID_FLAG_IS_DBL_STAR_PARAM;
|
|
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARKEYWORDS;
|
|
}
|
|
}
|
|
|
|
if (param_name != MP_QSTRnull) {
|
|
id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, param_name, ID_INFO_KIND_UNDECIDED);
|
|
if (id_info->kind != ID_INFO_KIND_UNDECIDED) {
|
|
compile_syntax_error(comp, pn, MP_ERROR_TEXT("argument name reused"));
|
|
return;
|
|
}
|
|
id_info->kind = ID_INFO_KIND_LOCAL;
|
|
id_info->flags = param_flag;
|
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
if (comp->scope_cur->emit_options == MP_EMIT_OPT_VIPER && pn_name == PN_typedargslist_name && pns != NULL) {
|
|
id_info->flags |= compile_viper_type_annotation(comp, pns->nodes[1]) << ID_FLAG_VIPER_TYPE_POS;
|
|
}
|
|
#else
|
|
(void)pns;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
STATIC void compile_scope_func_param(compiler_t *comp, mp_parse_node_t pn) {
|
|
compile_scope_func_lambda_param(comp, pn, PN_typedargslist_name, PN_typedargslist_star, PN_typedargslist_dbl_star);
|
|
}
|
|
|
|
STATIC void compile_scope_lambda_param(compiler_t *comp, mp_parse_node_t pn) {
|
|
compile_scope_func_lambda_param(comp, pn, PN_varargslist_name, PN_varargslist_star, PN_varargslist_dbl_star);
|
|
}
|
|
|
|
STATIC void compile_scope_comp_iter(compiler_t *comp, mp_parse_node_struct_t *pns_comp_for, mp_parse_node_t pn_inner_expr, int for_depth) {
|
|
uint l_top = comp_next_label(comp);
|
|
uint l_end = comp_next_label(comp);
|
|
EMIT_ARG(label_assign, l_top);
|
|
EMIT_ARG(for_iter, l_end);
|
|
c_assign(comp, pns_comp_for->nodes[0], ASSIGN_STORE);
|
|
mp_parse_node_t pn_iter = pns_comp_for->nodes[2];
|
|
|
|
tail_recursion:
|
|
if (MP_PARSE_NODE_IS_NULL(pn_iter)) {
|
|
// no more nested if/for; compile inner expression
|
|
compile_node(comp, pn_inner_expr);
|
|
if (comp->scope_cur->kind == SCOPE_GEN_EXPR) {
|
|
EMIT_ARG(yield, MP_EMIT_YIELD_VALUE);
|
|
reserve_labels_for_native(comp, 1);
|
|
EMIT(pop_top);
|
|
} else {
|
|
EMIT_ARG(store_comp, comp->scope_cur->kind, 4 * for_depth + 5);
|
|
}
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_iter) == PN_comp_if) {
|
|
// if condition
|
|
mp_parse_node_struct_t *pns_comp_if = (mp_parse_node_struct_t *)pn_iter;
|
|
c_if_cond(comp, pns_comp_if->nodes[0], false, l_top);
|
|
pn_iter = pns_comp_if->nodes[1];
|
|
goto tail_recursion;
|
|
} else {
|
|
assert(MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_iter) == PN_comp_for); // should be
|
|
// for loop
|
|
mp_parse_node_struct_t *pns_comp_for2 = (mp_parse_node_struct_t *)pn_iter;
|
|
compile_node(comp, pns_comp_for2->nodes[1]);
|
|
EMIT_ARG(get_iter, true);
|
|
compile_scope_comp_iter(comp, pns_comp_for2, pn_inner_expr, for_depth + 1);
|
|
}
|
|
|
|
EMIT_ARG(jump, l_top);
|
|
EMIT_ARG(label_assign, l_end);
|
|
EMIT(for_iter_end);
|
|
}
|
|
|
|
STATIC void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
|
|
#if MICROPY_ENABLE_DOC_STRING
|
|
// see http://www.python.org/dev/peps/pep-0257/
|
|
|
|
// look for the first statement
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
|
|
// a statement; fall through
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
|
|
// file input; find the first non-newline node
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
|
|
for (int i = 0; i < num_nodes; i++) {
|
|
pn = pns->nodes[i];
|
|
if (!(MP_PARSE_NODE_IS_LEAF(pn) && MP_PARSE_NODE_LEAF_KIND(pn) == MP_PARSE_NODE_TOKEN && MP_PARSE_NODE_LEAF_ARG(pn) == MP_TOKEN_NEWLINE)) {
|
|
// not a newline, so this is the first statement; finish search
|
|
break;
|
|
}
|
|
}
|
|
// if we didn't find a non-newline then it's okay to fall through; pn will be a newline and so doc-string test below will fail gracefully
|
|
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
|
|
// a list of statements; get the first one
|
|
pn = ((mp_parse_node_struct_t *)pn)->nodes[0];
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
// check the first statement for a doc string
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
|
|
if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0])
|
|
&& MP_PARSE_NODE_LEAF_KIND(pns->nodes[0]) == MP_PARSE_NODE_STRING)
|
|
|| (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)
|
|
&& mp_obj_is_str(get_const_object((mp_parse_node_struct_t *)pns->nodes[0])))) {
|
|
// compile the doc string
|
|
compile_node(comp, pns->nodes[0]);
|
|
// store the doc string
|
|
compile_store_id(comp, MP_QSTR___doc__);
|
|
}
|
|
}
|
|
#else
|
|
(void)comp;
|
|
(void)pn;
|
|
#endif
|
|
}
|
|
|
|
STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
|
|
comp->pass = pass;
|
|
comp->scope_cur = scope;
|
|
comp->next_label = 0;
|
|
EMIT_ARG(start_pass, pass, scope);
|
|
reserve_labels_for_native(comp, 6); // used by native's start_pass
|
|
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
// reset maximum stack sizes in scope
|
|
// they will be computed in this first pass
|
|
scope->stack_size = 0;
|
|
scope->exc_stack_size = 0;
|
|
}
|
|
|
|
// compile
|
|
if (MP_PARSE_NODE_IS_STRUCT_KIND(scope->pn, PN_eval_input)) {
|
|
assert(scope->kind == SCOPE_MODULE);
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
|
|
compile_node(comp, pns->nodes[0]); // compile the expression
|
|
EMIT(return_value);
|
|
} else if (scope->kind == SCOPE_MODULE) {
|
|
if (!comp->is_repl) {
|
|
check_for_doc_string(comp, scope->pn);
|
|
}
|
|
compile_node(comp, scope->pn);
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT(return_value);
|
|
} else if (scope->kind == SCOPE_FUNCTION) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
|
|
|
|
// work out number of parameters, keywords and default parameters, and add them to the id_info array
|
|
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
comp->have_star = false;
|
|
apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_scope_func_param);
|
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
if (scope->emit_options == MP_EMIT_OPT_VIPER) {
|
|
// Compile return type; pns->nodes[2] is return/whole function annotation
|
|
scope->scope_flags |= compile_viper_type_annotation(comp, pns->nodes[2]) << MP_SCOPE_FLAG_VIPERRET_POS;
|
|
}
|
|
#endif // MICROPY_EMIT_NATIVE
|
|
}
|
|
|
|
compile_node(comp, pns->nodes[3]); // 3 is function body
|
|
// emit return if it wasn't the last opcode
|
|
if (!EMIT(last_emit_was_return_value)) {
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
EMIT(return_value);
|
|
}
|
|
} else if (scope->kind == SCOPE_LAMBDA) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
|
|
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
|
|
|
|
// Set the source line number for the start of the lambda
|
|
EMIT_ARG(set_source_line, pns->source_line);
|
|
|
|
// work out number of parameters, keywords and default parameters, and add them to the id_info array
|
|
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
comp->have_star = false;
|
|
apply_to_single_or_list(comp, pns->nodes[0], PN_varargslist, compile_scope_lambda_param);
|
|
}
|
|
|
|
compile_node(comp, pns->nodes[1]); // 1 is lambda body
|
|
|
|
// if the lambda is a generator, then we return None, not the result of the expression of the lambda
|
|
if (scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {
|
|
EMIT(pop_top);
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
}
|
|
EMIT(return_value);
|
|
} else if (SCOPE_IS_COMP_LIKE(scope->kind)) {
|
|
// a bit of a hack at the moment
|
|
|
|
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
|
|
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
|
|
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
|
|
mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t *)pns->nodes[1];
|
|
|
|
// We need a unique name for the comprehension argument (the iterator).
|
|
// CPython uses .0, but we should be able to use anything that won't
|
|
// clash with a user defined variable. Best to use an existing qstr,
|
|
// so we use the blank qstr.
|
|
qstr qstr_arg = MP_QSTR_;
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
scope_find_or_add_id(comp->scope_cur, qstr_arg, ID_INFO_KIND_LOCAL);
|
|
scope->num_pos_args = 1;
|
|
}
|
|
|
|
// Set the source line number for the start of the comprehension
|
|
EMIT_ARG(set_source_line, pns->source_line);
|
|
|
|
if (scope->kind == SCOPE_LIST_COMP) {
|
|
EMIT_ARG(build, 0, MP_EMIT_BUILD_LIST);
|
|
} else if (scope->kind == SCOPE_DICT_COMP) {
|
|
EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);
|
|
#if MICROPY_PY_BUILTINS_SET
|
|
} else if (scope->kind == SCOPE_SET_COMP) {
|
|
EMIT_ARG(build, 0, MP_EMIT_BUILD_SET);
|
|
#endif
|
|
}
|
|
|
|
// There are 4 slots on the stack for the iterator, and the first one is
|
|
// NULL to indicate that the second one points to the iterator object.
|
|
if (scope->kind == SCOPE_GEN_EXPR) {
|
|
MP_STATIC_ASSERT(MP_OBJ_ITER_BUF_NSLOTS == 4);
|
|
EMIT(load_null);
|
|
compile_load_id(comp, qstr_arg);
|
|
EMIT(load_null);
|
|
EMIT(load_null);
|
|
} else {
|
|
compile_load_id(comp, qstr_arg);
|
|
EMIT_ARG(get_iter, true);
|
|
}
|
|
|
|
compile_scope_comp_iter(comp, pns_comp_for, pns->nodes[0], 0);
|
|
|
|
if (scope->kind == SCOPE_GEN_EXPR) {
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
}
|
|
EMIT(return_value);
|
|
} else {
|
|
assert(scope->kind == SCOPE_CLASS);
|
|
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
|
|
|
|
if (comp->pass == MP_PASS_SCOPE) {
|
|
scope_find_or_add_id(scope, MP_QSTR___class__, ID_INFO_KIND_LOCAL);
|
|
}
|
|
|
|
#if MICROPY_PY_SYS_SETTRACE
|
|
EMIT_ARG(set_source_line, pns->source_line);
|
|
#endif
|
|
compile_load_id(comp, MP_QSTR___name__);
|
|
compile_store_id(comp, MP_QSTR___module__);
|
|
EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
|
|
compile_store_id(comp, MP_QSTR___qualname__);
|
|
|
|
check_for_doc_string(comp, pns->nodes[2]);
|
|
compile_node(comp, pns->nodes[2]); // 2 is class body
|
|
|
|
id_info_t *id = scope_find(scope, MP_QSTR___class__);
|
|
assert(id != NULL);
|
|
if (id->kind == ID_INFO_KIND_LOCAL) {
|
|
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
|
|
} else {
|
|
EMIT_LOAD_FAST(MP_QSTR___class__, id->local_num);
|
|
}
|
|
EMIT(return_value);
|
|
}
|
|
|
|
EMIT(end_pass);
|
|
|
|
// make sure we match all the exception levels
|
|
assert(comp->cur_except_level == 0);
|
|
}
|
|
|
|
#if MICROPY_EMIT_INLINE_ASM
|
|
// requires 3 passes: SCOPE, CODE_SIZE, EMIT
|
|
STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
|
|
comp->pass = pass;
|
|
comp->scope_cur = scope;
|
|
comp->next_label = 0;
|
|
|
|
if (scope->kind != SCOPE_FUNCTION) {
|
|
compile_syntax_error(comp, MP_PARSE_NODE_NULL, MP_ERROR_TEXT("inline assembler must be a function"));
|
|
return;
|
|
}
|
|
|
|
if (comp->pass > MP_PASS_SCOPE) {
|
|
EMIT_INLINE_ASM_ARG(start_pass, comp->pass, &comp->compile_error);
|
|
}
|
|
|
|
// get the function definition parse node
|
|
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
|
|
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
|
|
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
|
|
|
|
// qstr f_id = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
|
|
|
|
// parameters are in pns->nodes[1]
|
|
if (comp->pass == MP_PASS_CODE_SIZE) {
|
|
mp_parse_node_t *pn_params;
|
|
size_t n_params = mp_parse_node_extract_list(&pns->nodes[1], PN_typedargslist, &pn_params);
|
|
scope->num_pos_args = EMIT_INLINE_ASM_ARG(count_params, n_params, pn_params);
|
|
if (comp->compile_error != MP_OBJ_NULL) {
|
|
goto inline_asm_error;
|
|
}
|
|
}
|
|
|
|
// pns->nodes[2] is function return annotation
|
|
mp_uint_t type_sig = MP_NATIVE_TYPE_INT;
|
|
mp_parse_node_t pn_annotation = pns->nodes[2];
|
|
if (!MP_PARSE_NODE_IS_NULL(pn_annotation)) {
|
|
// nodes[2] can be null or a test-expr
|
|
if (MP_PARSE_NODE_IS_ID(pn_annotation)) {
|
|
qstr ret_type = MP_PARSE_NODE_LEAF_ARG(pn_annotation);
|
|
switch (ret_type) {
|
|
case MP_QSTR_object:
|
|
type_sig = MP_NATIVE_TYPE_OBJ;
|
|
break;
|
|
case MP_QSTR_bool:
|
|
type_sig = MP_NATIVE_TYPE_BOOL;
|
|
break;
|
|
case MP_QSTR_int:
|
|
type_sig = MP_NATIVE_TYPE_INT;
|
|
break;
|
|
case MP_QSTR_uint:
|
|
type_sig = MP_NATIVE_TYPE_UINT;
|
|
break;
|
|
default:
|
|
compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("unknown type"));
|
|
return;
|
|
}
|
|
} else {
|
|
compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("return annotation must be an identifier"));
|
|
}
|
|
}
|
|
|
|
mp_parse_node_t pn_body = pns->nodes[3]; // body
|
|
mp_parse_node_t *nodes;
|
|
size_t num = mp_parse_node_extract_list(&pn_body, PN_suite_block_stmts, &nodes);
|
|
|
|
for (size_t i = 0; i < num; i++) {
|
|
assert(MP_PARSE_NODE_IS_STRUCT(nodes[i]));
|
|
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)nodes[i];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_pass_stmt) {
|
|
// no instructions
|
|
continue;
|
|
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_expr_stmt) {
|
|
// not an instruction; error
|
|
not_an_instruction:
|
|
compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("expecting an assembler instruction"));
|
|
return;
|
|
}
|
|
|
|
// check structure of parse node
|
|
assert(MP_PARSE_NODE_IS_STRUCT(pns2->nodes[0]));
|
|
if (!MP_PARSE_NODE_IS_NULL(pns2->nodes[1])) {
|
|
goto not_an_instruction;
|
|
}
|
|
pns2 = (mp_parse_node_struct_t *)pns2->nodes[0];
|
|
if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_atom_expr_normal) {
|
|
goto not_an_instruction;
|
|
}
|
|
if (!MP_PARSE_NODE_IS_ID(pns2->nodes[0])) {
|
|
goto not_an_instruction;
|
|
}
|
|
if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns2->nodes[1], PN_trailer_paren)) {
|
|
goto not_an_instruction;
|
|
}
|
|
|
|
// parse node looks like an instruction
|
|
// get instruction name and args
|
|
qstr op = MP_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
|
|
pns2 = (mp_parse_node_struct_t *)pns2->nodes[1]; // PN_trailer_paren
|
|
mp_parse_node_t *pn_arg;
|
|
size_t n_args = mp_parse_node_extract_list(&pns2->nodes[0], PN_arglist, &pn_arg);
|
|
|
|
// emit instructions
|
|
if (op == MP_QSTR_label) {
|
|
if (!(n_args == 1 && MP_PARSE_NODE_IS_ID(pn_arg[0]))) {
|
|
compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'label' requires 1 argument"));
|
|
return;
|
|
}
|
|
uint lab = comp_next_label(comp);
|
|
if (pass > MP_PASS_SCOPE) {
|
|
if (!EMIT_INLINE_ASM_ARG(label, lab, MP_PARSE_NODE_LEAF_ARG(pn_arg[0]))) {
|
|
compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("label redefined"));
|
|
return;
|
|
}
|
|
}
|
|
} else if (op == MP_QSTR_align) {
|
|
if (!(n_args == 1 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
|
|
compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'align' requires 1 argument"));
|
|
return;
|
|
}
|
|
if (pass > MP_PASS_SCOPE) {
|
|
mp_asm_base_align((mp_asm_base_t *)comp->emit_inline_asm,
|
|
MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]));
|
|
}
|
|
} else if (op == MP_QSTR_data) {
|
|
if (!(n_args >= 2 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
|
|
compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'data' requires at least 2 arguments"));
|
|
return;
|
|
}
|
|
if (pass > MP_PASS_SCOPE) {
|
|
mp_int_t bytesize = MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]);
|
|
for (uint j = 1; j < n_args; j++) {
|
|
if (!MP_PARSE_NODE_IS_SMALL_INT(pn_arg[j])) {
|
|
compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'data' requires integer arguments"));
|
|
return;
|
|
}
|
|
mp_asm_base_data((mp_asm_base_t *)comp->emit_inline_asm,
|
|
bytesize, MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[j]));
|
|
}
|
|
}
|
|
} else {
|
|
if (pass > MP_PASS_SCOPE) {
|
|
EMIT_INLINE_ASM_ARG(op, op, n_args, pn_arg);
|
|
}
|
|
}
|
|
|
|
if (comp->compile_error != MP_OBJ_NULL) {
|
|
pns = pns2; // this is the parse node that had the error
|
|
goto inline_asm_error;
|
|
}
|
|
}
|
|
|
|
if (comp->pass > MP_PASS_SCOPE) {
|
|
EMIT_INLINE_ASM_ARG(end_pass, type_sig);
|
|
|
|
if (comp->pass == MP_PASS_EMIT) {
|
|
void *f = mp_asm_base_get_code((mp_asm_base_t *)comp->emit_inline_asm);
|
|
mp_emit_glue_assign_native(comp->scope_cur->raw_code, MP_CODE_NATIVE_ASM,
|
|
f, mp_asm_base_get_code_size((mp_asm_base_t *)comp->emit_inline_asm),
|
|
NULL,
|
|
#if MICROPY_PERSISTENT_CODE_SAVE
|
|
0, 0, 0, 0, NULL,
|
|
#endif
|
|
comp->scope_cur->num_pos_args, 0, type_sig);
|
|
}
|
|
}
|
|
|
|
if (comp->compile_error != MP_OBJ_NULL) {
|
|
// inline assembler had an error; set line for its exception
|
|
inline_asm_error:
|
|
comp->compile_error_line = pns->source_line;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
STATIC void scope_compute_things(scope_t *scope) {
|
|
// in MicroPython we put the *x parameter after all other parameters (except **y)
|
|
if (scope->scope_flags & MP_SCOPE_FLAG_VARARGS) {
|
|
id_info_t *id_param = NULL;
|
|
for (int i = scope->id_info_len - 1; i >= 0; i--) {
|
|
id_info_t *id = &scope->id_info[i];
|
|
if (id->flags & ID_FLAG_IS_STAR_PARAM) {
|
|
if (id_param != NULL) {
|
|
// swap star param with last param
|
|
id_info_t temp = *id_param;
|
|
*id_param = *id;
|
|
*id = temp;
|
|
}
|
|
break;
|
|
} else if (id_param == NULL && id->flags == ID_FLAG_IS_PARAM) {
|
|
id_param = id;
|
|
}
|
|
}
|
|
}
|
|
|
|
// in functions, turn implicit globals into explicit globals
|
|
// compute the index of each local
|
|
scope->num_locals = 0;
|
|
for (int i = 0; i < scope->id_info_len; i++) {
|
|
id_info_t *id = &scope->id_info[i];
|
|
if (scope->kind == SCOPE_CLASS && id->qst == MP_QSTR___class__) {
|
|
// __class__ is not counted as a local; if it's used then it becomes a ID_INFO_KIND_CELL
|
|
continue;
|
|
}
|
|
if (SCOPE_IS_FUNC_LIKE(scope->kind) && id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
|
|
id->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
|
|
}
|
|
#if MICROPY_EMIT_NATIVE
|
|
if (id->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) {
|
|
// This function makes a reference to a global variable
|
|
if (scope->emit_options == MP_EMIT_OPT_VIPER
|
|
&& mp_native_type_from_qstr(id->qst) >= MP_NATIVE_TYPE_INT) {
|
|
// A casting operator in viper mode, not a real global reference
|
|
} else {
|
|
scope->scope_flags |= MP_SCOPE_FLAG_REFGLOBALS;
|
|
}
|
|
}
|
|
#endif
|
|
// params always count for 1 local, even if they are a cell
|
|
if (id->kind == ID_INFO_KIND_LOCAL || (id->flags & ID_FLAG_IS_PARAM)) {
|
|
id->local_num = scope->num_locals++;
|
|
}
|
|
}
|
|
|
|
// compute the index of cell vars
|
|
for (int i = 0; i < scope->id_info_len; i++) {
|
|
id_info_t *id = &scope->id_info[i];
|
|
// in MicroPython the cells come right after the fast locals
|
|
// parameters are not counted here, since they remain at the start
|
|
// of the locals, even if they are cell vars
|
|
if (id->kind == ID_INFO_KIND_CELL && !(id->flags & ID_FLAG_IS_PARAM)) {
|
|
id->local_num = scope->num_locals;
|
|
scope->num_locals += 1;
|
|
}
|
|
}
|
|
|
|
// compute the index of free vars
|
|
// make sure they are in the order of the parent scope
|
|
if (scope->parent != NULL) {
|
|
int num_free = 0;
|
|
for (int i = 0; i < scope->parent->id_info_len; i++) {
|
|
id_info_t *id = &scope->parent->id_info[i];
|
|
if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
|
|
for (int j = 0; j < scope->id_info_len; j++) {
|
|
id_info_t *id2 = &scope->id_info[j];
|
|
if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {
|
|
assert(!(id2->flags & ID_FLAG_IS_PARAM)); // free vars should not be params
|
|
// in MicroPython the frees come first, before the params
|
|
id2->local_num = num_free;
|
|
num_free += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// in MicroPython shift all other locals after the free locals
|
|
if (num_free > 0) {
|
|
for (int i = 0; i < scope->id_info_len; i++) {
|
|
id_info_t *id = &scope->id_info[i];
|
|
if (id->kind != ID_INFO_KIND_FREE || (id->flags & ID_FLAG_IS_PARAM)) {
|
|
id->local_num += num_free;
|
|
}
|
|
}
|
|
scope->num_pos_args += num_free; // free vars are counted as params for passing them into the function
|
|
scope->num_locals += num_free;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if !MICROPY_PERSISTENT_CODE_SAVE
|
|
STATIC
|
|
#endif
|
|
mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_file, bool is_repl) {
|
|
// put compiler state on the stack, it's relatively small
|
|
compiler_t comp_state = {0};
|
|
compiler_t *comp = &comp_state;
|
|
|
|
comp->source_file = source_file;
|
|
comp->is_repl = is_repl;
|
|
comp->break_label = INVALID_LABEL;
|
|
comp->continue_label = INVALID_LABEL;
|
|
|
|
// create the module scope
|
|
#if MICROPY_EMIT_NATIVE
|
|
const uint emit_opt = MP_STATE_VM(default_emit_opt);
|
|
#else
|
|
const uint emit_opt = MP_EMIT_OPT_NONE;
|
|
#endif
|
|
scope_t *module_scope = scope_new_and_link(comp, SCOPE_MODULE, parse_tree->root, emit_opt);
|
|
|
|
// create standard emitter; it's used at least for MP_PASS_SCOPE
|
|
emit_t *emit_bc = emit_bc_new();
|
|
|
|
// compile pass 1
|
|
comp->emit = emit_bc;
|
|
#if MICROPY_EMIT_NATIVE
|
|
comp->emit_method_table = &emit_bc_method_table;
|
|
#endif
|
|
uint max_num_labels = 0;
|
|
for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
|
|
#if MICROPY_EMIT_INLINE_ASM
|
|
if (s->emit_options == MP_EMIT_OPT_ASM) {
|
|
compile_scope_inline_asm(comp, s, MP_PASS_SCOPE);
|
|
} else
|
|
#endif
|
|
{
|
|
compile_scope(comp, s, MP_PASS_SCOPE);
|
|
|
|
// Check if any implicitly declared variables should be closed over
|
|
for (size_t i = 0; i < s->id_info_len; ++i) {
|
|
id_info_t *id = &s->id_info[i];
|
|
if (id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
|
|
scope_check_to_close_over(s, id);
|
|
}
|
|
}
|
|
}
|
|
|
|
// update maximim number of labels needed
|
|
if (comp->next_label > max_num_labels) {
|
|
max_num_labels = comp->next_label;
|
|
}
|
|
}
|
|
|
|
// compute some things related to scope and identifiers
|
|
for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
|
|
scope_compute_things(s);
|
|
}
|
|
|
|
// set max number of labels now that it's calculated
|
|
emit_bc_set_max_num_labels(emit_bc, max_num_labels);
|
|
|
|
// compile pass 2 and 3
|
|
#if MICROPY_EMIT_NATIVE
|
|
emit_t *emit_native = NULL;
|
|
#endif
|
|
for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
|
|
#if MICROPY_EMIT_INLINE_ASM
|
|
if (s->emit_options == MP_EMIT_OPT_ASM) {
|
|
// inline assembly
|
|
if (comp->emit_inline_asm == NULL) {
|
|
comp->emit_inline_asm = ASM_EMITTER(new)(max_num_labels);
|
|
}
|
|
comp->emit = NULL;
|
|
comp->emit_inline_asm_method_table = ASM_EMITTER_TABLE;
|
|
compile_scope_inline_asm(comp, s, MP_PASS_CODE_SIZE);
|
|
#if MICROPY_EMIT_INLINE_XTENSA
|
|
// Xtensa requires an extra pass to compute size of l32r const table
|
|
// TODO this can be improved by calculating it during SCOPE pass
|
|
// but that requires some other structural changes to the asm emitters
|
|
#if MICROPY_DYNAMIC_COMPILER
|
|
if (mp_dynamic_compiler.native_arch == MP_NATIVE_ARCH_XTENSA)
|
|
#endif
|
|
{
|
|
compile_scope_inline_asm(comp, s, MP_PASS_CODE_SIZE);
|
|
}
|
|
#endif
|
|
if (comp->compile_error == MP_OBJ_NULL) {
|
|
compile_scope_inline_asm(comp, s, MP_PASS_EMIT);
|
|
}
|
|
} else
|
|
#endif
|
|
{
|
|
|
|
// choose the emit type
|
|
|
|
switch (s->emit_options) {
|
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
case MP_EMIT_OPT_NATIVE_PYTHON:
|
|
case MP_EMIT_OPT_VIPER:
|
|
if (emit_native == NULL) {
|
|
emit_native = NATIVE_EMITTER(new)(&comp->compile_error, &comp->next_label, max_num_labels);
|
|
}
|
|
comp->emit_method_table = NATIVE_EMITTER_TABLE;
|
|
comp->emit = emit_native;
|
|
break;
|
|
#endif // MICROPY_EMIT_NATIVE
|
|
|
|
default:
|
|
comp->emit = emit_bc;
|
|
#if MICROPY_EMIT_NATIVE
|
|
comp->emit_method_table = &emit_bc_method_table;
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
// need a pass to compute stack size
|
|
compile_scope(comp, s, MP_PASS_STACK_SIZE);
|
|
|
|
// second last pass: compute code size
|
|
if (comp->compile_error == MP_OBJ_NULL) {
|
|
compile_scope(comp, s, MP_PASS_CODE_SIZE);
|
|
}
|
|
|
|
// final pass: emit code
|
|
if (comp->compile_error == MP_OBJ_NULL) {
|
|
compile_scope(comp, s, MP_PASS_EMIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (comp->compile_error != MP_OBJ_NULL) {
|
|
// if there is no line number for the error then use the line
|
|
// number for the start of this scope
|
|
compile_error_set_line(comp, comp->scope_cur->pn);
|
|
// add a traceback to the exception using relevant source info
|
|
mp_obj_exception_add_traceback(comp->compile_error, comp->source_file,
|
|
comp->compile_error_line, comp->scope_cur->simple_name);
|
|
}
|
|
|
|
// free the emitters
|
|
|
|
emit_bc_free(emit_bc);
|
|
#if MICROPY_EMIT_NATIVE
|
|
if (emit_native != NULL) {
|
|
NATIVE_EMITTER(free)(emit_native);
|
|
}
|
|
#endif
|
|
#if MICROPY_EMIT_INLINE_ASM
|
|
if (comp->emit_inline_asm != NULL) {
|
|
ASM_EMITTER(free)(comp->emit_inline_asm);
|
|
}
|
|
#endif
|
|
|
|
// free the parse tree
|
|
mp_parse_tree_clear(parse_tree);
|
|
|
|
// free the scopes
|
|
mp_raw_code_t *outer_raw_code = module_scope->raw_code;
|
|
for (scope_t *s = module_scope; s;) {
|
|
scope_t *next = s->next;
|
|
scope_free(s);
|
|
s = next;
|
|
}
|
|
|
|
if (comp->compile_error != MP_OBJ_NULL) {
|
|
nlr_raise(comp->compile_error);
|
|
} else {
|
|
return outer_raw_code;
|
|
}
|
|
}
|
|
|
|
mp_obj_t mp_compile(mp_parse_tree_t *parse_tree, qstr source_file, bool is_repl) {
|
|
mp_raw_code_t *rc = mp_compile_to_raw_code(parse_tree, source_file, is_repl);
|
|
// return function that executes the outer module
|
|
return mp_make_function_from_raw_code(rc, MP_OBJ_NULL, MP_OBJ_NULL);
|
|
}
|
|
|
|
#endif // MICROPY_ENABLE_COMPILER
|