djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a2ae503507
circuitpython/py/compile.c

3665 lines
145 KiB
C
Raw Normal View History

Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 18:27:38 -04:00
/*
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
* This file is part of the MicroPython project, http://micropython.org/
Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 18:27:38 -04:00
*
* The MIT License (MIT)
*
Add license to some obvious files.
2020-06-03 18:40:05 -04:00
* SPDX-FileCopyrightText: Copyright (c) 2013-2015 Damien P. George
Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 18:27:38 -04:00
*
* 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.
*/
py: Clean up includes. Remove unnecessary includes. Add includes that improve portability.
2014-03-16 03:14:26 -04:00
#include <stdbool.h>
Initial commit.
2013-10-04 14:53:11 -04:00
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
py: Move to guarded includes, everywhere in py/ core. Addresses issue #1022.
2015-01-01 15:27:54 -05:00
#include "py/scope.h"
#include "py/emit.h"
#include "py/compile.h"
#include "py/runtime.h"
py/emitinline: Move inline-asm align and data methods to compiler. These are generic methods that don't depend on the architecture and so can be handled directly by the compiler.
2016-12-09 04:54:54 -05:00
#include "py/asmbase.h"
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#include "py/persistentcode.h"
Initial commit.
2013-10-04 14:53:11 -04:00
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
#include "supervisor/shared/translate.h"
py: Add MICROPY_ENABLE_COMPILER and MICROPY_PY_BUILTINS_EVAL_EXEC opts. MICROPY_ENABLE_COMPILER can be used to enable/disable the entire compiler, which is useful when only loading of pre-compiled bytecode is supported. It is enabled by default. MICROPY_PY_BUILTINS_EVAL_EXEC controls support of eval and exec builtin functions. By default they are only included if MICROPY_ENABLE_COMPILER is enabled. Disabling both options saves about 40k of code size on 32-bit x86.
2015-12-18 07:35:44 -05:00
#if MICROPY_ENABLE_COMPILER
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO need to mangle __attr names
py/compile: Optimise emitter label indices to save a word of heap. Previous to this patch, a label with value "0" was used to indicate an invalid label, but that meant a wasted word (at slot 0) in the array of label offsets. This patch adjusts the label indices so the first one starts at 0, and the maximum value indicates an invalid label.
2017-06-22 01:05:58 -04:00
#define INVALID_LABEL (0xffff)
Initial commit.
2013-10-04 14:53:11 -04:00
typedef enum {
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
// define rules with a compile function
py: Change macro var args in parser to be C99 compliant.
2014-01-22 19:00:53 -05:00
#define DEF_RULE(rule, comp, kind, ...) PN_##rule,
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
#define DEF_RULE_NC(rule, kind, ...)
run code formatting script
2021-03-15 09:57:36 -04:00
#include "py/grammar.h"
Initial commit.
2013-10-04 14:53:11 -04:00
#undef DEF_RULE
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
#undef DEF_RULE_NC
py: Parse big-int/float/imag constants directly in parser. Previous to this patch, a big-int, float or imag constant was interned (made into a qstr) and then parsed at runtime to create an object each time it was needed. This is wasteful in RAM and not efficient. Now, these constants are parsed straight away in the parser and turned into objects. This allows constants with large numbers of digits (so addresses issue #1103) and takes us a step closer to #722.
2015-02-07 20:57:40 -05:00
PN_const_object, // special node for a constant, generic Python object
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
// define rules without a compile function
#define DEF_RULE(rule, comp, kind, ...)
#define DEF_RULE_NC(rule, kind, ...) PN_##rule,
run code formatting script
2021-03-15 09:57:36 -04:00
#include "py/grammar.h"
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
#undef DEF_RULE
#undef DEF_RULE_NC
Initial commit.
2013-10-04 14:53:11 -04:00
} pn_kind_t;
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
#define NEED_METHOD_TABLE MICROPY_EMIT_NATIVE
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#if NEED_METHOD_TABLE
// we need a method table to do the lookup for the emitter functions
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
#define EMIT(fun) (comp->emit_method_table->fun(comp->emit))
#define EMIT_ARG(fun, ...) (comp->emit_method_table->fun(comp->emit, __VA_ARGS__))
py/emit: Combine fast and deref into one function for load/store/delete. Reduces code size by: bare-arm: -16 minimal x86: -208 unix x64: -408 unix nanbox: -248 stm32: -12 cc3200: -24 esp8266: -96 esp32: -44
2018-05-18 10:11:04 -04:00
#define EMIT_LOAD_FAST(qst, local_num) (comp->emit_method_table->load_id.local(comp->emit, qst, local_num, MP_EMIT_IDOP_LOCAL_FAST))
py/emit: Combine name and global into one func for load/store/delete. Reduces code size by: bare-arm: -56 minimal x86: -300 unix x64: -576 unix nanbox: -300 stm32: -164 cc3200: -56 esp8266: -236 esp32: -76
2018-05-22 07:16:30 -04:00
#define EMIT_LOAD_GLOBAL(qst) (comp->emit_method_table->load_id.global(comp->emit, qst, MP_EMIT_IDOP_GLOBAL_GLOBAL))
Initial commit.
2013-10-04 14:53:11 -04:00
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#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__))
py/emit: Combine fast and deref into one function for load/store/delete. Reduces code size by: bare-arm: -16 minimal x86: -208 unix x64: -408 unix nanbox: -248 stm32: -12 cc3200: -24 esp8266: -96 esp32: -44
2018-05-18 10:11:04 -04:00
#define EMIT_LOAD_FAST(qst, local_num) (mp_emit_bc_load_local(comp->emit, qst, local_num, MP_EMIT_IDOP_LOCAL_FAST))
py/emit: Combine name and global into one func for load/store/delete. Reduces code size by: bare-arm: -56 minimal x86: -300 unix x64: -576 unix nanbox: -300 stm32: -164 cc3200: -56 esp8266: -236 esp32: -76
2018-05-22 07:16:30 -04:00
#define EMIT_LOAD_GLOBAL(qst) (mp_emit_bc_load_global(comp->emit, qst, MP_EMIT_IDOP_GLOBAL_GLOBAL))
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#endif
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#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,
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
&emit_native_xtensawin_method_table,
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
};
#elif MICROPY_EMIT_NATIVE
py/compile: Simplify configuration of native emitter.
2016-12-06 19:17:17 -05:00
// 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
py: Integrate Xtensa assembler into native emitter. The config option MICROPY_EMIT_XTENSA can now be enabled to target the Xtensa architecture with @micropython.native and @micropython.viper decorators.
2016-12-09 00:39:39 -05:00
#elif MICROPY_EMIT_XTENSA
#define NATIVE_EMITTER(f) emit_native_xtensa_##f
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
#elif MICROPY_EMIT_XTENSAWIN
#define NATIVE_EMITTER(f) emit_native_xtensawin_##f
py/compile: Simplify configuration of native emitter.
2016-12-06 19:17:17 -05:00
#else
#error "unknown native emitter"
#endif
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#define NATIVE_EMITTER_TABLE &NATIVE_EMITTER(method_table)
py/compile: Simplify configuration of native emitter.
2016-12-06 19:17:17 -05:00
#endif
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#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,
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
NULL,
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
};
#elif MICROPY_EMIT_INLINE_ASM
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
// 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
py: Add inline Xtensa assembler. This patch adds the MICROPY_EMIT_INLINE_XTENSA option, which, when enabled, allows the @micropython.asm_xtensa decorator to be used. The following opcodes are currently supported (ax is a register, a0-a15): ret_n() callx0(ax) j(label) jx(ax) beqz(ax, label) bnez(ax, label) mov(ax, ay) movi(ax, imm) # imm can be full 32-bit, uses l32r if needed and_(ax, ay, az) or_(ax, ay, az) xor(ax, ay, az) add(ax, ay, az) sub(ax, ay, az) mull(ax, ay, az) l8ui(ax, ay, imm) l16ui(ax, ay, imm) l32i(ax, ay, imm) s8i(ax, ay, imm) s16i(ax, ay, imm) s32i(ax, ay, imm) l16si(ax, ay, imm) addi(ax, ay, imm) ball(ax, ay, label) bany(ax, ay, label) bbc(ax, ay, label) bbs(ax, ay, label) beq(ax, ay, label) bge(ax, ay, label) bgeu(ax, ay, label) blt(ax, ay, label) bnall(ax, ay, label) bne(ax, ay, label) bnone(ax, ay, label) Upon entry to the assembly function the registers a0, a12, a13, a14 are pushed to the stack and the stack pointer (a1) decreased by 16. Upon exit, these registers and the stack pointer are restored, and ret.n is executed to return to the caller (caller address is in a0). Note that the ABI for the Xtensa emitters is non-windowing.
2016-12-09 01:03:33 -05:00
#elif MICROPY_EMIT_INLINE_XTENSA
#define ASM_DECORATOR_QSTR MP_QSTR_asm_xtensa
#define ASM_EMITTER(f) emit_inline_xtensa_##f
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#else
#error "unknown asm emitter"
#endif
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#define ASM_EMITTER_TABLE &ASM_EMITTER(method_table)
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#endif
py: Allow to enable inline assembler without native emitter.
2015-10-03 12:07:54 -04:00
#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__))
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
// elements in this struct are ordered to make it compact
Initial commit.
2013-10-04 14:53:11 -04:00
typedef struct _compiler_t {
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
qstr source_file;
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
py, compiler: Clean up and compress scope/compile structures. Convert int types to uint where sensible, and then to uint8_t or uint16_t where possible to reduce RAM usage.
2014-04-09 07:27:39 -04:00
uint8_t is_repl;
uint8_t pass; // holds enum type pass_kind_t
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
uint8_t have_star;
// try to keep compiler clean from nlr
py/compile: Give more precise line number for compile errors. Previous to this patch there were some cases where line numbers for errors were 0 (unknown). Now the compiler attempts to give a better line number where possible, in some cases giving the line number of the closest statement, and other cases the line number of the inner-most scope of the error (eg the line number of the start of the function). This helps to give good (and sometimes exact) line numbers for ViperTypeError exceptions. This patch also makes sure that the first compile error (eg SyntaxError) that is encountered is reported (previously it was the last one that was reported).
2015-07-29 18:16:01 -04:00
mp_obj_t compile_error; // set to an exception object if there's an error
py/compile: Use size_t or uintptr_t instead of mp_uint_t.
2015-12-17 08:13:18 -05:00
size_t compile_error_line; // set to best guess of line of error
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint next_label;
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
uint16_t num_dict_params;
uint16_t num_default_params;
py: Fix break from within a for loop. Needed to pop the iterator object when breaking out of a for loop. Need also to be careful to unwind exception handler before popping iterator. Addresses issue #635.
2014-05-30 10:20:41 -04:00
uint16_t break_label; // highest bit set indicates we are breaking out of a for loop
uint16_t continue_label;
py, compiler: Clean up and compress scope/compile structures. Convert int types to uint where sensible, and then to uint8_t or uint16_t where possible to reduce RAM usage.
2014-04-09 07:27:39 -04:00
uint16_t cur_except_level; // increased for SETUP_EXCEPT, SETUP_FINALLY; decreased for POP_BLOCK, POP_EXCEPT
py: Fix compiling of nested while/for and exception handler. Addresses issue #912.
2014-10-17 10:08:49 -04:00
uint16_t break_continue_except_level;
Initial commit.
2013-10-04 14:53:11 -04:00
scope_t *scope_head;
scope_t *scope_cur;
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
emit_t *emit; // current emitter
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#if NEED_METHOD_TABLE
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
const emit_method_table_t *emit_method_table; // current emit method table
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#endif
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#if MICROPY_EMIT_INLINE_ASM
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
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
py: In compiler, put macro guard around potentially unused asm vars.
2015-03-14 08:59:31 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
} compiler_t;
py/compile: Give more precise line number for compile errors. Previous to this patch there were some cases where line numbers for errors were 0 (unknown). Now the compiler attempts to give a better line number where possible, in some cases giving the line number of the closest statement, and other cases the line number of the inner-most scope of the error (eg the line number of the start of the function). This helps to give good (and sometimes exact) line numbers for ViperTypeError exceptions. This patch also makes sure that the first compile error (eg SyntaxError) that is encountered is reported (previously it was the last one that was reported).
2015-07-29 18:16:01 -04:00
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)) {
run code formatting script
2021-03-15 09:57:36 -04:00
comp->compile_error_line = ((mp_parse_node_struct_t *)pn)->source_line;
py: Improve compiler syntax errors; catch more errors.
2014-04-08 11:41:02 -04:00
}
py: For viper compile errors, add traceback with function and filename. ViperTypeError now includes filename and function name where the error occurred. The line number is the line number of the start of the function definition, which is the best that can be done without a lot more work. Partially addresses issue #1381.
2015-07-27 17:20:00 -04:00
}
Compress all translated strings with Huffman coding. This saves code space in builds which use link-time optimization. The optimization drops the untranslated strings and replaces them with a compressed_string_t struct. It can then be decompressed to a c string. Builds without LTO work as well but include both untranslated strings and compressed strings. This work could be expanded to include QSTRs and loaded strings if a compress method is added to C. Its tracked in #531.
2018-08-15 21:32:37 -04:00
STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, const compressed_string_t *msg) {
py/compile: Give more precise line number for compile errors. Previous to this patch there were some cases where line numbers for errors were 0 (unknown). Now the compiler attempts to give a better line number where possible, in some cases giving the line number of the closest statement, and other cases the line number of the inner-most scope of the error (eg the line number of the start of the function). This helps to give good (and sometimes exact) line numbers for ViperTypeError exceptions. This patch also makes sure that the first compile error (eg SyntaxError) that is encountered is reported (previously it was the last one that was reported).
2015-07-29 18:16:01 -04:00
// 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);
}
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
}
Replace global "static" -> "STATIC", to allow "analysis builds". Part 2.
2014-02-12 11:31:30 -05:00
STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_arglist, bool is_method_call, int n_positional_extra);
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind);
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *pns, bool create_map);
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn);
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
STATIC uint comp_next_label(compiler_t *comp) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
return comp->next_label++;
}
py/emitnative: Optimise and improve exception handling in native code. Prior to this patch, native code would use a full nlr_buf_t for each exception handler (try-except, try-finally, with). For nested exception handlers this would use a lot of C stack and be rather inefficient. This patch changes how exceptions are handled in native code by setting up only a single nlr_buf_t context for the entire function, and then manages a state machine (using the PC) to work out which exception handler to run when an exception is raised by an nlr_jump. This keeps the C stack usage at a constant level regardless of the depth of Python exception blocks. The patch also fixes an existing bug when local variables are written to within an exception handler, then their value was incorrectly restored if an exception was raised (since the nlr_jump would restore register values, back to the point of the nlr_push). And it also gets nested try-finally+with working with the viper emitter. Broadly speaking, efficiency of executing native code that doesn't use any exception blocks is unchanged, and emitted code size is only slightly increased for such function. C stack usage of all native functions is either equal or less than before. Emitted code size for native functions that use exception blocks is increased by roughly 10% (due in part to fixing of above-mentioned bugs). But, most importantly, this patch allows to implement more Python features in native code, like unwind jumps and yielding from within nested exception blocks.
2018-08-15 23:56:36 -04:00
#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
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
STATIC void compile_increase_except_level(compiler_t *comp, uint label, int kind) {
EMIT_ARG(setup_block, label, kind);
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
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;
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
EMIT(end_finally);
reserve_labels_for_native(comp, 1);
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
}
Replace global "static" -> "STATIC", to allow "analysis builds". Part 2.
2014-02-12 11:31:30 -05:00
STATIC scope_t *scope_new_and_link(compiler_t *comp, scope_kind_t kind, mp_parse_node_t pn, uint emit_options) {
py: Remove unique_codes from emitglue.c. Replace with pointers. Attempt to address issue #386. unique_code_id's have been removed and replaced with a pointer to the "raw code" information. This pointer is stored in the actual byte code (aligned, so the GC can trace it), so that raw code (ie byte code, native code and inline assembler) is kept only for as long as it is needed. In memory it's now like a tree: the outer module's byte code points directly to its children's raw code. So when the outer code gets freed, if there are no remaining functions that need the raw code, then the children's code gets freed as well. This is pretty much like CPython does it, except that CPython stores indexes in the byte code rather than machine pointers. These indices index the per-function constant table in order to find the relevant code.
2014-04-13 06:04:33 -04:00
scope_t *scope = scope_new(kind, pn, comp->source_file, emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
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;
}
py: Provide typedefs for function types instead of writing them inline.
2015-04-09 11:31:53 -04:00
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) {
py, unix: Allow to compile with -Wsign-compare. See issue #699.
2015-01-16 12:47:07 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, pn_list_kind)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < num_nodes; i++) {
f(comp, pns->nodes[i]);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (!MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
f(comp, pn);
}
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_generic_all_nodes(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < num_nodes; i++) {
compile_node(comp, pns->nodes[i]);
py/compile: Give more precise line number for compile errors. Previous to this patch there were some cases where line numbers for errors were 0 (unknown). Now the compiler attempts to give a better line number where possible, in some cases giving the line number of the closest statement, and other cases the line number of the inner-most scope of the error (eg the line number of the start of the function). This helps to give good (and sometimes exact) line numbers for ViperTypeError exceptions. This patch also makes sure that the first compile error (eg SyntaxError) that is encountered is reported (previously it was the last one that was reported).
2015-07-29 18:16:01 -04:00
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;
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
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 {
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#if NEED_METHOD_TABLE
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
mp_emit_common_id_op(comp->emit, &comp->emit_method_table->load_id, comp->scope_cur, qst);
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#else
mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_load_id_ops, comp->scope_cur, qst);
#endif
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
}
}
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 {
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#if NEED_METHOD_TABLE
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
mp_emit_common_id_op(comp->emit, &comp->emit_method_table->store_id, comp->scope_cur, qst);
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#else
mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_store_id_ops, comp->scope_cur, qst);
#endif
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
}
}
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 {
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#if NEED_METHOD_TABLE
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
mp_emit_common_id_op(comp->emit, &comp->emit_method_table->delete_id, comp->scope_cur, qst);
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#else
mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_delete_id_ops, comp->scope_cur, qst);
#endif
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
}
}
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
STATIC void c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t *pns_list) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
int total = 0;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pn)) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
compile_node(comp, pn);
total += 1;
}
if (pns_list != NULL) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
for (int i = 0; i < n; i++) {
compile_node(comp, pns_list->nodes[i]);
}
total += n;
}
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, total, MP_EMIT_BUILD_TUPLE);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_generic_tuple(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// a simple tuple expression
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
c_tuple(comp, MP_PARSE_NODE_NULL, pns);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Replace global "static" -> "STATIC", to allow "analysis builds". Part 2.
2014-02-12 11:31:30 -05:00
STATIC void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label) {
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
if (mp_parse_node_is_const_false(pn)) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (jump_if == false) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(jump, label);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
}
return;
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
} else if (mp_parse_node_is_const_true(pn)) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (jump_if == true) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(jump, label);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
}
return;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (jump_if == false) {
py: Combine logic for compiling and/or tests, to reduce code size. Reduces code size by 72 bytes on Thumb2 archs.
2015-02-28 09:37:54 -05:00
and_or_logic1:;
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint label2 = comp_next_label(comp);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
for (int i = 0; i < n - 1; i++) {
py: Combine logic for compiling and/or tests, to reduce code size. Reduces code size by 72 bytes on Thumb2 archs.
2015-02-28 09:37:54 -05:00
c_if_cond(comp, pns->nodes[i], !jump_if, label2);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
}
py: Combine logic for compiling and/or tests, to reduce code size. Reduces code size by 72 bytes on Thumb2 archs.
2015-02-28 09:37:54 -05:00
c_if_cond(comp, pns->nodes[n - 1], jump_if, label);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, label2);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
} else {
py: Combine logic for compiling and/or tests, to reduce code size. Reduces code size by 72 bytes on Thumb2 archs.
2015-02-28 09:37:54 -05:00
and_or_logic2:
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
for (int i = 0; i < n; i++) {
py: Combine logic for compiling and/or tests, to reduce code size. Reduces code size by 72 bytes on Thumb2 archs.
2015-02-28 09:37:54 -05:00
c_if_cond(comp, pns->nodes[i], jump_if, label);
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
}
}
return;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
if (jump_if == false) {
py: Combine logic for compiling and/or tests, to reduce code size. Reduces code size by 72 bytes on Thumb2 archs.
2015-02-28 09:37:54 -05:00
goto and_or_logic2;
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
} else {
py: Combine logic for compiling and/or tests, to reduce code size. Reduces code size by 72 bytes on Thumb2 archs.
2015-02-28 09:37:54 -05:00
goto and_or_logic1;
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
c_if_cond(comp, pns->nodes[0], !jump_if, label);
return;
py: Add compiler optimisation for conditions in parenthesis. Optimises: if () -> if False if (x,...) -> if True if (a and b) -> if a and b
2014-08-29 15:04:01 -04:00
} 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);
}
py/parse: Optimise away parse node that's just parenthesis around expr. Before this patch, (x+y)*z would be parsed to a tree that contained a redundant identity parse node corresponding to the parenthesis. With this patch such nodes are optimised away, which reduces memory requirements for expressions with parenthesis, and simplifies the compiler because it doesn't need to handle this identity case. A parenthesis parse node is still needed for tuples.
2016-01-07 08:07:52 -05:00
} else {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
py: Add compiler optimisation for conditions in parenthesis. Optimises: if () -> if False if (x,...) -> if True if (a and b) -> if a and b
2014-08-29 15:04:01 -04:00
// non-empty tuple, acts as true for the condition
if (jump_if == true) {
EMIT_ARG(jump, label);
}
}
return;
Option in compile.c to emit compatible or not with CPython.
2013-10-12 10:01:56 -04:00
}
}
// nothing special, fall back to default compiling for node and jump
compile_node(comp, pn);
py: Combine emit functions for jump true/false to reduce code size. Saves 116 bytes for stmhal and 56 bytes for cc3200 port.
2015-02-28 10:04:06 -05:00
EMIT_ARG(pop_jump_if, jump_if, label);
Initial commit.
2013-10-04 14:53:11 -04:00
}
typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t kind);
Initial commit.
2013-10-04 14:53:11 -04:00
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, assign_kind_t assign_kind) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind != ASSIGN_AUG_STORE) {
compile_node(comp, pns->nodes[0]);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind != ASSIGN_AUG_STORE) {
for (int i = 0; i < n - 1; i++) {
compile_node(comp, pns1->nodes[i]);
}
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
run code formatting script
2021-03-15 09:57:36 -04:00
pns1 = (mp_parse_node_struct_t *)pns1->nodes[n - 1];
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Simplify some logic in compiler; add comments about CPython compat.
2015-03-25 18:06:47 -04:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind == ASSIGN_AUG_STORE) {
EMIT(rot_three);
py/emit: Combine load/store/delete subscr into one emit function. Reduces code size by: bare-arm: -8 minimal x86: -104 unix x64: -312 unix nanbox: -120 stm32: -60 cc3200: -16 esp8266: -92 esp32: -24
2018-05-22 07:31:56 -04:00
EMIT_ARG(subscr, MP_EMIT_SUBSCR_STORE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
compile_node(comp, pns1->nodes[0]);
if (assign_kind == ASSIGN_AUG_LOAD) {
EMIT(dup_top_two);
py/emit: Combine load/store/delete subscr into one emit function. Reduces code size by: bare-arm: -8 minimal x86: -104 unix x64: -312 unix nanbox: -120 stm32: -60 cc3200: -16 esp8266: -92 esp32: -24
2018-05-22 07:31:56 -04:00
EMIT_ARG(subscr, MP_EMIT_SUBSCR_LOAD);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py/emit: Combine load/store/delete subscr into one emit function. Reduces code size by: bare-arm: -8 minimal x86: -104 unix x64: -312 unix nanbox: -120 stm32: -60 cc3200: -16 esp8266: -92 esp32: -24
2018-05-22 07:31:56 -04:00
EMIT_ARG(subscr, MP_EMIT_SUBSCR_STORE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py/compile: Adjust c_assign_atom_expr() to use return instead of goto. Makes the flow of the function a little more obvious, and allows to reach 100% coverage of compile.c when using gcov.
2018-02-24 07:03:17 -05:00
return;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
if (assign_kind == ASSIGN_AUG_LOAD) {
EMIT(dup_top);
py/emit: Combine load/store/delete attr into one emit function. Reduces code size by: bare-arm: -20 minimal x86: -140 unix x64: -408 unix nanbox: -140 stm32: -68 cc3200: -16 esp8266: -80 esp32: -32
2018-05-22 07:43:41 -04:00
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]), MP_EMIT_ATTR_LOAD);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
if (assign_kind == ASSIGN_AUG_STORE) {
EMIT(rot_two);
}
py/emit: Combine load/store/delete attr into one emit function. Reduces code size by: bare-arm: -20 minimal x86: -140 unix x64: -408 unix nanbox: -140 stm32: -68 cc3200: -16 esp8266: -80 esp32: -32
2018-05-22 07:43:41 -04:00
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]), MP_EMIT_ATTR_STORE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Adjust c_assign_atom_expr() to use return instead of goto. Makes the flow of the function a little more obvious, and allows to reach 100% coverage of compile.c when using gcov.
2018-02-24 07:03:17 -05:00
return;
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("can't assign to expression"));
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
// we need to allow for a caller passing in 1 initial node (node_head) followed by an array of nodes (nodes_tail)
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void c_assign_tuple(compiler_t *comp, mp_parse_node_t node_head, uint num_tail, mp_parse_node_t *nodes_tail) {
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
uint num_head = (node_head == MP_PARSE_NODE_NULL) ? 0 : 1;
// look for star expression
py, unix: Allow to compile with -Wsign-compare. See issue #699.
2015-01-16 12:47:07 -05:00
uint have_star_index = -1;
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
if (num_head != 0 && MP_PARSE_NODE_IS_STRUCT_KIND(node_head, PN_star_expr)) {
EMIT_ARG(unpack_ex, 0, num_tail);
have_star_index = 0;
}
py, unix: Allow to compile with -Wsign-compare. See issue #699.
2015-01-16 12:47:07 -05:00
for (uint i = 0; i < num_tail; i++) {
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes_tail[i], PN_star_expr)) {
py, unix: Allow to compile with -Wsign-compare. See issue #699.
2015-01-16 12:47:07 -05:00
if (have_star_index == (uint)-1) {
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
EMIT_ARG(unpack_ex, num_head + i, num_tail - i - 1);
have_star_index = num_head + i;
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, nodes_tail[i], translate("multiple *x in assignment"));
Initial commit.
2013-10-04 14:53:11 -04:00
return;
}
}
}
py, unix: Allow to compile with -Wsign-compare. See issue #699.
2015-01-16 12:47:07 -05:00
if (have_star_index == (uint)-1) {
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
EMIT_ARG(unpack_sequence, num_head + num_tail);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
if (num_head != 0) {
if (0 == have_star_index) {
run code formatting script
2021-03-15 09:57:36 -04:00
c_assign(comp, ((mp_parse_node_struct_t *)node_head)->nodes[0], ASSIGN_STORE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
c_assign(comp, node_head, ASSIGN_STORE);
}
}
py, unix: Allow to compile with -Wsign-compare. See issue #699.
2015-01-16 12:47:07 -05:00
for (uint i = 0; i < num_tail; i++) {
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
if (num_head + i == have_star_index) {
run code formatting script
2021-03-15 09:57:36 -04:00
c_assign(comp, ((mp_parse_node_struct_t *)nodes_tail[i])->nodes[0], ASSIGN_STORE);
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
} else {
c_assign(comp, nodes_tail[i], ASSIGN_STORE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
// assigns top of stack to pn
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_kind) {
py: Simplify some logic in compiler; add comments about CPython compat.
2015-03-25 18:06:47 -04:00
assert(!MP_PARSE_NODE_IS_NULL(pn));
if (MP_PARSE_NODE_IS_LEAF(pn)) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_ID(pn)) {
py: Convert [u]int to mp_[u]int_t where appropriate. Addressing issue #50.
2014-10-03 13:44:14 -04:00
qstr arg = MP_PARSE_NODE_LEAF_ARG(pn);
Initial commit.
2013-10-04 14:53:11 -04:00
switch (assign_kind) {
case ASSIGN_STORE:
case ASSIGN_AUG_STORE:
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, arg);
Initial commit.
2013-10-04 14:53:11 -04:00
break;
case ASSIGN_AUG_LOAD:
py: Add "default" to switches to allow better code flow analysis. This helps compiler produce smaller code. Saves 124 bytes on stmhal and bare-arm.
2015-01-14 16:32:42 -05:00
default:
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_load_id(comp, arg);
Initial commit.
2013-10-04 14:53:11 -04:00
break;
}
} else {
py/compile: Simplify syntax-error messages for illegal assignments. With this patch all illegal assignments are reported as "can't assign to expression". Before the patch there were special cases for a literal on the LHS, and for augmented assignments (eg +=), but it seems a waste of bytes (and there are lots of bytes used in error messages) to spend on distinguishing such errors which a user will rarely encounter.
2017-03-28 21:28:33 -04:00
goto cannot_assign;
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
py: Simplify some logic in compiler; add comments about CPython compat.
2015-03-25 18:06:47 -04:00
// pn must be a struct
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
case PN_atom_expr_normal:
Initial commit.
2013-10-04 14:53:11 -04:00
// lhs is an index or attribute
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
c_assign_atom_expr(comp, pns, assign_kind);
Initial commit.
2013-10-04 14:53:11 -04:00
break;
case PN_testlist_star_expr:
case PN_exprlist:
// lhs is a tuple
if (assign_kind != ASSIGN_STORE) {
py/compile: Simplify syntax-error messages for illegal assignments. With this patch all illegal assignments are reported as "can't assign to expression". Before the patch there were special cases for a literal on the LHS, and for augmented assignments (eg +=), but it seems a waste of bytes (and there are lots of bytes used in error messages) to spend on distinguishing such errors which a user will rarely encounter.
2017-03-28 21:28:33 -04:00
goto cannot_assign;
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
c_assign_tuple(comp, MP_PARSE_NODE_NULL, MP_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
Initial commit.
2013-10-04 14:53:11 -04:00
break;
case PN_atom_paren:
// lhs is something in parenthesis
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty tuple
py: Save some ROM by shortening compiler error messages. Messages are still explanatory, while taking a little less ROM.
2014-04-27 11:55:27 -04:00
goto cannot_assign;
py/parse: Optimise away parse node that's just parenthesis around expr. Before this patch, (x+y)*z would be parsed to a tree that contained a redundant identity parse node corresponding to the parenthesis. With this patch such nodes are optimised away, which reduces memory requirements for expressions with parenthesis, and simplifies the compiler because it doesn't need to handle this identity case. A parenthesis parse node is still needed for tuples.
2016-01-07 08:07:52 -05:00
} else {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
py: Fix bug in compiler which allowed through illegal augmented assign. It allowed such things as (a, b) += c.
2015-03-25 19:06:48 -04:00
if (assign_kind != ASSIGN_STORE) {
py/compile: Simplify syntax-error messages for illegal assignments. With this patch all illegal assignments are reported as "can't assign to expression". Before the patch there were special cases for a literal on the LHS, and for augmented assignments (eg +=), but it seems a waste of bytes (and there are lots of bytes used in error messages) to spend on distinguishing such errors which a user will rarely encounter.
2017-03-28 21:28:33 -04:00
goto cannot_assign;
py: Fix bug in compiler which allowed through illegal augmented assign. It allowed such things as (a, b) += c.
2015-03-25 19:06:48 -04:00
}
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
goto testlist_comp;
}
break;
case PN_atom_bracket:
// lhs is something in brackets
if (assign_kind != ASSIGN_STORE) {
py/compile: Simplify syntax-error messages for illegal assignments. With this patch all illegal assignments are reported as "can't assign to expression". Before the patch there were special cases for a literal on the LHS, and for augmented assignments (eg +=), but it seems a waste of bytes (and there are lots of bytes used in error messages) to spend on distinguishing such errors which a user will rarely encounter.
2017-03-28 21:28:33 -04:00
goto cannot_assign;
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty list, assignment allowed
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
c_assign_tuple(comp, MP_PARSE_NODE_NULL, 0, NULL);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
goto testlist_comp;
} else {
// brackets around 1 item
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
c_assign_tuple(comp, pns->nodes[0], 0, NULL);
Initial commit.
2013-10-04 14:53:11 -04:00
}
break;
default:
py: Save some ROM by shortening compiler error messages. Messages are still explanatory, while taking a little less ROM.
2014-04-27 11:55:27 -04:00
goto cannot_assign;
Initial commit.
2013-10-04 14:53:11 -04:00
}
return;
run code formatting script
2021-03-15 09:57:36 -04:00
testlist_comp:
Initial commit.
2013-10-04 14:53:11 -04:00
// lhs is a sequence
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of one item, with trailing comma
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
c_assign_tuple(comp, pns->nodes[0], 0, NULL);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of many items
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
uint n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns2);
c_assign_tuple(comp, pns->nodes[0], n, pns2->nodes);
py/compile: Fix typo when checking for parse-node kind.
2016-09-30 00:48:06 -04:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
py: Save some ROM by shortening compiler error messages. Messages are still explanatory, while taking a little less ROM.
2014-04-27 11:55:27 -04:00
goto cannot_assign;
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// sequence with 2 items
goto sequence_with_2_items;
}
} else {
// sequence with 2 items
run code formatting script
2021-03-15 09:57:36 -04:00
sequence_with_2_items:
py: Implement compiling of *-expr within parenthesis.
2014-04-11 07:53:00 -04:00
c_assign_tuple(comp, MP_PARSE_NODE_NULL, 2, pns->nodes);
Initial commit.
2013-10-04 14:53:11 -04:00
}
return;
}
return;
run code formatting script
2021-03-15 09:57:36 -04:00
cannot_assign:
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("can't assign to expression"));
Initial commit.
2013-10-04 14:53:11 -04:00
}
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// stuff for lambda and comprehensions and generators:
py: Towards default keyword arguments. These are default arguments after a bare *.
2014-03-31 10:18:37 -04:00
// 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)
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int n_pos_defaults, int n_kw_defaults) {
py: Rename and reorder parameters in emit_make_function/closure. In preparation for implementing default keyword arguments.
2014-03-31 06:30:17 -04:00
assert(n_pos_defaults >= 0);
assert(n_kw_defaults >= 0);
py: Put all bytecode state (arg count, etc) in bytecode.
2015-10-22 18:45:37 -04:00
// set flags
if (n_kw_defaults > 0) {
this_scope->scope_flags |= MP_SCOPE_FLAG_DEFKWARGS;
}
this_scope->num_def_pos_args = n_pos_defaults;
py: Fix native functions so they run with their correct globals context. Prior to this commit a function compiled with the native decorator @micropython.native would not work correctly when accessing global variables, because the globals dict was not being set upon function entry. This commit fixes this problem by, upon function entry, setting as the current globals dict the globals dict context the function was defined within, as per normal Python semantics, and as bytecode does. Upon function exit the original globals dict is restored. In order to restore the globals dict when an exception is raised the native function must guard its internals with an nlr_push/nlr_pop pair. Because this push/pop is relatively expensive, in both C stack usage for the nlr_buf_t and CPU execution time, the implementation here optimises things as much as possible. First, the compiler keeps track of whether a function even needs to access global variables. Using this information the native emitter then generates three different kinds of code: 1. no globals used, no exception handlers: no nlr handling code and no setting of the globals dict. 2. globals used, no exception handlers: an nlr_buf_t is allocated on the C stack but it is not used if the globals dict is unchanged, saving execution time because nlr_push/nlr_pop don't need to run. 3. function has exception handlers, may use globals: an nlr_buf_t is allocated and nlr_push/nlr_pop are always called. In the end, native functions that don't access globals and don't have exception handlers will run more efficiently than those that do. Fixes issue #1573.
2018-09-13 08:03:48 -04:00
#if MICROPY_EMIT_NATIVE
// When creating a function/closure it will take a reference to the current globals
py/emitnative: Place const objs for native code in separate const table. This commit changes native code to handle constant objects like bytecode: instead of storing the pointers inside the native code they are now stored in a separate constant table (such pointers include objects like bignum, bytes, and raw code for nested functions). This removes the need for the GC to scan native code for root pointers, and takes a step towards making native code independent of the runtime (eg so it can be compiled offline by mpy-cross). Note that the changes to the struct scope_t did not increase its size: on a 32-bit architecture it is still 48 bytes, and on a 64-bit architecture it decreased from 80 to 72 bytes.
2018-09-27 09:27:53 -04:00
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_REFGLOBALS | MP_SCOPE_FLAG_HASCONSTS;
py: Fix native functions so they run with their correct globals context. Prior to this commit a function compiled with the native decorator @micropython.native would not work correctly when accessing global variables, because the globals dict was not being set upon function entry. This commit fixes this problem by, upon function entry, setting as the current globals dict the globals dict context the function was defined within, as per normal Python semantics, and as bytecode does. Upon function exit the original globals dict is restored. In order to restore the globals dict when an exception is raised the native function must guard its internals with an nlr_push/nlr_pop pair. Because this push/pop is relatively expensive, in both C stack usage for the nlr_buf_t and CPU execution time, the implementation here optimises things as much as possible. First, the compiler keeps track of whether a function even needs to access global variables. Using this information the native emitter then generates three different kinds of code: 1. no globals used, no exception handlers: no nlr handling code and no setting of the globals dict. 2. globals used, no exception handlers: an nlr_buf_t is allocated on the C stack but it is not used if the globals dict is unchanged, saving execution time because nlr_push/nlr_pop don't need to run. 3. function has exception handlers, may use globals: an nlr_buf_t is allocated and nlr_push/nlr_pop are always called. In the end, native functions that don't access globals and don't have exception handlers will run more efficiently than those that do. Fixes issue #1573.
2018-09-13 08:03:48 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
// make closed over variables, if any
py: emit correct id for closed over variables.
2013-12-10 13:28:17 -05:00
// ensure they are closed over in the order defined in the outer scope (mainly to agree with CPython)
Initial commit.
2013-10-04 14:53:11 -04:00
int nfree = 0;
if (comp->scope_cur->kind != SCOPE_MODULE) {
py: emit correct id for closed over variables.
2013-12-10 13:28:17 -05:00
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];
py: Convert [u]int to mp_[u]int_t in emit.h and associated .c files. Towards resolving issue #50.
2014-09-08 18:05:16 -04:00
if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython we load closures using LOAD_FAST
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
EMIT_LOAD_FAST(id->qst, id->local_num);
py: emit correct id for closed over variables.
2013-12-10 13:28:17 -05:00
nfree += 1;
}
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
// make the function/closure
if (nfree == 0) {
py: Rename and reorder parameters in emit_make_function/closure. In preparation for implementing default keyword arguments.
2014-03-31 06:30:17 -04:00
EMIT_ARG(make_function, this_scope, n_pos_defaults, n_kw_defaults);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: Making closures now passes pointer to stack, not a tuple for vars. Closed over variables are now passed on the stack, instead of creating a tuple and passing that. This way memory for the closed over variables can be allocated within the closure object itself. See issue #510 for background.
2014-04-20 12:50:40 -04:00
EMIT_ARG(make_closure, this_scope, nfree, n_pos_defaults, n_kw_defaults);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn) {
py/compile: Extract parse-node kind at start of func for efficiency. Otherwise the type of parse-node and its kind has to be re-extracted multiple times. This optimisation reduces code size by a bit (16 bytes on bare-arm).
2017-04-22 00:23:47 -04:00
// 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));
run code formatting script
2021-03-15 09:57:36 -04:00
pn_kind = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn);
py/compile: Extract parse-node kind at start of func for efficiency. Otherwise the type of parse-node and its kind has to be re-extracted multiple times. This optimisation reduces code size by a bit (16 bytes on bare-arm).
2017-04-22 00:23:47 -04:00
}
if (pn_kind == PN_typedargslist_star || pn_kind == PN_varargslist_star) {
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
comp->have_star = true;
/* don't need to distinguish bare from named star
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// bare star
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
} else {
// named star
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
}
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
*/
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
py/compile: Extract parse-node kind at start of func for efficiency. Otherwise the type of parse-node and its kind has to be re-extracted multiple times. This optimisation reduces code size by a bit (16 bytes on bare-arm).
2017-04-22 00:23:47 -04:00
} else if (pn_kind == PN_typedargslist_dbl_star || pn_kind == PN_varargslist_dbl_star) {
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
// named double star
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
// TODO do we need to do anything with this?
} else {
mp_parse_node_t pn_id;
mp_parse_node_t pn_equal;
py/compile: Extract parse-node kind at start of func for efficiency. Otherwise the type of parse-node and its kind has to be re-extracted multiple times. This optimisation reduces code size by a bit (16 bytes on bare-arm).
2017-04-22 00:23:47 -04:00
if (pn_kind == -1) {
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
// this parameter is just an id
pn_id = pn;
pn_equal = MP_PARSE_NODE_NULL;
py/compile: Extract parse-node kind at start of func for efficiency. Otherwise the type of parse-node and its kind has to be re-extracted multiple times. This optimisation reduces code size by a bit (16 bytes on bare-arm).
2017-04-22 00:23:47 -04:00
} else if (pn_kind == PN_typedargslist_name) {
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
// this parameter has a colon and/or equal specifier
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
pn_id = pns->nodes[0];
run code formatting script
2021-03-15 09:57:36 -04:00
// pn_colon = pns->nodes[1]; // unused
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
pn_equal = pns->nodes[2];
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
} else {
py/compile: Extract parse-node kind at start of func for efficiency. Otherwise the type of parse-node and its kind has to be re-extracted multiple times. This optimisation reduces code size by a bit (16 bytes on bare-arm).
2017-04-22 00:23:47 -04:00
assert(pn_kind == PN_varargslist_name); // should be
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
// this parameter has an equal specifier
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
pn_id = pns->nodes[0];
pn_equal = pns->nodes[1];
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
}
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)
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
if (!comp->have_star && comp->num_default_params != 0) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("non-default argument follows default argument"));
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
return;
}
} else {
Initial commit.
2013-10-04 14:53:11 -04:00
// this parameter has a default value
// in CPython, None (and True, False?) as default parameters are loaded with LOAD_NAME; don't understandy why
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
if (comp->have_star) {
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
comp->num_dict_params += 1;
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython we put the default dict parameters into a dictionary using the bytecode
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
if (comp->num_dict_params == 1) {
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython we put the default positional parameters into a tuple using the bytecode
py, compiler: Fix up creation of default positionals tuple. With new order of evaluation of defaults, creating the tuple was done in the wrong spot.
2014-04-11 19:05:49 -04:00
// we need to do this here before we start building the map for the default keywords
if (comp->num_default_params > 0) {
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, comp->num_default_params, MP_EMIT_BUILD_TUPLE);
py: Making closures now passes pointer to stack, not a tuple for vars. Closed over variables are now passed on the stack, instead of creating a tuple and passing that. This way memory for the closed over variables can be allocated within the closure object itself. See issue #510 for background.
2014-04-20 12:50:40 -04:00
} else {
EMIT(load_null); // sentinel indicating empty default positional args
py, compiler: Fix up creation of default positionals tuple. With new order of evaluation of defaults, creating the tuple was done in the wrong spot.
2014-04-11 19:05:49 -04:00
}
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
// first default dict param, so make the map
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
}
py: Implement default keyword only args. Should finish addressing issue #524.
2014-06-07 17:01:00 -04:00
// compile value then key, then store it to the dict
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
compile_node(comp, pn_equal);
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pn_id));
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
EMIT(store_map);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
comp->num_default_params += 1;
compile_node(comp, pn_equal);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
}
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
STATIC void compile_funcdef_lambdef(compiler_t *comp, scope_t *scope, mp_parse_node_t pn_params, pn_kind_t pn_list_kind) {
py: Fix compiler to handle lambdas used as default arguments. Addresses issue #1709.
2015-12-12 08:42:51 -05:00
// 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;
Initial commit.
2013-10-04 14:53:11 -04:00
// compile default parameters
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
comp->have_star = false;
py: Change compile order for default positional and keyword args. This simplifies the compiler a little, since now it can do 1 pass over a function declaration, to determine default arguments. I would have done this originally, but CPython 3.3 somehow had the default keyword args compiled before the default position args (even though they appear in the other order in the text of the script), and I thought it was important to have the same order of execution when evaluating default arguments. CPython 3.4 has changed the order to the more obvious one, so we can also change.
2014-04-11 09:38:30 -04:00
comp->num_dict_params = 0;
comp->num_default_params = 0;
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
apply_to_single_or_list(comp, pn_params, pn_list_kind, compile_funcdef_lambdef_param);
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
if (comp->compile_error != MP_OBJ_NULL) {
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
return;
py: Unify syntax error handling in compiler; check defualt arg syntax. Checks for non-default args following default args, and errors out. Addresses issue #328.
2014-03-03 18:19:11 -05:00
}
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython we put the default positional parameters into a tuple using the bytecode
py, compiler: Fix up creation of default positionals tuple. With new order of evaluation of defaults, creating the tuple was done in the wrong spot.
2014-04-11 19:05:49 -04:00
// 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) {
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, comp->num_default_params, MP_EMIT_BUILD_TUPLE);
py: Making closures now passes pointer to stack, not a tuple for vars. Closed over variables are now passed on the stack, instead of creating a tuple and passing that. This way memory for the closed over variables can be allocated within the closure object itself. See issue #510 for background.
2014-04-20 12:50:40 -04:00
EMIT(load_null); // sentinel indicating empty default keyword args
py: Towards default keyword arguments. These are default arguments after a bare *.
2014-03-31 10:18:37 -04:00
}
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
// make the function
close_over_variables_etc(comp, scope, comp->num_default_params, comp->num_dict_params);
py: Fix compiler to handle lambdas used as default arguments. Addresses issue #1709.
2015-12-12 08:42:51 -05:00
// restore state
comp->have_star = orig_have_star;
comp->num_dict_params = orig_num_dict_params;
comp->num_default_params = orig_num_default_params;
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
}
// 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;
}
Initial commit.
2013-10-04 14:53:11 -04:00
// get the scope for this function
run code formatting script
2021-03-15 09:57:36 -04:00
scope_t *fscope = (scope_t *)pns->nodes[4];
Initial commit.
2013-10-04 14:53:11 -04:00
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
// compile the function definition
compile_funcdef_lambdef(comp, fscope, pns->nodes[1], PN_typedargslist);
Initial commit.
2013-10-04 14:53:11 -04:00
// return its name (the 'f' in "def f(...):")
return fscope->simple_name;
}
// leaves class object on stack
// returns class name
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
Initial commit.
2013-10-04 14:53:11 -04:00
// create a new scope for this class
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
scope_t *s = scope_new_and_link(comp, SCOPE_CLASS, (mp_parse_node_t)pns, emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store the class scope so the compiling function can use it at each pass
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
pns->nodes[3] = (mp_parse_node_t)s;
Initial commit.
2013-10-04 14:53:11 -04:00
}
EMIT(load_build_class);
// scope for this class
run code formatting script
2021-03-15 09:57:36 -04:00
scope_t *cscope = (scope_t *)pns->nodes[3];
Initial commit.
2013-10-04 14:53:11 -04:00
// compile the class
close_over_variables_etc(comp, cscope, 0, 0);
// get its name
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
EMIT_ARG(load_const_str, cscope->simple_name);
Initial commit.
2013-10-04 14:53:11 -04:00
// nodes[1] has parent classes, if any
py: Fix bug in compiler for empty class bases. Eg class A(): pass would fail an assertion.
2014-03-30 18:06:37 -04:00
// 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);
Initial commit.
2013-10-04 14:53:11 -04:00
// return its name (the 'C' in class C(...):")
return cscope->simple_name;
}
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// returns true if it was a built-in decorator (even if the built-in had an error)
Replace global "static" -> "STATIC", to allow "analysis builds". Part 2.
2014-02-12 11:31:30 -05:00
STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_node_t *name_nodes, uint *emit_options) {
Split qstr into pools, and put initial pool in ROM. Qstr's are now split into a linked-list of qstr pools. This has 2 benefits: the first pool can be in ROM (huge benefit, since we no longer use RAM for the core qstrs), and subsequent pools use m_new for the next pool instead of m_renew (thus avoiding a huge single table for all the qstrs). Still would be better to use a hash table, but this scheme takes us part of the way (eventually convert the pools to hash tables). Also fixed bug with import. Also improved the way the module code is referenced (not magic number 1 anymore).
2014-01-04 10:57:35 -05:00
if (MP_PARSE_NODE_LEAF_ARG(name_nodes[0]) != MP_QSTR_micropython) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
return false;
}
if (name_len != 2) {
Make error messages platform agnostic Remove mentions of 'MicroPython' in error messages as they could lead to confusion in lesser-experienced users
2021-04-10 19:36:53 -04:00
compile_syntax_error(comp, name_nodes[0], translate("invalid decorator"));
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
return true;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
py: Rename byte_code to bytecode everywhere. bytecode is the more widely used. See issue #590.
2014-05-10 05:36:38 -04:00
if (attr == MP_QSTR_bytecode) {
py: Rename BYTE_CODE to BYTECODE (this was missed in previous rename).
2014-05-12 17:35:37 -04:00
*emit_options = MP_EMIT_OPT_BYTECODE;
run code formatting script
2021-03-15 09:57:36 -04:00
// @micropython.native decorator.
Split qstr into pools, and put initial pool in ROM. Qstr's are now split into a linked-list of qstr pools. This has 2 benefits: the first pool can be in ROM (huge benefit, since we no longer use RAM for the core qstrs), and subsequent pools use m_new for the next pool instead of m_renew (thus avoiding a huge single table for all the qstrs). Still would be better to use a hash table, but this scheme takes us part of the way (eventually convert the pools to hash tables). Also fixed bug with import. Also improved the way the module code is referenced (not magic number 1 anymore).
2014-01-04 10:57:35 -05:00
} else if (attr == MP_QSTR_native) {
Make the @micropython.native decorator no-op if support isn't enabled When adding the ability for boards to turn on the `@micropython.native`, `viper`, and `asm_thumb` decorators it was pointed out that it's somewhat awkward to write libraries and drivers that can take advantage of this since the decorators raise `SyntaxErrors` if they aren't enabled. In the case of `viper` and `asm_thumb` this behavior makes sense as they require writing non-normative code. Drivers could have a normal and viper/thumb implementation and implement them as such: ```python try: import _viper_impl as _impl except SyntaxError: import _python_impl as _impl def do_thing(): return _impl.do_thing() ``` For `native`, however, this behavior and the pattern to work around it is less than ideal. Since `native` code should also be valid Python code (although not necessarily the other way around) using the pattern above means *duplicating* the Python implementation and adding `@micropython.native` in the code. This is an unnecessary maintenance burden. This commit *modifies* the behavior of the `@micropython.native` decorator. On boards with `CIRCUITPY_ENABLE_MPY_NATIVE` turned on it operates as usual. On boards with it turned off it does *nothing*- it doesn't raise a `SyntaxError` and doesn't apply optimizations. This means we can write our drivers/libraries once and take advantage of speedups on boards where they are enabled.
2019-11-12 15:33:52 -05:00
// 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
py: Add option to compiler to specify default code emitter. Also add command line option to unix port to select emitter.
2014-04-06 06:48:15 -04:00
*emit_options = MP_EMIT_OPT_NATIVE_PYTHON;
Make the @micropython.native decorator no-op if support isn't enabled When adding the ability for boards to turn on the `@micropython.native`, `viper`, and `asm_thumb` decorators it was pointed out that it's somewhat awkward to write libraries and drivers that can take advantage of this since the decorators raise `SyntaxErrors` if they aren't enabled. In the case of `viper` and `asm_thumb` this behavior makes sense as they require writing non-normative code. Drivers could have a normal and viper/thumb implementation and implement them as such: ```python try: import _viper_impl as _impl except SyntaxError: import _python_impl as _impl def do_thing(): return _impl.do_thing() ``` For `native`, however, this behavior and the pattern to work around it is less than ideal. Since `native` code should also be valid Python code (although not necessarily the other way around) using the pattern above means *duplicating* the Python implementation and adding `@micropython.native` in the code. This is an unnecessary maintenance burden. This commit *modifies* the behavior of the `@micropython.native` decorator. On boards with `CIRCUITPY_ENABLE_MPY_NATIVE` turned on it operates as usual. On boards with it turned off it does *nothing*- it doesn't raise a `SyntaxError` and doesn't apply optimizations. This means we can write our drivers/libraries once and take advantage of speedups on boards where they are enabled.
2019-11-12 15:33:52 -05:00
#else
return true;
#endif
run code formatting script
2021-03-15 09:57:36 -04:00
#if MICROPY_EMIT_NATIVE
// @micropython.viper decorator.
Split qstr into pools, and put initial pool in ROM. Qstr's are now split into a linked-list of qstr pools. This has 2 benefits: the first pool can be in ROM (huge benefit, since we no longer use RAM for the core qstrs), and subsequent pools use m_new for the next pool instead of m_renew (thus avoiding a huge single table for all the qstrs). Still would be better to use a hash table, but this scheme takes us part of the way (eventually convert the pools to hash tables). Also fixed bug with import. Also improved the way the module code is referenced (not magic number 1 anymore).
2014-01-04 10:57:35 -05:00
} else if (attr == MP_QSTR_viper) {
py: Add option to compiler to specify default code emitter. Also add command line option to unix port to select emitter.
2014-04-06 06:48:15 -04:00
*emit_options = MP_EMIT_OPT_VIPER;
run code formatting script
2021-03-15 09:57:36 -04:00
#endif
#if MICROPY_EMIT_INLINE_ASM
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#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
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
} else if (attr == ASM_DECORATOR_QSTR) {
*emit_options = MP_EMIT_OPT_ASM;
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#endif
run code formatting script
2021-03-15 09:57:36 -04:00
#endif
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
} else {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, name_nodes[1], translate("invalid micropython decorator"));
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#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], translate("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], translate("invalid architecture"));
}
}
#endif
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
return true;
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// get the list of decorators
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *nodes;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n = mp_parse_node_extract_list(&pns->nodes[0], PN_decorators, &nodes);
Initial commit.
2013-10-04 14:53:11 -04:00
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// inherit emit options for this function/class definition
uint emit_options = comp->scope_cur->emit_options;
// compile each decorator
int num_built_in_decorators = 0;
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i++) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_decorator = (mp_parse_node_struct_t *)nodes[i];
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// nodes[0] contains the decorator function, which is a dotted name
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *name_nodes;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int name_len = mp_parse_node_extract_list(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// 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]);
py, unix, stmhal: Allow to compile with -Wshadow. See issue #699.
2015-01-20 06:55:10 -05:00
for (int j = 1; j < name_len; j++) {
assert(MP_PARSE_NODE_IS_ID(name_nodes[j])); // should be
py/emit: Combine load/store/delete attr into one emit function. Reduces code size by: bare-arm: -20 minimal x86: -140 unix x64: -408 unix nanbox: -140 stm32: -68 cc3200: -16 esp8266: -80 esp32: -32
2018-05-22 07:43:41 -04:00
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[j]), MP_EMIT_ATTR_LOAD);
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
}
// nodes[1] contains arguments to the decorator function, if any
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns_decorator->nodes[1])) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// call the decorator function with the arguments in nodes[1]
compile_node(comp, pns_decorator->nodes[1]);
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
// compile the body (funcdef, async funcdef or classdef) and get its name
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_body = (mp_parse_node_struct_t *)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
qstr body_name = 0;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
body_name = compile_funcdef_helper(comp, pns_body, emit_options);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
#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]));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns_body->nodes[0];
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
body_name = compile_funcdef_helper(comp, pns0, emit_options);
run code formatting script
2021-03-15 09:57:36 -04:00
scope_t *fscope = (scope_t *)pns0->nodes[4];
update async tests with less upython workaround and more cpython compatibility
2020-10-11 02:39:32 -04:00
fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR | MP_SCOPE_FLAG_ASYNC;
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
assert(MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef); // should be
body_name = compile_classdef_helper(comp, pns_body, emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
}
// call each decorator
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
for (int i = 0; i < n - num_built_in_decorators; i++) {
py, compile: Combine have_star_arg, have_dbl_star_arg into star_flags. Small reduction in ROM, heap and stack usage.
2014-04-09 07:43:17 -04:00
EMIT_ARG(call_function, 1, 0, 0);
Initial commit.
2013-10-04 14:53:11 -04:00
}
// store func/class object into name
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, body_name);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_funcdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
qstr fname = compile_funcdef_helper(comp, pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store function object into function name
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, fname);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_ID(pn)) {
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_delete_id(comp, MP_PARSE_NODE_LEAF_ARG(pn));
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_expr_normal)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
Initial commit.
2013-10-04 14:53:11 -04:00
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_node(comp, pns->nodes[0]); // base of the atom_expr_normal node
Initial commit.
2013-10-04 14:53:11 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n - 1; i++) {
compile_node(comp, pns1->nodes[i]);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
run code formatting script
2021-03-15 09:57:36 -04:00
pns1 = (mp_parse_node_struct_t *)pns1->nodes[n - 1];
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Simplify some logic in compiler; add comments about CPython compat.
2015-03-25 18:06:47 -04:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns1->nodes[0]);
py/emit: Combine load/store/delete subscr into one emit function. Reduces code size by: bare-arm: -8 minimal x86: -104 unix x64: -312 unix nanbox: -120 stm32: -60 cc3200: -16 esp8266: -92 esp32: -24
2018-05-22 07:31:56 -04:00
EMIT_ARG(subscr, MP_EMIT_SUBSCR_DELETE);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
py/emit: Combine load/store/delete attr into one emit function. Reduces code size by: bare-arm: -20 minimal x86: -140 unix x64: -408 unix nanbox: -140 stm32: -68 cc3200: -16 esp8266: -80 esp32: -32
2018-05-22 07:43:41 -04:00
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]), MP_EMIT_ATTR_DELETE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: Improve compiler syntax errors; catch more errors.
2014-04-08 11:41:02 -04:00
goto cannot_delete;
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
py: Improve compiler syntax errors; catch more errors.
2014-04-08 11:41:02 -04:00
goto cannot_delete;
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {
run code formatting script
2021-03-15 09:57:36 -04:00
pn = ((mp_parse_node_struct_t *)pn)->nodes[0];
py/parse: Optimise away parse node that's just parenthesis around expr. Before this patch, (x+y)*z would be parsed to a tree that contained a redundant identity parse node corresponding to the parenthesis. With this patch such nodes are optimised away, which reduces memory requirements for expressions with parenthesis, and simplifies the compiler because it doesn't need to handle this identity case. A parenthesis parse node is still needed for tuples.
2016-01-07 08:07:52 -05:00
if (MP_PARSE_NODE_IS_NULL(pn)) {
goto cannot_delete;
} else {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
Initial commit.
2013-10-04 14:53:11 -04:00
// TODO perhaps factorise testlist_comp code with other uses of PN_testlist_comp
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of one item, with trailing comma
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_NULL(pns1->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
c_del_stmt(comp, pns->nodes[0]);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// sequence of many items
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
c_del_stmt(comp, pns->nodes[0]);
for (int i = 0; i < n; i++) {
c_del_stmt(comp, pns1->nodes[i]);
}
py/compile: Fix typo when checking for parse-node kind.
2016-09-30 00:48:06 -04:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for) {
py: Improve compiler syntax errors; catch more errors.
2014-04-08 11:41:02 -04:00
goto cannot_delete;
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// sequence with 2 items
goto sequence_with_2_items;
}
} else {
// sequence with 2 items
run code formatting script
2021-03-15 09:57:36 -04:00
sequence_with_2_items:
Initial commit.
2013-10-04 14:53:11 -04:00
c_del_stmt(comp, pns->nodes[0]);
c_del_stmt(comp, pns->nodes[1]);
}
}
} else {
various: Spelling fixes
2017-05-29 03:08:14 -04:00
// some arbitrary statement that we can't delete (eg del 1)
py: Improve compiler syntax errors; catch more errors.
2014-04-08 11:41:02 -04:00
goto cannot_delete;
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Improve compiler syntax errors; catch more errors.
2014-04-08 11:41:02 -04:00
return;
cannot_delete:
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pn, translate("can't delete expression"));
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
apply_to_single_or_list(comp, pns->nodes[0], PN_exprlist, c_del_stmt);
}
py/compile: Combine break and continue compile functions.
2018-06-18 23:54:03 -04:00
STATIC void compile_break_cont_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
uint16_t label;
Compress all translated strings with Huffman coding. This saves code space in builds which use link-time optimization. The optimization drops the untranslated strings and replaces them with a compressed_string_t struct. It can then be decompressed to a c string. Builds without LTO work as well but include both untranslated strings and compressed strings. This work could be expanded to include QSTRs and loaded strings if a compress method is added to C. Its tracked in #531.
2018-08-15 21:32:37 -04:00
const compressed_string_t *error_msg;
py/compile: Combine break and continue compile functions.
2018-06-18 23:54:03 -04:00
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_break_stmt) {
label = comp->break_label;
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
error_msg = translate("'break' outside loop");
py/compile: Combine break and continue compile functions.
2018-06-18 23:54:03 -04:00
} else {
label = comp->continue_label;
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
error_msg = translate("'continue' outside loop");
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Combine break and continue compile functions.
2018-06-18 23:54:03 -04:00
if (label == INVALID_LABEL) {
compile_syntax_error(comp, (mp_parse_node_t)pns, error_msg);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Fix compiling of nested while/for and exception handler. Addresses issue #912.
2014-10-17 10:08:49 -04:00
assert(comp->cur_except_level >= comp->break_continue_except_level);
py/compile: Combine break and continue compile functions.
2018-06-18 23:54:03 -04:00
EMIT_ARG(unwind_jump, label, comp->cur_except_level - comp->break_continue_except_level);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Implement REPL.
2013-10-18 14:58:12 -04:00
if (comp->scope_cur->kind != SCOPE_FUNCTION) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("'return' outside function"));
Implement REPL.
2013-10-18 14:58:12 -04:00
return;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Implement REPL.
2013-10-18 14:58:12 -04:00
// no argument to 'return', so return None
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
py/compile: Add COMP_RETURN_IF_EXPR option to enable return-if-else opt. With this optimisation enabled the compiler optimises the if-else expression within a return statement. The optimisation reduces bytecode size by 2 bytes for each use of such a return-if-else statement. Since such a statement is not often used, and costs bytes for the code, the feature is disabled by default. For example the following code: def f(x): return 1 if x else 2 compiles to this bytecode with the optimisation disabled (left column is bytecode offset in bytes): 00 LOAD_FAST 0 01 POP_JUMP_IF_FALSE 8 04 LOAD_CONST_SMALL_INT 1 05 JUMP 9 08 LOAD_CONST_SMALL_INT 2 09 RETURN_VALUE and to this bytecode with the optimisation enabled: 00 LOAD_FAST 0 01 POP_JUMP_IF_FALSE 6 04 LOAD_CONST_SMALL_INT 1 05 RETURN_VALUE 06 LOAD_CONST_SMALL_INT 2 07 RETURN_VALUE So the JUMP to RETURN_VALUE is optimised and replaced by RETURN_VALUE, saving 2 bytes and making the code a bit faster.
2017-04-22 00:58:01 -04:00
} else if (MICROPY_COMP_RETURN_IF_EXPR
run code formatting script
2021-03-15 09:57:36 -04:00
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// special case when returning an if-expression; to match CPython optimisation
run code formatting script
2021-03-15 09:57:36 -04:00
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];
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_fail = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
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);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, l_fail);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns_test_if_else->nodes[1]); // failure value
} else {
compile_node(comp, pns->nodes[0]);
}
EMIT(return_value);
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_yield_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
EMIT(pop_top);
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// raise
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(raise_varargs, 0);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// raise x from y
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
compile_node(comp, pns->nodes[1]);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(raise_varargs, 2);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// raise x
compile_node(comp, pns->nodes[0]);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(raise_varargs, 1);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
// q_base holds the base of the name
// eg a -> q_base=a
// a.b.c -> q_base=a
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q_base) {
Initial commit.
2013-10-04 14:53:11 -04:00
bool is_as = false;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
Initial commit.
2013-10-04 14:53:11 -04:00
// a name of the form x as y; unwrap it
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
*q_base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
Initial commit.
2013-10-04 14:53:11 -04:00
pn = pns->nodes[0];
is_as = true;
}
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
if (MP_PARSE_NODE_IS_NULL(pn)) {
// empty name (eg, from . import x)
*q_base = MP_QSTR_;
py/emit: Combine import from/name/star into one emit function. Change in code size is: bare-arm: +4 minimal x86: -88 unix x64: -456 unix nanbox: -88 stm32: -44 cc3200: +0 esp8266: -104 esp32: +8
2018-05-22 07:58:25 -04:00
EMIT_ARG(import, MP_QSTR_, MP_EMIT_IMPORT_NAME); // import the empty string
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
} else if (MP_PARSE_NODE_IS_ID(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// just a simple name
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
qstr q_full = MP_PARSE_NODE_LEAF_ARG(pn);
Initial commit.
2013-10-04 14:53:11 -04:00
if (!is_as) {
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
*q_base = q_full;
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/emit: Combine import from/name/star into one emit function. Change in code size is: bare-arm: +4 minimal x86: -88 unix x64: -456 unix nanbox: -88 stm32: -44 cc3200: +0 esp8266: -104 esp32: +8
2018-05-22 07:58:25 -04:00
EMIT_ARG(import, q_full, MP_EMIT_IMPORT_NAME);
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_name)); // should be
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
{
Initial commit.
2013-10-04 14:53:11 -04:00
// a name of the form a.b.c
if (!is_as) {
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
*q_base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
int len = n - 1;
for (int i = 0; i < n; i++) {
Revamp qstrs: they now include length and hash. Can now have null bytes in strings. Can define ROM qstrs per port using qstrdefsport.h
2014-01-21 16:40:13 -05:00
len += qstr_len(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Convert all uses of alloca() to use new scoped allocation API.
2017-11-26 07:37:19 -05:00
char *q_ptr = mp_local_alloc(len);
py/compile: Use alloca instead of qstr_build when compiling import name. The technique of using alloca is how dotted import names are composed in mp_import_from and mp_builtin___import__, so use the same technique in the compiler. This puts less pressure on the heap (only the stack is used if the qstr already exists, and if it doesn't exist then the standard qstr block memory is used for the new qstr rather than a separate chunk of the heap) and reduces overall code size.
2017-10-31 22:16:16 -04:00
char *str_dest = q_ptr;
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i++) {
if (i > 0) {
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
*str_dest++ = '.';
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Change qstr_* functions to use size_t as the type for str len arg.
2015-11-27 07:23:18 -05:00
size_t str_src_len;
Revamp qstrs: they now include length and hash. Can now have null bytes in strings. Can define ROM qstrs per port using qstrdefsport.h
2014-01-21 16:40:13 -05:00
const byte *str_src = qstr_data(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]), &str_src_len);
py: remove depedence on strcat and stpcpy. This fixes Issue #29, and means the core is no longer dependent on string functions, except strlen.
2014-01-02 11:36:09 -05:00
memcpy(str_dest, str_src, str_src_len);
str_dest += str_src_len;
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Use alloca instead of qstr_build when compiling import name. The technique of using alloca is how dotted import names are composed in mp_import_from and mp_builtin___import__, so use the same technique in the compiler. This puts less pressure on the heap (only the stack is used if the qstr already exists, and if it doesn't exist then the standard qstr block memory is used for the new qstr rather than a separate chunk of the heap) and reduces overall code size.
2017-10-31 22:16:16 -04:00
qstr q_full = qstr_from_strn(q_ptr, len);
py: Convert all uses of alloca() to use new scoped allocation API.
2017-11-26 07:37:19 -05:00
mp_local_free(q_ptr);
py/emit: Combine import from/name/star into one emit function. Change in code size is: bare-arm: +4 minimal x86: -88 unix x64: -456 unix nanbox: -88 stm32: -44 cc3200: +0 esp8266: -104 esp32: +8
2018-05-22 07:58:25 -04:00
EMIT_ARG(import, q_full, MP_EMIT_IMPORT_NAME);
Initial commit.
2013-10-04 14:53:11 -04:00
if (is_as) {
for (int i = 1; i < n; i++) {
py/emit: Combine load/store/delete attr into one emit function. Reduces code size by: bare-arm: -20 minimal x86: -140 unix x64: -408 unix nanbox: -140 stm32: -68 cc3200: -16 esp8266: -80 esp32: -32
2018-05-22 07:43:41 -04:00
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]), MP_EMIT_ATTR_LOAD);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
}
}
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void compile_dotted_as_name(compiler_t *comp, mp_parse_node_t pn) {
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
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);
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, q_base);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_import_name(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
apply_to_single_or_list(comp, pns->nodes[0], PN_dotted_as_names, compile_dotted_as_name);
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
mp_parse_node_t pn_import_source = pns->nodes[0];
various: Spelling fixes
2017-05-29 03:08:14 -04:00
// extract the preceding .'s (if any) for a relative import, to compute the import level
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
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"
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_2b = (mp_parse_node_struct_t *)pn_import_source;
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
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;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n = mp_parse_node_extract_list(&pn_rel, PN_one_or_more_period_or_ellipsis, &nodes);
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
// count the total number of .'s
for (int 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);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
#if MICROPY_CPYTHON_COMPAT
if (comp->scope_cur->kind != SCOPE_MODULE) {
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("import * not at module level"));
return;
}
#endif
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
EMIT_ARG(load_const_small_int, import_level);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
// build the "fromlist" tuple
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
EMIT_ARG(load_const_str, MP_QSTR__star_);
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 1, MP_EMIT_BUILD_TUPLE);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
// do the import
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
qstr dummy_q;
do_import_name(comp, pn_import_source, &dummy_q);
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
EMIT_ARG(import, MP_QSTRnull, MP_EMIT_IMPORT_STAR);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
EMIT_ARG(load_const_small_int, import_level);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
// build the "fromlist" tuple
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *pn_nodes;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n = mp_parse_node_extract_list(&pns->nodes[1], PN_import_as_names, &pn_nodes);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
for (int i = 0; i < n; i++) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pn_nodes[i];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
EMIT_ARG(load_const_str, id2);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
}
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, n, MP_EMIT_BUILD_TUPLE);
py: add skeletal import functionality.
2013-12-10 12:27:24 -05:00
// do the import
py, compiler: Implement compiling of relative imports.
2014-04-10 07:56:52 -04:00
qstr dummy_q;
do_import_name(comp, pn_import_source, &dummy_q);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i++) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pn_nodes[i];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
py/emit: Combine import from/name/star into one emit function. Change in code size is: bare-arm: +4 minimal x86: -88 unix x64: -456 unix nanbox: -88 stm32: -44 cc3200: +0 esp8266: -104 esp32: +8
2018-05-22 07:58:25 -04:00
EMIT_ARG(import, id2, MP_EMIT_IMPORT_FROM);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, id2);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
EMIT(pop_top);
}
}
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
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) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("identifier redefined as global"));
py: Move global/nonlocal decl code to compiler for proper SyntaxError. This patch gives proper SyntaxError exceptions for bad global/nonlocal declarations. It also reduces code size: 304 bytes on unix x64, 132 bytes on stmhal.
2014-12-21 12:26:45 -05:00
return;
}
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
// if the id exists in the global scope, set its kind to EXPLICIT_GLOBAL
py/compile: Remove unneeded variable from global/nonlocal stmt helpers.
2018-10-26 02:11:48 -04:00
id_info = scope_find_global(comp->scope_cur, id_info->qst);
py: Move global/nonlocal decl code to compiler for proper SyntaxError. This patch gives proper SyntaxError exceptions for bad global/nonlocal declarations. It also reduces code size: 304 bytes on unix x64, 132 bytes on stmhal.
2014-12-21 12:26:45 -05:00
if (id_info != NULL) {
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
}
}
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
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) {
py/compile: Fix case of eager implicit conversion of local to nonlocal. This ensures that implicit variables are only converted to implicit closed-over variables (nonlocals) at the very end of the function scope. If variables are closed-over when first used (read from, as was done prior to this commit) then this can be incorrect because the variable may be assigned to later on in the function which means they are just a plain local, not closed over. Fixes issue #4272.
2018-10-26 01:48:07 -04:00
id_info->kind = ID_INFO_KIND_GLOBAL_IMPLICIT;
scope_check_to_close_over(comp->scope_cur, id_info);
py/scope: Factor common code to find locals and close over them. Saves 50-100 bytes of code.
2016-09-29 23:53:00 -04:00
if (id_info->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("no binding for nonlocal found"));
py/scope: Factor common code to find locals and close over them. Saves 50-100 bytes of code.
2016-09-29 23:53:00 -04:00
}
} else if (id_info->kind != ID_INFO_KIND_FREE) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("identifier redefined as nonlocal"));
py: Move global/nonlocal decl code to compiler for proper SyntaxError. This patch gives proper SyntaxError exceptions for bad global/nonlocal declarations. It also reduces code size: 304 bytes on unix x64, 132 bytes on stmhal.
2014-12-21 12:26:45 -05:00
}
}
py/compile: Combine global and nonlocal statement compile functions.
2018-06-19 00:04:05 -04:00
STATIC void compile_global_nonlocal_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
py/compile: Combine global and nonlocal statement compile functions.
2018-06-19 00:04:05 -04:00
bool is_global = MP_PARSE_NODE_STRUCT_KIND(pns) == PN_global_stmt;
if (!is_global && comp->scope_cur->kind == SCOPE_MODULE) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("can't declare nonlocal in outer code"));
py: Move global/nonlocal decl code to compiler for proper SyntaxError. This patch gives proper SyntaxError exceptions for bad global/nonlocal declarations. It also reduces code size: 304 bytes on unix x64, 132 bytes on stmhal.
2014-12-21 12:26:45 -05:00
return;
}
py/compile: Combine global and nonlocal statement compile functions.
2018-06-19 00:04:05 -04:00
py: Move global/nonlocal decl code to compiler for proper SyntaxError. This patch gives proper SyntaxError exceptions for bad global/nonlocal declarations. It also reduces code size: 304 bytes on unix x64, 132 bytes on stmhal.
2014-12-21 12:26:45 -05:00
mp_parse_node_t *nodes;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n = mp_parse_node_extract_list(&pns->nodes[0], PN_name_list, &nodes);
py: Move global/nonlocal decl code to compiler for proper SyntaxError. This patch gives proper SyntaxError exceptions for bad global/nonlocal declarations. It also reduces code size: 304 bytes on unix x64, 132 bytes on stmhal.
2014-12-21 12:26:45 -05:00
for (int i = 0; i < n; i++) {
py/compile: Combine global and nonlocal statement compile functions.
2018-06-19 00:04:05 -04:00
qstr qst = MP_PARSE_NODE_LEAF_ARG(nodes[i]);
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qst, ID_INFO_KIND_UNDECIDED);
py/compile: Combine global and nonlocal statement compile functions.
2018-06-19 00:04:05 -04:00
if (is_global) {
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
compile_declare_global(comp, (mp_parse_node_t)pns, id_info);
py/compile: Combine global and nonlocal statement compile functions.
2018-06-19 00:04:05 -04:00
} else {
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
compile_declare_nonlocal(comp, (mp_parse_node_t)pns, id_info);
py/compile: Combine global and nonlocal statement compile functions.
2018-06-19 00:04:05 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_assert_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
py/compile: Don't compile assert statements when optimisations enabled. As per CPython.
2016-08-26 08:28:22 -04:00
// with optimisations enabled we don't compile assertions
if (MP_STATE_VM(mp_optimise_value) != 0) {
return;
}
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_end = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns->nodes[0], true, l_end);
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
EMIT_LOAD_GLOBAL(MP_QSTR_AssertionError); // we load_global instead of load_id, to be consistent with CPython
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// assertion message
compile_node(comp, pns->nodes[1]);
py, compile: Combine have_star_arg, have_dbl_star_arg into star_flags. Small reduction in ROM, heap and stack usage.
2014-04-09 07:43:17 -04:00
EMIT_ARG(call_function, 1, 0, 0);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(raise_varargs, 1);
EMIT_ARG(label_assign, l_end);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_end = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// optimisation: don't emit anything when "if False"
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
if (!mp_parse_node_is_const_false(pns->nodes[0])) {
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
uint l_fail = comp_next_label(comp);
c_if_cond(comp, pns->nodes[0], false, l_fail); // if condition
Initial commit.
2013-10-04 14:53:11 -04:00
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
compile_node(comp, pns->nodes[1]); // if block
py: Enable a jump optimisation in the compiler.
2014-04-02 11:12:28 -04:00
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// optimisation: skip everything else when "if True"
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
if (mp_parse_node_is_const_true(pns->nodes[0])) {
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
goto done;
}
py: Enable a jump optimisation in the compiler.
2014-04-02 11:12:28 -04:00
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
if (
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// 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]))
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
// 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);
}
Initial commit.
2013-10-04 14:53:11 -04:00
py: Simplify compilation of elif blocks.
2014-10-17 13:30:16 -04:00
// compile elif blocks (if any)
mp_parse_node_t *pn_elif;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n_elif = mp_parse_node_extract_list(&pns->nodes[2], PN_if_stmt_elif_list, &pn_elif);
py: Simplify compilation of elif blocks.
2014-10-17 13:30:16 -04:00
for (int i = 0; i < n_elif; i++) {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_elif[i], PN_if_stmt_elif)); // should be
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t *)pn_elif[i];
py: Simplify compilation of elif blocks.
2014-10-17 13:30:16 -04:00
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// optimisation: don't emit anything when "if False"
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
if (!mp_parse_node_is_const_false(pns_elif->nodes[0])) {
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
uint l_fail = comp_next_label(comp);
c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition
py: Simplify compilation of elif blocks.
2014-10-17 13:30:16 -04:00
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
compile_node(comp, pns_elif->nodes[1]); // elif block
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// optimisation: skip everything else when "elif True"
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
if (mp_parse_node_is_const_true(pns_elif->nodes[0])) {
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
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);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
// compile else block
compile_node(comp, pns->nodes[3]); // can be null
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
done:
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, l_end);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
#define START_BREAK_CONTINUE_BLOCK \
py: Fix compiling of nested while/for and exception handler. Addresses issue #912.
2014-10-17 10:08:49 -04:00
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; \
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint break_label = comp_next_label(comp); \
uint continue_label = comp_next_label(comp); \
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
comp->break_label = break_label; \
comp->continue_label = continue_label; \
comp->break_continue_except_level = comp->cur_except_level;
Initial commit.
2013-10-04 14:53:11 -04:00
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
#define END_BREAK_CONTINUE_BLOCK \
comp->break_label = old_break_label; \
comp->continue_label = old_continue_label; \
py: Fix compiling of nested while/for and exception handler. Addresses issue #912.
2014-10-17 10:08:49 -04:00
comp->break_continue_except_level = old_break_continue_except_level;
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
START_BREAK_CONTINUE_BLOCK
Initial commit.
2013-10-04 14:53:11 -04:00
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
if (!mp_parse_node_is_const_false(pns->nodes[0])) { // optimisation: don't emit anything for "while False"
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
uint top_label = comp_next_label(comp);
py/parse: Move function to check for const parse node to parse.[ch].
2016-11-12 23:32:05 -05:00
if (!mp_parse_node_is_const_true(pns->nodes[0])) { // optimisation: don't jump to cond for "while True"
py: Add more compiler optimisations for constant if/while conditions.
2014-10-17 13:57:33 -04:00
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
}
Implement basic exception framework, and simple for loop.
2013-10-15 17:25:17 -04:00
// break/continue apply to outer loop (if any) in the else block
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
END_BREAK_CONTINUE_BLOCK
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[2]); // else
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, break_label);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Fix optimised for-loop compiler so it follows proper semantics. You can now assign to the range end variable and the for-loop still works correctly. This fully addresses issue #565. Also fixed a bug with the stack not being fully popped when breaking out of an optimised for-loop (and it's actually impossible to write a test for this case!).
2014-12-12 12:19:56 -05:00
// 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>.
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
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) {
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
START_BREAK_CONTINUE_BLOCK
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint top_label = comp_next_label(comp);
uint entry_label = comp_next_label(comp);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
py: Fix optimised for-loop compiler so it follows proper semantics. You can now assign to the range end variable and the for-loop still works correctly. This fully addresses issue #565. Also fixed a bug with the stack not being fully popped when breaking out of an optimised for-loop (and it's actually impossible to write a test for this case!).
2014-12-12 12:19:56 -05:00
// 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
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
compile_node(comp, pn_start);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(jump, entry_label);
EMIT_ARG(label_assign, top_label);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
py: Fix a semantic issue with range optimisation. Now you can assign to the range variable within the for loop and it will still work. Partially addresses issue #565.
2014-12-11 12:35:23 -05:00
// duplicate next value and store it to var
EMIT(dup_top);
py: Fix bug in optimised for .. range. Don't store final, failing value to the loop variable. This fix also makes for .. range a bit more efficient, as it uses less store/load pairs for the loop variable.
2014-03-31 13:02:22 -04:00
c_assign(comp, pn_var, ASSIGN_STORE);
Fix but with optimised range being 1 over.
2013-11-09 15:12:03 -05:00
// compile body
compile_node(comp, pn_body);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, continue_label);
py: Implement break and continue byte codes, and add tests. Also fixes a bug in the for-in-range optimiser. I hope to remove break and continue byte codes in the future and just use jump (if possible).
2014-01-21 18:48:04 -05:00
py: Fix optimised for-loop compiler so it follows proper semantics. You can now assign to the range end variable and the for-loop still works correctly. This fully addresses issue #565. Also fixed a bug with the stack not being fully popped when breaking out of an optimised for-loop (and it's actually impossible to write a test for this case!).
2014-12-12 12:19:56 -05:00
// compile: var + step
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
compile_node(comp, pn_step);
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(binary_op, MP_BINARY_OP_INPLACE_ADD);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, entry_label);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
// compile: if var <cond> end: goto top
py: Fix optimised for-loop compiler so it follows proper semantics. You can now assign to the range end variable and the for-loop still works correctly. This fully addresses issue #565. Also fixed a bug with the stack not being fully popped when breaking out of an optimised for-loop (and it's actually impossible to write a test for this case!).
2014-12-12 12:19:56 -05:00
if (end_on_stack) {
EMIT(dup_top_two);
EMIT(rot_two);
} else {
EMIT(dup_top);
compile_node(comp, pn_end);
}
parse: Refactor parse node encoding to support full range of small ints. Based on suggestion by @dpgeorge at https://github.com/micropython/micropython/pull/313
2014-02-22 09:39:45 -05:00
assert(MP_PARSE_NODE_IS_SMALL_INT(pn_step));
if (MP_PARSE_NODE_LEAF_SMALL_INT(pn_step) >= 0) {
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(binary_op, MP_BINARY_OP_LESS);
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
} else {
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(binary_op, MP_BINARY_OP_MORE);
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
}
py: Combine emit functions for jump true/false to reduce code size. Saves 116 bytes for stmhal and 56 bytes for cc3200 port.
2015-02-28 10:04:06 -05:00
EMIT_ARG(pop_jump_if, true, top_label);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
// break/continue apply to outer loop (if any) in the else block
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
END_BREAK_CONTINUE_BLOCK
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
py/compile: Fix bug with break/continue in else of optimised for-range. This patch fixes a bug whereby the Python stack was not correctly reset if there was a break/continue statement in the else black of an optimised for-range loop. For example, in the following code the "j" variable from the inner for loop was not being popped off the Python stack: for i in range(4): for j in range(4): pass else: continue This is now fixed with this patch.
2017-06-21 23:50:33 -04:00
// 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);
}
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, break_label);
py: Fix optimised for-loop compiler so it follows proper semantics. You can now assign to the range end variable and the for-loop still works correctly. This fully addresses issue #565. Also fixed a bug with the stack not being fully popped when breaking out of an optimised for-loop (and it's actually impossible to write a test for this case!).
2014-12-12 12:19:56 -05:00
// 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);
}
py/compile: Fix bug with break/continue in else of optimised for-range. This patch fixes a bug whereby the Python stack was not correctly reset if there was a break/continue statement in the else black of an optimised for-range loop. For example, in the following code the "j" variable from the inner for loop was not being popped off the Python stack: for i in range(4): for j in range(4): pass else: continue This is now fixed with this patch.
2017-06-21 23:50:33 -04:00
if (!MP_PARSE_NODE_IS_NULL(pn_else)) {
EMIT_ARG(label_assign, end_label);
}
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
// 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
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
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)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_it = (mp_parse_node_struct_t *)pns->nodes[1];
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
if (MP_PARSE_NODE_IS_ID(pns_it->nodes[0])
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
&& MP_PARSE_NODE_LEAF_ARG(pns_it->nodes[0]) == MP_QSTR_range
run code formatting script
2021-03-15 09:57:36 -04:00
&& 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];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *args;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n_args = mp_parse_node_extract_list(&pn_range_args, PN_arglist, &args);
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
mp_parse_node_t pn_range_start;
mp_parse_node_t pn_range_end;
mp_parse_node_t pn_range_step;
bool optimize = false;
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
if (1 <= n_args && n_args <= 3) {
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
optimize = true;
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
if (n_args == 1) {
py/parse: Make mp_parse_node_new_leaf an inline function. It is split into 2 functions, one to make small ints and the other to make a non-small-int leaf node. This reduces code size by 32 bytes on bare-arm, 64 bytes on unix (x64-64) and 144 bytes on stmhal.
2016-11-12 23:35:11 -05:00
pn_range_start = mp_parse_node_new_small_int(0);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
pn_range_end = args[0];
py/parse: Make mp_parse_node_new_leaf an inline function. It is split into 2 functions, one to make small ints and the other to make a non-small-int leaf node. This reduces code size by 32 bytes on bare-arm, 64 bytes on unix (x64-64) and 144 bytes on stmhal.
2016-11-12 23:35:11 -05:00
pn_range_step = mp_parse_node_new_small_int(1);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
} else if (n_args == 2) {
pn_range_start = args[0];
pn_range_end = args[1];
py/parse: Make mp_parse_node_new_leaf an inline function. It is split into 2 functions, one to make small ints and the other to make a non-small-int leaf node. This reduces code size by 32 bytes on bare-arm, 64 bytes on unix (x64-64) and 144 bytes on stmhal.
2016-11-12 23:35:11 -05:00
pn_range_step = mp_parse_node_new_small_int(1);
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
} else {
pn_range_start = args[0];
pn_range_end = args[1];
pn_range_step = args[2];
py: Raise a ValueError if range() step is zero. Following CPython. Otherwise one gets either an infinite loop (if code is optimised by the uPy compiler) or possibly a divide-by-zero CPU exception.
2017-04-04 20:50:26 -04:00
// 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) {
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
optimize = false;
}
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
}
py: Don't try to optimise for+range when args are not simple expressions. Addresses issue #1693.
2015-12-08 16:05:14 -05:00
// arguments must be able to be compiled as standard expressions
if (optimize && MP_PARSE_NODE_IS_STRUCT(pn_range_start)) {
run code formatting script
2021-03-15 09:57:36 -04:00
int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_range_start);
py: Don't try to optimise for+range when args are not simple expressions. Addresses issue #1693.
2015-12-08 16:05:14 -05:00
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)) {
run code formatting script
2021-03-15 09:57:36 -04:00
int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_range_end);
py: Don't try to optimise for+range when args are not simple expressions. Addresses issue #1693.
2015-12-08 16:05:14 -05:00
if (k == PN_arglist_star || k == PN_arglist_dbl_star || k == PN_argument) {
optimize = false;
}
}
compile_for_stmt_optimised_range(): Properly handle negative & unknown steps. If step is not constant, in first approximation, we can't apply optimization, (well, we could, but need a special case for this).
2014-01-10 13:38:57 -05:00
}
if (optimize) {
Add optimisation for "for x in range".
2013-11-06 15:20:49 -05:00
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;
}
}
}
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
START_BREAK_CONTINUE_BLOCK
py: Fix break from within a for loop. Needed to pop the iterator object when breaking out of a for loop. Need also to be careful to unwind exception handler before popping iterator. Addresses issue #635.
2014-05-30 10:20:41 -04:00
comp->break_label |= MP_EMIT_BREAK_FROM_FOR;
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint pop_label = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[1]); // iterator
py: Allow bytecode/native to put iter_buf on stack for simple for loops. So that the "for x in it: ..." statement can now work without using the heap (so long as the iterator argument fits in an iter_buf structure).
2016-01-09 18:59:52 -05:00
EMIT_ARG(get_iter, true);
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
EMIT_ARG(label_assign, continue_label);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(for_iter, pop_label);
Initial commit.
2013-10-04 14:53:11 -04:00
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
compile_node(comp, pns->nodes[2]); // body
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) {
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
EMIT_ARG(jump, continue_label);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, pop_label);
py: Remove unused "use_stack" argument from for_iter_end emit function.
2017-01-16 23:30:18 -05:00
EMIT(for_iter_end);
Initial commit.
2013-10-04 14:53:11 -04:00
// break/continue apply to outer loop (if any) in the else block
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
END_BREAK_CONTINUE_BLOCK
Initial commit.
2013-10-04 14:53:11 -04:00
py/compile: Fix bug with break/continue in else of optimised for-range. This patch fixes a bug whereby the Python stack was not correctly reset if there was a break/continue statement in the else black of an optimised for-range loop. For example, in the following code the "j" variable from the inner for loop was not being popped off the Python stack: for i in range(4): for j in range(4): pass else: continue This is now fixed with this patch.
2017-06-21 23:50:33 -04:00
compile_node(comp, pns->nodes[3]); // else (may be empty)
Initial commit.
2013-10-04 14:53:11 -04:00
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, break_label);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
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) {
Initial commit.
2013-10-04 14:53:11 -04:00
// setup code
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l1 = comp_next_label(comp);
uint success_label = comp_next_label(comp);
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
compile_increase_except_level(comp, l1, MP_EMIT_SETUP_BLOCK_EXCEPT);
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn_body); // body
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
EMIT_ARG(pop_except_jump, success_label, false); // jump over exception handler
py, compiler: Improve stack depth counting. Much less of a hack now. Hopefully it's correct!
2014-04-10 13:22:19 -04:00
EMIT_ARG(label_assign, l1); // start of exception handler
py: Improvements to native emitter. Native emitter can now compile try/except blocks using nlr_push/nlr_pop. It probably only works for 1 level of exception handling. It doesn't work on Thumb (only x64). Native emitter can also handle some additional op codes. With this patch, 198 tests now pass using "-X emit=native" option to micropython.
2014-06-30 00:17:25 -04:00
EMIT(start_except_handler);
py, compiler: Improve stack depth counting. Much less of a hack now. Hopefully it's correct!
2014-04-10 13:22:19 -04:00
py: Only store the exception instance on Py stack in bytecode try block. When an exception is raised and is to be handled by the VM, it is stored on the Python value stack so the bytecode can access it. CPython stores 3 objects on the stack for each exception: exc type, exc instance and traceback. uPy followed this approach, but it turns out not to be necessary. Instead, it is enough to store just the exception instance on the Python value stack. The only place where the 3 values are needed explicitly is for the __exit__ handler of a with-statement context, but for these cases the 3 values can be extracted from the single exception instance. This patch removes the need to store 3 values on the stack, and instead just stores the exception instance. Code size is reduced by about 50-100 bytes, the compiler and VM are slightly simpler, generate bytecode is smaller (by 2 bytes for each try block), and the Python value stack is reduced in size for functions that handle exceptions.
2016-09-26 22:37:21 -04:00
// at this point the top of the stack contains the exception instance that was raised
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l2 = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n_except; i++) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_except = (mp_parse_node_struct_t *)pn_excepts[i];
Initial commit.
2013-10-04 14:53:11 -04:00
qstr qstr_exception_local = 0;
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint end_finally_label = comp_next_label(comp);
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
#if MICROPY_PY_SYS_SETTRACE
EMIT_ARG(set_source_line, pns_except->source_line);
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// this is a catch all exception handler
if (i + 1 != n_except) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn_excepts[i], translate("default 'except' must be last"));
py: Make compiler not crash when default except is not last.
2015-01-13 18:33:16 -05:00
compile_decrease_except_level(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
return;
}
} else {
// this exception handler requires a match to a certain type of exception
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t pns_exception_expr = pns_except->nodes[0];
if (MP_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pns_exception_expr;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
Initial commit.
2013-10-04 14:53:11 -04:00
// handler binds the exception to a local
pns_exception_expr = pns3->nodes[0];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
qstr_exception_local = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
EMIT(dup_top);
compile_node(comp, pns_exception_expr);
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(binary_op, MP_BINARY_OP_EXCEPTION_MATCH);
py: Combine emit functions for jump true/false to reduce code size. Saves 116 bytes for stmhal and 56 bytes for cc3200 port.
2015-02-28 10:04:06 -05:00
EMIT_ARG(pop_jump_if, false, end_finally_label);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Only store the exception instance on Py stack in bytecode try block. When an exception is raised and is to be handled by the VM, it is stored on the Python value stack so the bytecode can access it. CPython stores 3 objects on the stack for each exception: exc type, exc instance and traceback. uPy followed this approach, but it turns out not to be necessary. Instead, it is enough to store just the exception instance on the Python value stack. The only place where the 3 values are needed explicitly is for the __exit__ handler of a with-statement context, but for these cases the 3 values can be extracted from the single exception instance. This patch removes the need to store 3 values on the stack, and instead just stores the exception instance. Code size is reduced by about 50-100 bytes, the compiler and VM are slightly simpler, generate bytecode is smaller (by 2 bytes for each try block), and the Python value stack is reduced in size for functions that handle exceptions.
2016-09-26 22:37:21 -04:00
// either discard or store the exception instance
Initial commit.
2013-10-04 14:53:11 -04:00
if (qstr_exception_local == 0) {
EMIT(pop_top);
} else {
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, qstr_exception_local);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
// 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>
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l3 = 0;
Initial commit.
2013-10-04 14:53:11 -04:00
if (qstr_exception_local != 0) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
l3 = comp_next_label(comp);
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
compile_increase_except_level(comp, l3, MP_EMIT_SETUP_BLOCK_FINALLY);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
compile_node(comp, pns_except->nodes[1]); // the <body>
Initial commit.
2013-10-04 14:53:11 -04:00
if (qstr_exception_local != 0) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
EMIT_ARG(label_assign, l3);
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, qstr_exception_local);
compile_delete_id(comp, qstr_exception_local);
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
compile_decrease_except_level(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
EMIT_ARG(pop_except_jump, l2, true);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, end_finally_label);
py: Only store the exception instance on Py stack in bytecode try block. When an exception is raised and is to be handled by the VM, it is stored on the Python value stack so the bytecode can access it. CPython stores 3 objects on the stack for each exception: exc type, exc instance and traceback. uPy followed this approach, but it turns out not to be necessary. Instead, it is enough to store just the exception instance on the Python value stack. The only place where the 3 values are needed explicitly is for the __exit__ handler of a with-statement context, but for these cases the 3 values can be extracted from the single exception instance. This patch removes the need to store 3 values on the stack, and instead just stores the exception instance. Code size is reduced by about 50-100 bytes, the compiler and VM are slightly simpler, generate bytecode is smaller (by 2 bytes for each try block), and the Python value stack is reduced in size for functions that handle exceptions.
2016-09-26 22:37:21 -04:00
EMIT_ARG(adjust_stack_size, 1); // stack adjust for the exception instance
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
compile_decrease_except_level(comp);
py: Improvements to native emitter. Native emitter can now compile try/except blocks using nlr_push/nlr_pop. It probably only works for 1 level of exception handling. It doesn't work on Thumb (only x64). Native emitter can also handle some additional op codes. With this patch, 198 tests now pass using "-X emit=native" option to micropython.
2014-06-30 00:17:25 -04:00
EMIT(end_except_handler);
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, success_label);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn_else); // else block, can be null
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, l2);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
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) {
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_finally_block = comp_next_label(comp);
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
compile_increase_except_level(comp, l_finally_block, MP_EMIT_SETUP_BLOCK_FINALLY);
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
Initial commit.
2013-10-04 14:53:11 -04:00
if (n_except == 0) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_NULL(pn_else));
py: Simplify stack get/set to become stack adjust in emitters. Can do this now that the stack size calculation is improved.
2014-04-10 13:28:54 -04:00
EMIT_ARG(adjust_stack_size, 3); // stack adjust for possible UNWIND_JUMP state
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn_body);
py: Simplify stack get/set to become stack adjust in emitters. Can do this now that the stack size calculation is improved.
2014-04-10 13:28:54 -04:00
EMIT_ARG(adjust_stack_size, -3);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
compile_try_except(comp, pn_body, n_except, pn_except, pn_else);
}
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
EMIT_ARG(label_assign, l_finally_block);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn_finally);
py: Implement break/continue from an exception with finally. Still todo: break/continue from within the finally block itself.
2014-02-01 15:08:18 -05:00
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
compile_decrease_except_level(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_try_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should be
{
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
Initial commit.
2013-10-04 14:53:11 -04:00
// just try-finally
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
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) {
Initial commit.
2013-10-04 14:53:11 -04:00
// try-except and possibly else and/or finally
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *pn_excepts;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n_except = mp_parse_node_extract_list(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// no finally
compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1]);
} else {
// have finally
run code formatting script
2021-03-15 09:57:36 -04:00
compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((mp_parse_node_struct_t *)pns2->nodes[2])->nodes[0]);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// just try-except
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *pn_excepts;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n_except = mp_parse_node_extract_list(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, MP_PARSE_NODE_NULL);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void compile_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *nodes, mp_parse_node_t body) {
Initial commit.
2013-10-04 14:53:11 -04:00
if (n == 0) {
// no more pre-bits, compile the body of the with
compile_node(comp, body);
} else {
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_end = comp_next_label(comp);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// this pre-bit is of the form "a as b"
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
compile_increase_except_level(comp, l_end, MP_EMIT_SETUP_BLOCK_WITH);
Initial commit.
2013-10-04 14:53:11 -04:00
c_assign(comp, pns->nodes[1], ASSIGN_STORE);
} else {
// this pre-bit is just an expression
compile_node(comp, nodes[0]);
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
compile_increase_except_level(comp, l_end, MP_EMIT_SETUP_BLOCK_WITH);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(pop_top);
}
// compile additional pre-bits and the body
compile_with_stmt_helper(comp, n - 1, nodes + 1, body);
// finish this with block
py: Combine continuous block of emit steps into with_cleanup emit call. Because different emitters need to handle with-cleanup in different ways.
2016-04-07 03:50:38 -04:00
EMIT_ARG(with_cleanup, l_end);
py/emitnative: Add support for return/break/continue in try and with. This patch adds full support for unwinding jumps to the native emitter. This means that return/break/continue can be used in try-except, try-finally and with statements. For code that doesn't use unwinding jumps there is almost no overhead added to the generated code.
2018-09-04 00:31:28 -04:00
reserve_labels_for_native(comp, 3); // used by native's with_cleanup
vm: Implement "with" statement (SETUP_WITH and WITH_CLEANUP bytecodes).
2014-03-28 22:10:11 -04:00
compile_decrease_except_level(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *nodes;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
Initial commit.
2013-10-04 14:53:11 -04:00
assert(n > 0);
// compile in a nested fashion
compile_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
}
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
STATIC void compile_yield_from(compiler_t *comp) {
py: Allow bytecode/native to put iter_buf on stack for simple for loops. So that the "for x in it: ..." statement can now work without using the heap (so long as the iterator argument fits in an iter_buf structure).
2016-01-09 18:59:52 -05:00
EMIT_ARG(get_iter, false);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
py/emit: Combine yield value and yield-from emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -72 unix x64: -200 unix nanbox: -72 stm32: -52 cc3200: -32 esp8266: -84 esp32: -24
2018-05-18 10:30:42 -04:00
EMIT_ARG(yield, MP_EMIT_YIELD_FROM);
py/emitnative: Implement yield and yield-from in native emitter. This commit adds first class support for yield and yield-from in the native emitter, including send and throw support, and yields enclosed in exception handlers (which requires pulling down the NLR stack before yielding, then rebuilding it when resuming). This has been fully tested and is working on unix x86 and x86-64, and stm32. Also basic tests have been done with the esp8266 port. Performance of existing native code is unchanged.
2018-09-30 23:07:04 -04:00
reserve_labels_for_native(comp, 3);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
}
#if MICROPY_PY_ASYNC_AWAIT
compile: Give a proper error on 'async with'/'async for' outside 'async def' A simple reproducer is: async for x in():x
2020-03-01 10:40:43 -05:00
STATIC bool compile_require_async_context(compiler_t *comp, mp_parse_node_struct_t *pns) {
int scope_flags = comp->scope_cur->scope_flags;
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
if ((scope_flags & MP_SCOPE_FLAG_ASYNC) != 0) {
compile: Give a proper error on 'async with'/'async for' outside 'async def' A simple reproducer is: async for x in():x
2020-03-01 10:40:43 -05:00
return true;
}
compile_syntax_error(comp, (mp_parse_node_t)pns,
require async for and async with to actually be in an async def method instead of just a generator
2020-07-22 01:43:15 -04:00
translate("'await', 'async for' or 'async with' outside async function"));
compile: Give a proper error on 'async with'/'async for' outside 'async def' A simple reproducer is: async for x in():x
2020-03-01 10:40:43 -05:00
return false;
}
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
STATIC void compile_await_object_method(compiler_t *comp, qstr method) {
py: Add LOAD_SUPER_METHOD bytecode to allow heap-free super meth calls. This patch allows the following code to run without allocating on the heap: super().foo(...) Before this patch such a call would allocate a super object on the heap and then load the foo method and call it right away. The super object is only needed to perform the lookup of the method and not needed after that. This patch makes an optimisation to allocate the super object on the C stack and discard it right after use. Changes in code size due to this patch are: bare-arm: +128 minimal: +232 unix x64: +416 unix nanbox: +364 stmhal: +184 esp8266: +340 cc3200: +128
2017-04-18 19:45:59 -04:00
EMIT_ARG(load_method, method, false);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
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;
run code formatting script
2021-03-15 09:57:36 -04:00
if (!compile_require_async_context(comp, pns)) {
compile: Give a proper error on 'async with'/'async for' outside 'async def' A simple reproducer is: async for x in():x
2020-03-01 10:40:43 -05:00
return;
}
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
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
py/compile: Don't await __aiter__ special method in async-for. MicroPython's original implementation of __aiter__ was correct for an earlier (provisional) version of PEP492 (CPython 3.5), where __aiter__ was an async-def function. But that changed in the final version of PEP492 (in CPython 3.5.2) where the function was changed to a normal one. See https://www.python.org/dev/peps/pep-0492/#why-aiter-does-not-return-an-awaitable See also the note at the end of this subsection in the docs: https://docs.python.org/3.5/reference/datamodel.html#asynchronous-iterators And for completeness the BPO: https://bugs.python.org/issue27243 To be consistent with the Python spec as it stands today (and now that PEP492 is final) this commit changes MicroPython's behaviour to match CPython: __aiter__ should return an async-iterable object, but is not itself awaitable. The relevant tests are updated to match. See #6267.
2020-07-21 13:47:28 -04:00
EMIT_ARG(load_method, MP_QSTR___aiter__, false);
EMIT_ARG(call_method, 0, 0, 0);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_store_id(comp, context);
START_BREAK_CONTINUE_BLOCK
EMIT_ARG(label_assign, continue_label);
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
compile_increase_except_level(comp, try_exception_label, MP_EMIT_SETUP_BLOCK_EXCEPT);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_load_id(comp, context);
compile_await_object_method(comp, MP_QSTR___anext__);
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
EMIT_ARG(pop_except_jump, try_else_label, false);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
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);
py/compile: Fix async-for/async-with to work with simpler exc on stack. There is now just the exception instance on the stack when an exception is raised, not the full (type, exc, traceback).
2016-09-27 21:52:13 -04:00
EMIT(pop_top); // pop exception instance
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
EMIT_ARG(pop_except_jump, while_else_label, true);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
EMIT_ARG(label_assign, try_finally_label);
py/compile: Fix async-for/async-with to work with simpler exc on stack. There is now just the exception instance on the stack when an exception is raised, not the full (type, exc, traceback).
2016-09-27 21:52:13 -04:00
EMIT_ARG(adjust_stack_size, 1); // if we jump here, the exc is on the stack
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
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, int 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 {
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
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);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
// this pre-bit is of the form "a as b"
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)nodes[0];
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_node(comp, pns->nodes[0]);
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
EMIT(dup_top);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
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]);
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
EMIT(dup_top);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_await_object_method(comp, MP_QSTR___aenter__);
EMIT(pop_top);
}
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// 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.
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// Start the try-finally statement
py/compile: Factor code that compiles start/end of exception handler.
2018-09-04 01:34:51 -04:00
compile_increase_except_level(comp, l_finally_block, MP_EMIT_SETUP_BLOCK_FINALLY);
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// 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
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_async_with_stmt_helper(comp, n - 1, nodes + 1, body);
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
EMIT_ARG(adjust_stack_size, -3);
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
// We have now finished the "try" block and fall through to the "finally"
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// 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)
py/compile: Fix async-for/async-with to work with simpler exc on stack. There is now just the exception instance on the stack when an exception is raised, not the full (type, exc, traceback).
2016-09-27 21:52:13 -04:00
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// 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);
py/compile: Fix async-for/async-with to work with simpler exc on stack. There is now just the exception instance on the stack when an exception is raised, not the full (type, exc, traceback).
2016-09-27 21:52:13 -04:00
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// Detect if TOS an exception or not
EMIT(dup_top);
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
EMIT_LOAD_GLOBAL(MP_QSTR_BaseException);
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
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);
py/compile: Fix async-for/async-with to work with simpler exc on stack. There is now just the exception instance on the stack when an exception is raised, not the full (type, exc, traceback).
2016-09-27 21:52:13 -04:00
EMIT(dup_top);
#if MICROPY_CPYTHON_COMPAT
py/emit: Combine load/store/delete attr into one emit function. Reduces code size by: bare-arm: -20 minimal x86: -140 unix x64: -408 unix nanbox: -140 stm32: -68 cc3200: -16 esp8266: -80 esp32: -32
2018-05-22 07:43:41 -04:00
EMIT_ARG(attr, MP_QSTR___class__, MP_EMIT_ATTR_LOAD); // get type(exc)
py/compile: Fix async-for/async-with to work with simpler exc on stack. There is now just the exception instance on the stack when an exception is raised, not the full (type, exc, traceback).
2016-09-27 21:52:13 -04:00
#else
compile_load_id(comp, MP_QSTR_type);
EMIT(rot_two);
EMIT_ARG(call_function, 1, 0, 0); // get type(exc)
#endif
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
EMIT(rot_two);
py/compile: Fix async-for/async-with to work with simpler exc on stack. There is now just the exception instance on the stack when an exception is raised, not the full (type, exc, traceback).
2016-09-27 21:52:13 -04:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE); // dummy traceback value
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// Stack: (..., exc, __aexit__, ctx_mgr, type(exc), exc, None)
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
EMIT_ARG(call_method, 3, 0, 0);
compile_yield_from(comp);
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
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);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
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);
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
EMIT_ARG(adjust_stack_size, -1);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
py/compile: Handle return/break/continue correctly in async with. Before this patch the context manager's __aexit__() method would not be executed if a return/break/continue statement was used to exit an async with block. async with now has the same semantics as normal with. The fix here applies purely to the compiler, and does not modify the runtime at all. It might (eventually) be better to define new bytecode(s) to handle async with (and maybe other async constructs) in a cleaner, more efficient way. One minor drawback with addressing this issue purely in the compiler is that it wasn't possible to get 100% CPython semantics. The thing that is different here to CPython is that the __aexit__ method is not looked up in the context manager until it is needed, which is after the body of the async with statement has executed. So if a context manager doesn't have __aexit__ then CPython raises an exception before the async with is executed, whereas uPy will raise it after it is executed. Note that __aenter__ is looked up at the beginning in uPy because it needs to be called straightaway, so if the context manager isn't a context manager then it'll still raise an exception at the same location as CPython. The only difference is if the context manager has the __aenter__ method but not the __aexit__ method, then in that case uPy has different behaviour. But this is a very minor, and acceptable, difference.
2018-06-23 08:32:09 -04:00
// 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);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
}
}
STATIC void compile_async_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
run code formatting script
2021-03-15 09:57:36 -04:00
if (!compile_require_async_context(comp, pns)) {
compile: Give a proper error on 'async with'/'async for' outside 'async def' A simple reproducer is: async for x in():x
2020-03-01 10:40:43 -05:00
return;
}
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
// get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
mp_parse_node_t *nodes;
int 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]));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns->nodes[0];
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_funcdef) {
// async def
compile_funcdef(comp, pns0);
run code formatting script
2021-03-15 09:57:36 -04:00
scope_t *fscope = (scope_t *)pns0->nodes[4];
add coroutine behavior for generators coroutines don't have __next__; they also call themselves coroutines. This does not change the fact that `async def` methods are generators, but it does make them behave more like CPython.
2020-07-21 03:01:22 -04:00
fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR | MP_SCOPE_FLAG_ASYNC;
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
} else 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
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Implement REPL.
2013-10-18 14:58:12 -04:00
if (comp->is_repl && comp->scope_cur->kind == SCOPE_MODULE) {
// for REPL, evaluate then print the expression
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_load_id(comp, MP_QSTR___repl_print__);
Implement REPL.
2013-10-18 14:58:12 -04:00
compile_node(comp, pns->nodes[0]);
py, compile: Combine have_star_arg, have_dbl_star_arg into star_flags. Small reduction in ROM, heap and stack usage.
2014-04-09 07:43:17 -04:00
EMIT_ARG(call_function, 1, 0, 0);
Implement REPL.
2013-10-18 14:58:12 -04:00
EMIT(pop_top);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
Implement REPL.
2013-10-18 14:58:12 -04:00
// for non-REPL, evaluate then discard the expression
py: Don't automatically intern strings in parser. This completes non-automatic interning of strings in the parser, so that doc strings don't take up RAM. It complicates the parser and compiler, and bloats stmhal by about 300 bytes. It's complicated because now there are 2 kinds of parse-nodes that can be strings: interned leaves and non-interned structs.
2014-05-25 17:06:06 -04:00
if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !MP_PARSE_NODE_IS_ID(pns->nodes[0]))
py: Parse big-int/float/imag constants directly in parser. Previous to this patch, a big-int, float or imag constant was interned (made into a qstr) and then parsed at runtime to create an object each time it was needed. This is wasteful in RAM and not efficient. Now, these constants are parsed straight away in the parser and turned into objects. This allows constants with large numbers of digits (so addresses issue #1103) and takes us a step closer to #722.
2015-02-07 20:57:40 -05:00
|| MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)) {
Implement REPL.
2013-10-18 14:58:12 -04:00
// 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
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Don't generate unnecessary parse nodes for assignment or kwargs. This patch eliminates the need for a nested parse node for assignments and keyword arguments. It saves a little bit of RAM when parsing.
2015-10-08 09:26:01 -04:00
} else if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int kind = MP_PARSE_NODE_STRUCT_KIND(pns1);
Initial commit.
2013-10-04 14:53:11 -04:00
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
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
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);
py: Reduce code size of compiler by a bit.
2014-02-01 17:18:47 -05:00
EMIT_ARG(binary_op, op);
Initial commit.
2013-10-04 14:53:11 -04:00
c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
} else if (kind == PN_expr_stmt_assign_list) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int rhs = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1) - 1;
py: Don't generate unnecessary parse nodes for assignment or kwargs. This patch eliminates the need for a nested parse node for assignments and keyword arguments. It saves a little bit of RAM when parsing.
2015-10-08 09:26:01 -04:00
compile_node(comp, pns1->nodes[rhs]); // rhs
Initial commit.
2013-10-04 14:53:11 -04:00
// 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);
}
py: Don't generate unnecessary parse nodes for assignment or kwargs. This patch eliminates the need for a nested parse node for assignments and keyword arguments. It saves a little bit of RAM when parsing.
2015-10-08 09:26:01 -04:00
c_assign(comp, pns1->nodes[i], ASSIGN_STORE); // middle store
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
py: Don't generate unnecessary parse nodes for assignment or kwargs. This patch eliminates the need for a nested parse node for assignments and keyword arguments. It saves a little bit of RAM when parsing.
2015-10-08 09:26:01 -04:00
plain_assign:
py/compile: Combine compiler-opt of 2 and 3 tuple-to-tuple assignment. This patch combines the compiler optimisation code for double and triple tuple-to-tuple assignment, taking it from two separate if-blocks to one combined if-block. This can be done because the code for both of these optimisations has a lot in common. Combining them together reduces code size for ports that have the triple-tuple optimisation enabled (and doesn't change code size for ports that have it disabled).
2018-02-03 21:35:21 -05:00
#if MICROPY_COMP_DOUBLE_TUPLE_ASSIGN
if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_testlist_star_expr)
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns->nodes[0];
pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
py/compile: Combine compiler-opt of 2 and 3 tuple-to-tuple assignment. This patch combines the compiler optimisation code for double and triple tuple-to-tuple assignment, taking it from two separate if-blocks to one combined if-block. This can be done because the code for both of these optimisations has a lot in common. Combining them together reduces code size for ports that have the triple-tuple optimisation enabled (and doesn't change code size for ports that have it disabled).
2018-02-03 21:35:21 -05:00
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;
py: implement UNPACK_EX byte code (for: a, *b, c = d)
2014-04-08 12:51:47 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Combine compiler-opt of 2 and 3 tuple-to-tuple assignment. This patch combines the compiler optimisation code for double and triple tuple-to-tuple assignment, taking it from two separate if-blocks to one combined if-block. This can be done because the code for both of these optimisations has a lot in common. Combining them together reduces code size for ports that have the triple-tuple optimisation enabled (and doesn't change code size for ports that have it disabled).
2018-02-03 21:35:21 -05:00
#endif
compile_node(comp, pns->nodes[1]); // rhs
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Don't generate unnecessary parse nodes for assignment or kwargs. This patch eliminates the need for a nested parse node for assignments and keyword arguments. It saves a little bit of RAM when parsing.
2015-10-08 09:26:01 -04:00
} else {
goto plain_assign;
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_test_if_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t *)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_fail = comp_next_label(comp);
uint l_end = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
compile_node(comp, pns->nodes[0]); // success value
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(jump, l_end);
EMIT_ARG(label_assign, l_fail);
py: Simplify stack get/set to become stack adjust in emitters. Can do this now that the stack size calculation is improved.
2014-04-10 13:28:54 -04:00
EMIT_ARG(adjust_stack_size, -1); // adjust stack size
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns_test_if_else->nodes[1]); // failure value
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, l_end);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_lambdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
Initial commit.
2013-10-04 14:53:11 -04:00
// create a new scope for this lambda
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
scope_t *s = scope_new_and_link(comp, SCOPE_LAMBDA, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store the lambda scope so the compiling function (this one) can use it at each pass
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
pns->nodes[2] = (mp_parse_node_t)s;
Initial commit.
2013-10-04 14:53:11 -04:00
}
// get the scope for this lambda
run code formatting script
2021-03-15 09:57:36 -04:00
scope_t *this_scope = (scope_t *)pns->nodes[2];
Initial commit.
2013-10-04 14:53:11 -04:00
py: Implement default and star args for lambdas.
2015-11-17 09:00:14 -05:00
// compile the lambda definition
compile_funcdef_lambdef(comp, this_scope, pns->nodes[0], PN_varargslist);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Combine or_test and and_test compile functions.
2018-06-19 00:10:29 -04:00
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;
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_end = comp_next_label(comp);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
for (int i = 0; i < n; i += 1) {
compile_node(comp, pns->nodes[i]);
if (i + 1 < n) {
py: Combine complie functions for or_test/and_test to reduce code size. Saves around 60 bytes code on Thumb2 archs.
2015-02-28 10:10:18 -05:00
EMIT_ARG(jump_if_or_pop, cond, l_end);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, l_end);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_not_test_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(unary_op, MP_UNARY_OP_NOT);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
bool multi = (num_nodes > 3);
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_fail = 0;
Initial commit.
2013-10-04 14:53:11 -04:00
if (multi) {
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
l_fail = comp_next_label(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
}
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);
}
py: Reduce code size of compiler by a bit.
2014-02-01 17:18:47 -05:00
if (MP_PARSE_NODE_IS_TOKEN(pns->nodes[i])) {
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]);
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
mp_binary_op_t op;
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
if (tok == MP_TOKEN_KW_IN) {
op = MP_BINARY_OP_IN;
} else {
op = MP_BINARY_OP_LESS + (tok - MP_TOKEN_OP_LESS);
py: Reduce code size of compiler by a bit.
2014-02-01 17:18:47 -05:00
}
EMIT_ARG(binary_op, op);
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])); // should be
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[i];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int kind = MP_PARSE_NODE_STRUCT_KIND(pns2);
Initial commit.
2013-10-04 14:53:11 -04:00
if (kind == PN_comp_op_not_in) {
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(binary_op, MP_BINARY_OP_NOT_IN);
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
assert(kind == PN_comp_op_is); // should be
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(binary_op, MP_BINARY_OP_IS);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
EMIT_ARG(binary_op, MP_BINARY_OP_IS_NOT);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
if (i + 2 < num_nodes) {
py: Combine emit functions for jump true/false to reduce code size. Saves 116 bytes for stmhal and 56 bytes for cc3200 port.
2015-02-28 10:04:06 -05:00
EMIT_ARG(jump_if_or_pop, false, l_fail);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
if (multi) {
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint l_end = comp_next_label(comp);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(jump, l_end);
EMIT_ARG(label_assign, l_fail);
py: Simplify stack get/set to become stack adjust in emitters. Can do this now that the stack size calculation is improved.
2014-04-10 13:28:54 -04:00
EMIT_ARG(adjust_stack_size, 1);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(rot_two);
EMIT(pop_top);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(label_assign, l_end);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_star_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("*x must be assignment target"));
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Combine expr, xor_expr and and_expr into one function. This and the previous 4 commits combined have change in code size of: bare-arm: -92 minimal x86: -544 unix x64: -544 unix nanbox: -712 stm32: -116 cc3200: -128 esp8266: -348 esp32: -232
2018-06-19 00:20:42 -04:00
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);
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Combine arith and bit-shift ops into 1 compile routine. This refactoring saves code space.
2017-04-27 15:32:50 -04:00
STATIC void compile_term(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
py/compile: Use switch-case to match token and operator. Reduces code size.
2017-04-27 15:33:11 -04:00
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]);
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
mp_binary_op_t op = MP_BINARY_OP_LSHIFT + (tok - MP_TOKEN_OP_DBL_LESS);
py/compile: Use switch-case to match token and operator. Reduces code size.
2017-04-27 15:33:11 -04:00
EMIT_ARG(binary_op, op);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_factor_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[1]);
py/compile: Use switch-case to match token and operator. Reduces code size.
2017-04-27 15:33:11 -04:00
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
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);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Use switch-case to match token and operator. Reduces code size.
2017-04-27 15:33:11 -04:00
EMIT_ARG(unary_op, op);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
STATIC void compile_atom_expr_normal(compiler_t *comp, mp_parse_node_struct_t *pns) {
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
// compile the subject of the expression
compile_node(comp, pns->nodes[0]);
py: Add built-in super.
2014-02-04 19:51:47 -05:00
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
// compile_atom_expr_await may call us with a NULL node
if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
return;
}
py: Don't allocate an extra parse node for power exponent. Previous to this patch, the "**b" in "a**b" had its own parse node with just one item (the "b"). Now, the "b" is just the last element of the power parse-node. This saves (a tiny bit of) RAM when compiling.
2016-03-16 09:04:51 -04:00
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
// get the array of trailers (known to be an array of PARSE_NODE_STRUCT)
size_t num_trail = 1;
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t **pns_trail = (mp_parse_node_struct_t **)&pns->nodes[1];
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
if (MP_PARSE_NODE_STRUCT_KIND(pns_trail[0]) == PN_atom_expr_trailers) {
num_trail = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_trail[0]);
run code formatting script
2021-03-15 09:57:36 -04:00
pns_trail = (mp_parse_node_struct_t **)&pns_trail[0]->nodes[0];
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
}
py: Add built-in super.
2014-02-04 19:51:47 -05:00
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
// the current index into the array of trailers
size_t i = 0;
Initial commit.
2013-10-04 14:53:11 -04:00
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
// 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
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_load_id(comp, MP_QSTR___class__);
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
py: Remove last uses of printf from compile; use proper SyntaxError.
2014-12-21 12:44:27 -05:00
// look for first argument to function (assumes it's "self")
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
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) {
py/compile: When compiling super(), handle closed-over self variable. The self variable may be closed-over in the function, and in that case the call to super() should load the contents of the closure cell using LOAD_DEREF (before this patch it would just load the cell directly).
2017-03-26 20:27:08 -04:00
if (id->flags & ID_FLAG_IS_PARAM) {
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
// first argument found; load it
py/compile: When compiling super(), handle closed-over self variable. The self variable may be closed-over in the function, and in that case the call to super() should load the contents of the closure cell using LOAD_DEREF (before this patch it would just load the cell directly).
2017-03-26 20:27:08 -04:00
compile_load_id(comp, id->qst);
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
found = true;
break;
py: Add built-in super.
2014-02-04 19:51:47 -05:00
}
}
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
if (!found) {
compile_syntax_error(comp, (mp_parse_node_t)pns_trail[0],
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
translate("super() can't find self")); // really a TypeError
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
return;
}
py: Add LOAD_SUPER_METHOD bytecode to allow heap-free super meth calls. This patch allows the following code to run without allocating on the heap: super().foo(...) Before this patch such a call would allocate a super object on the heap and then load the foo method and call it right away. The super object is only needed to perform the lookup of the method and not needed after that. This patch makes an optimisation to allocate the super object on the C stack and discard it right after use. Changes in code size due to this patch are: bare-arm: +128 minimal: +232 unix x64: +416 unix nanbox: +364 stmhal: +184 esp8266: +340 cc3200: +128
2017-04-18 19:45:59 -04:00
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;
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#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
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
}
// 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];
py: Add LOAD_SUPER_METHOD bytecode to allow heap-free super meth calls. This patch allows the following code to run without allocating on the heap: super().foo(...) Before this patch such a call would allocate a super object on the heap and then load the foo method and call it right away. The super object is only needed to perform the lookup of the method and not needed after that. This patch makes an optimisation to allocate the super object on the C stack and discard it right after use. Changes in code size due to this patch are: bare-arm: +128 minimal: +232 unix x64: +416 unix nanbox: +364 stmhal: +184 esp8266: +340 cc3200: +128
2017-04-18 19:45:59 -04:00
EMIT_ARG(load_method, MP_PARSE_NODE_LEAF_ARG(pns_period->nodes[0]), false);
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
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]);
}
py: Add built-in super.
2014-02-04 19:51:47 -05:00
}
py/compile: Refactor handling of special super() call. This patch refactors the handling of the special super() call within the compiler. It removes the need for a global (to the compiler) state variable which keeps track of whether the subject of an expression is super. The handling of super() is now done entirely within one function, which makes the compiler a bit cleaner and allows to easily add more optimisations to super calls. Changes to the code size are: bare-arm: +12 minimal: +0 unix x64: +48 unix nanbox: -16 stmhal: +4 cc3200: +0 esp8266: -56
2017-04-18 08:52:18 -04:00
}
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
py: Add built-in super.
2014-02-04 19:51:47 -05:00
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
// get the list of arguments
mp_parse_node_t *args;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n_args = mp_parse_node_extract_list(&pn_arglist, PN_arglist, &args);
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
// 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;
py: Fix call args when a stararg is followed by keyword args.
2015-09-17 06:07:06 -04:00
mp_parse_node_struct_t *star_args_node = NULL, *dblstar_args_node = NULL;
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
for (int i = 0; i < n_args; i++) {
if (MP_PARSE_NODE_IS_STRUCT(args[i])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_arg = (mp_parse_node_struct_t *)args[i];
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_star) {
if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns_arg, translate("can't have multiple *x"));
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
return;
}
star_flags |= MP_EMIT_STAR_FLAG_SINGLE;
py: Fix call args when a stararg is followed by keyword args.
2015-09-17 06:07:06 -04:00
star_args_node = pns_arg;
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_dbl_star) {
if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns_arg, translate("can't have multiple **x"));
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
return;
}
star_flags |= MP_EMIT_STAR_FLAG_DOUBLE;
py: Fix call args when a stararg is followed by keyword args.
2015-09-17 06:07:06 -04:00
dblstar_args_node = pns_arg;
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_argument) {
py: Don't generate unnecessary parse nodes for assignment or kwargs. This patch eliminates the need for a nested parse node for assignments and keyword arguments. It saves a little bit of RAM when parsing.
2015-10-08 09:26:01 -04:00
if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns_arg->nodes[1], PN_comp_for)) {
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
if (!MP_PARSE_NODE_IS_ID(pns_arg->nodes[0])) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns_arg, translate("LHS of keyword arg must be an id"));
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
return;
}
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns_arg->nodes[0]));
py: Don't generate unnecessary parse nodes for assignment or kwargs. This patch eliminates the need for a nested parse node for assignments and keyword arguments. It saves a little bit of RAM when parsing.
2015-10-08 09:26:01 -04:00
compile_node(comp, pns_arg->nodes[1]);
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
n_keyword += 1;
} else {
compile_comprehension(comp, pns_arg, SCOPE_GEN_EXPR);
n_positional++;
}
} else {
goto normal_argument;
}
} else {
run code formatting script
2021-03-15 09:57:36 -04:00
normal_argument:
py/compile: Raise SyntaxError if positional args are given after */**. In CPython 3.4 this raises a SyntaxError. In CPython 3.5+ having a positional after * is allowed but uPy has the wrong semantics and passes the arguments in the incorrect order. To prevent incorrect use of a function going unnoticed it is important to raise the SyntaxError in uPy, until the behaviour is fixed to follow CPython 3.5+.
2017-06-14 04:18:01 -04:00
if (star_flags) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, args[i], translate("non-keyword arg after */**"));
py/compile: Raise SyntaxError if positional args are given after */**. In CPython 3.4 this raises a SyntaxError. In CPython 3.5+ having a positional after * is allowed but uPy has the wrong semantics and passes the arguments in the incorrect order. To prevent incorrect use of a function going unnoticed it is important to raise the SyntaxError in uPy, until the behaviour is fixed to follow CPython 3.5+.
2017-06-14 04:18:01 -04:00
return;
}
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
if (n_keyword > 0) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, args[i], translate("non-keyword arg after keyword arg"));
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
return;
}
compile_node(comp, args[i]);
n_positional++;
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Fix call args when a stararg is followed by keyword args.
2015-09-17 06:07:06 -04:00
// compile the star/double-star arguments if we had them
py: Slightly simplify compile and emit of star/double-star arguments. Saves a few bytes of code space and eliminates need for rot_two bytecode (hence saving RAM and execution time, by a tiny bit).
2015-09-23 06:47:01 -04:00
// 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]);
}
py: Fix call args when a stararg is followed by keyword args.
2015-09-17 06:07:06 -04:00
}
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
// emit the function/method call
Initial commit.
2013-10-04 14:53:11 -04:00
if (is_method_call) {
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
EMIT_ARG(call_method, n_positional, n_keyword, star_flags);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: Change the way function arguments are compiled. New way uses slightly less ROM and RAM, should be slightly faster, and, most importantly, allows to catch the error "non-keyword arg following keyword arg". Addresses issue #466.
2014-04-27 11:46:51 -04:00
EMIT_ARG(call_function, n_positional, n_keyword, star_flags);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
// pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t *)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
Initial commit.
2013-10-04 14:53:11 -04:00
// create a new scope for this comprehension
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
scope_t *s = scope_new_and_link(comp, kind, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store the comprehension scope so the compiling function (this one) can use it at each pass
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
pns_comp_for->nodes[3] = (mp_parse_node_t)s;
Initial commit.
2013-10-04 14:53:11 -04:00
}
// get the scope for this comprehension
run code formatting script
2021-03-15 09:57:36 -04:00
scope_t *this_scope = (scope_t *)pns_comp_for->nodes[3];
Initial commit.
2013-10-04 14:53:11 -04:00
// compile the comprehension
close_over_variables_etc(comp, this_scope, 0, 0);
compile_node(comp, pns_comp_for->nodes[1]); // source of the iterator
py/compile: Optimise list/dict/set comprehensions to use stack iter.
2017-02-09 23:39:33 -05:00
if (kind == SCOPE_GEN_EXPR) {
EMIT_ARG(get_iter, false);
}
py, compile: Combine have_star_arg, have_dbl_star_arg into star_flags. Small reduction in ROM, heap and stack usage.
2014-04-09 07:43:17 -04:00
EMIT_ARG(call_function, 1, 0, 0);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_atom_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// an empty tuple
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
c_tuple(comp, MP_PARSE_NODE_NULL, NULL);
py/parse: Optimise away parse node that's just parenthesis around expr. Before this patch, (x+y)*z would be parsed to a tree that contained a redundant identity parse node corresponding to the parenthesis. With this patch such nodes are optimised away, which reduces memory requirements for expressions with parenthesis, and simplifies the compiler because it doesn't need to handle this identity case. A parenthesis parse node is still needed for tuples.
2016-01-07 08:07:52 -05:00
} else {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[0];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(!MP_PARSE_NODE_IS_NULL(pns->nodes[1]));
if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// tuple of one item, with trailing comma
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
c_tuple(comp, pns->nodes[0], NULL);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// tuple of many items
c_tuple(comp, pns->nodes[0], pns2);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
// generator expression
compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
} else {
// tuple with 2 items
goto tuple_with_2_items;
}
} else {
// tuple with 2 items
run code formatting script
2021-03-15 09:57:36 -04:00
tuple_with_2_items:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
c_tuple(comp, MP_PARSE_NODE_NULL, pns);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_atom_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty list
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 0, MP_EMIT_BUILD_LIST);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[0];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT(pns2->nodes[1])) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pns2->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3b) {
Initial commit.
2013-10-04 14:53:11 -04:00
// list of one item, with trailing comma
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_NULL(pns3->nodes[0]));
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns2->nodes[0]);
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 1, MP_EMIT_BUILD_LIST);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3c) {
Initial commit.
2013-10-04 14:53:11 -04:00
// list of many items
compile_node(comp, pns2->nodes[0]);
compile_generic_all_nodes(comp, pns3);
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 1 + MP_PARSE_NODE_STRUCT_NUM_NODES(pns3), MP_EMIT_BUILD_LIST);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_comp_for) {
Initial commit.
2013-10-04 14:53:11 -04:00
// list comprehension
compile_comprehension(comp, pns2, SCOPE_LIST_COMP);
} else {
// list with 2 items
goto list_with_2_items;
}
} else {
// list with 2 items
run code formatting script
2021-03-15 09:57:36 -04:00
list_with_2_items:
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns2->nodes[0]);
compile_node(comp, pns2->nodes[1]);
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 2, MP_EMIT_BUILD_LIST);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// list with 1 item
compile_node(comp, pns->nodes[0]);
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 1, MP_EMIT_BUILD_LIST);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *pns, bool create_map) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t pn = pns->nodes[0];
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// empty dict
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
if (create_map) {
EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
Initial commit.
2013-10-04 14:53:11 -04:00
// dict with one element
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
if (create_map) {
EMIT_ARG(build, 1, MP_EMIT_BUILD_MAP);
}
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn);
EMIT(store_map);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
Initial commit.
2013-10-04 14:53:11 -04:00
// dict/set with multiple elements
// get tail elements (2nd, 3rd, ...)
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *nodes;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n = mp_parse_node_extract_list(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
Initial commit.
2013-10-04 14:53:11 -04:00
// first element sets whether it's a dict or set
bool is_dict;
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
if (!MICROPY_PY_BUILTINS_SET || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// a dictionary
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
if (create_map) {
EMIT_ARG(build, 1 + n, MP_EMIT_BUILD_MAP);
}
Initial commit.
2013-10-04 14:53:11 -04:00
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 (int i = 0; i < n; i++) {
py, unix, stmhal: Allow to compile with -Wshadow. See issue #699.
2015-01-20 06:55:10 -05:00
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);
Initial commit.
2013-10-04 14:53:11 -04:00
if (is_dict) {
if (!is_key_value) {
Always use preprocessor for MICROPY_ERROR_REPORTING This ensures that only the translate("") alternative that will be used is seen after preprocessing. Improves the quality of the Huffman encoding and reduces binary size slightly. Also makes one "enhanced" error message only occur when ERROR_REPORTING_DETAILED: Instead of the word-for-word python3 error message "Type object has no attribute '%q'", the message will be "'type' object has no attribute '%q'". Also reduces binary size. (that's rolled into this commit as it was right next to a change to use the preprocessor for MICROPY_ERROR_REPORTING) Note that the odd semicolon after "value_error:" in parsenum.c is necessary due to a detail of the C grammar, in which a declaration cannot follow a label directly.
2020-11-19 17:18:52 -05:00
#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
run code formatting script
2021-03-15 09:57:36 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("invalid syntax"));
Always use preprocessor for MICROPY_ERROR_REPORTING This ensures that only the translate("") alternative that will be used is seen after preprocessing. Improves the quality of the Huffman encoding and reduces binary size slightly. Also makes one "enhanced" error message only occur when ERROR_REPORTING_DETAILED: Instead of the word-for-word python3 error message "Type object has no attribute '%q'", the message will be "'type' object has no attribute '%q'". Also reduces binary size. (that's rolled into this commit as it was right next to a change to use the preprocessor for MICROPY_ERROR_REPORTING) Note that the odd semicolon after "value_error:" in parsenum.c is necessary due to a detail of the C grammar, in which a declaration cannot follow a label directly.
2020-11-19 17:18:52 -05:00
#else
run code formatting script
2021-03-15 09:57:36 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("expecting key:value for dict"));
Always use preprocessor for MICROPY_ERROR_REPORTING This ensures that only the translate("") alternative that will be used is seen after preprocessing. Improves the quality of the Huffman encoding and reduces binary size slightly. Also makes one "enhanced" error message only occur when ERROR_REPORTING_DETAILED: Instead of the word-for-word python3 error message "Type object has no attribute '%q'", the message will be "'type' object has no attribute '%q'". Also reduces binary size. (that's rolled into this commit as it was right next to a change to use the preprocessor for MICROPY_ERROR_REPORTING) Note that the odd semicolon after "value_error:" in parsenum.c is necessary due to a detail of the C grammar, in which a declaration cannot follow a label directly.
2020-11-19 17:18:52 -05:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
return;
}
EMIT(store_map);
} else {
if (is_key_value) {
Always use preprocessor for MICROPY_ERROR_REPORTING This ensures that only the translate("") alternative that will be used is seen after preprocessing. Improves the quality of the Huffman encoding and reduces binary size slightly. Also makes one "enhanced" error message only occur when ERROR_REPORTING_DETAILED: Instead of the word-for-word python3 error message "Type object has no attribute '%q'", the message will be "'type' object has no attribute '%q'". Also reduces binary size. (that's rolled into this commit as it was right next to a change to use the preprocessor for MICROPY_ERROR_REPORTING) Note that the odd semicolon after "value_error:" in parsenum.c is necessary due to a detail of the C grammar, in which a declaration cannot follow a label directly.
2020-11-19 17:18:52 -05:00
#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
run code formatting script
2021-03-15 09:57:36 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("invalid syntax"));
Always use preprocessor for MICROPY_ERROR_REPORTING This ensures that only the translate("") alternative that will be used is seen after preprocessing. Improves the quality of the Huffman encoding and reduces binary size slightly. Also makes one "enhanced" error message only occur when ERROR_REPORTING_DETAILED: Instead of the word-for-word python3 error message "Type object has no attribute '%q'", the message will be "'type' object has no attribute '%q'". Also reduces binary size. (that's rolled into this commit as it was right next to a change to use the preprocessor for MICROPY_ERROR_REPORTING) Note that the odd semicolon after "value_error:" in parsenum.c is necessary due to a detail of the C grammar, in which a declaration cannot follow a label directly.
2020-11-19 17:18:52 -05:00
#else
run code formatting script
2021-03-15 09:57:36 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("expecting just a value for set"));
Always use preprocessor for MICROPY_ERROR_REPORTING This ensures that only the translate("") alternative that will be used is seen after preprocessing. Improves the quality of the Huffman encoding and reduces binary size slightly. Also makes one "enhanced" error message only occur when ERROR_REPORTING_DETAILED: Instead of the word-for-word python3 error message "Type object has no attribute '%q'", the message will be "'type' object has no attribute '%q'". Also reduces binary size. (that's rolled into this commit as it was right next to a change to use the preprocessor for MICROPY_ERROR_REPORTING) Note that the odd semicolon after "value_error:" in parsenum.c is necessary due to a detail of the C grammar, in which a declaration cannot follow a label directly.
2020-11-19 17:18:52 -05:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
return;
}
}
}
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
#if MICROPY_PY_BUILTINS_SET
Initial commit.
2013-10-04 14:53:11 -04:00
// if it's a set, build it
if (!is_dict) {
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 1 + n, MP_EMIT_BUILD_SET);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
#endif
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
assert(MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for); // should be
Initial commit.
2013-10-04 14:53:11 -04:00
// dict/set comprehension
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
if (!MICROPY_PY_BUILTINS_SET || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// 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
run code formatting script
2021-03-15 09:57:36 -04:00
set_with_one_element:
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
#if MICROPY_PY_BUILTINS_SET
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pn);
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 1, MP_EMIT_BUILD_SET);
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
#else
assert(0);
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
STATIC void compile_atom_brace(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_atom_brace_helper(comp, pns, true);
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_trailer_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
py: Fix compile of class with keyword arguments in bases.
2014-02-06 15:30:16 -05:00
compile_trailer_paren_helper(comp, pns->nodes[0], false, 0);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_trailer_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// object who's index we want is on top of stack
compile_node(comp, pns->nodes[0]); // the index
py/emit: Combine load/store/delete subscr into one emit function. Reduces code size by: bare-arm: -8 minimal x86: -104 unix x64: -312 unix nanbox: -120 stm32: -60 cc3200: -16 esp8266: -92 esp32: -24
2018-05-22 07:31:56 -04:00
EMIT_ARG(subscr, MP_EMIT_SUBSCR_LOAD);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_trailer_period(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// object who's attribute we want is on top of stack
py/emit: Combine load/store/delete attr into one emit function. Reduces code size by: bare-arm: -20 minimal x86: -140 unix x64: -408 unix nanbox: -140 stm32: -68 cc3200: -16 esp8266: -80 esp32: -32
2018-05-22 07:43:41 -04:00
EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]), MP_EMIT_ATTR_LOAD); // attribute to get
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Allow to properly disable builtin slice operation. This patch makes the MICROPY_PY_BUILTINS_SLICE compile-time option fully disable the builtin slice operation (when set to 0). This includes removing the slice sytanx from the grammar. Now, enabling slice costs 4228 bytes on unix x64, and 1816 bytes on stmhal.
2014-12-27 12:20:41 -05:00
#if MICROPY_PY_BUILTINS_SLICE
py/compile: Combine subscript_2 and subscript_3 into one function.
2018-06-18 23:57:55 -04:00
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
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[1];
py/compile: Combine subscript_2 and subscript_3 into one function.
2018-06-18 23:57:55 -04:00
} else {
// pns is a PN_subscript_3, load None for start of slice
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
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)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// [?:]
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
pn = pns->nodes[0];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// [?::]
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// [?::x]
compile_node(comp, pn);
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 3, MP_EMIT_BUILD_SLICE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[1];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Initial commit.
2013-10-04 14:53:11 -04:00
// [?:x:]
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
// [?:x:x]
compile_node(comp, pns->nodes[0]);
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 3, MP_EMIT_BUILD_SLICE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// [?:x]
compile_node(comp, pn);
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
// [?:x]
compile_node(comp, pn);
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Allow to properly disable builtin slice operation. This patch makes the MICROPY_PY_BUILTINS_SLICE compile-time option fully disable the builtin slice operation (when set to 0). This includes removing the slice sytanx from the grammar. Now, enabling slice costs 4228 bytes on unix x64, and 1816 bytes on stmhal.
2014-12-27 12:20:41 -05:00
#endif // MICROPY_PY_BUILTINS_SLICE
Initial commit.
2013-10-04 14:53:11 -04:00
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_dictorsetmaker_item(compiler_t *comp, mp_parse_node_struct_t *pns) {
Initial commit.
2013-10-04 14:53:11 -04:00
// 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
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_classdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
qstr cname = compile_classdef_helper(comp, pns, comp->scope_cur->emit_options);
Initial commit.
2013-10-04 14:53:11 -04:00
// store class object into class name
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, cname);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Make functions static where appropriate.
2014-12-10 17:07:04 -05:00
STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
py, compiler: Allow lambda's to yield.
2014-04-11 09:10:21 -04:00
if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("'yield' outside function"));
Initial commit.
2013-10-04 14:53:11 -04:00
return;
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
py/emit: Combine yield value and yield-from emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -72 unix x64: -200 unix nanbox: -72 stm32: -52 cc3200: -32 esp8266: -84 esp32: -24
2018-05-18 10:30:42 -04:00
EMIT_ARG(yield, MP_EMIT_YIELD_VALUE);
py/emitnative: Implement yield and yield-from in native emitter. This commit adds first class support for yield and yield-from in the native emitter, including send and throw support, and yields enclosed in exception handlers (which requires pulling down the NLR stack before yielding, then rebuilding it when resuming). This has been fully tested and is working on unix x86 and x86-64, and stm32. Also basic tests have been done with the esp8266 port. Performance of existing native code is unchanged.
2018-09-30 23:07:04 -04:00
reserve_labels_for_native(comp, 1);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[0];
#if MICROPY_PY_ASYNC_AWAIT
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
if ((comp->scope_cur->scope_flags & MP_SCOPE_FLAG_ASYNC) != 0) {
async def syntax rigor and __await__ magic method Some examples of improved compliance with CPython that currently have divergent behavior in CircuitPython are listed below: * yield from is not allowed in async methods ``` >>> async def f(): ... yield from 'abc' ... Traceback (most recent call last): File "<stdin>", line 2, in f SyntaxError: 'yield from' inside async function ``` * await only works on awaitable expressions ``` >>> async def f(): ... await 'not awaitable' ... >>> f().send(None) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in f AttributeError: 'str' object has no attribute '__await__' ``` * only __await__()able expressions are awaitable Okay this one actually does not work in circuitpython at all today. This is how CPython works though and pretending __await__ does not exist will only bite users who write both. ``` >>> class c: ... pass ... >>> def f(self): ... yield ... yield ... return 'f to pay respects' ... >>> c.__await__ = f # could just as easily have put it on the class but this shows how it's wired >>> async def g(): ... awaitable_thing = c() ... partial = await awaitable_thing ... return 'press ' + partial ... >>> q = g() >>> q.send(None) >>> q.send(None) >>> q.send(None) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration: press f to pay respects ```
2020-08-05 22:55:40 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("'yield from' inside async function"));
return;
}
run code formatting script
2021-03-15 09:57:36 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns->nodes[0]);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_yield_from(comp);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
compile_node(comp, pns->nodes[0]);
py/emit: Combine yield value and yield-from emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -72 unix x64: -200 unix nanbox: -72 stm32: -52 cc3200: -32 esp8266: -84 esp32: -24
2018-05-18 10:30:42 -04:00
EMIT_ARG(yield, MP_EMIT_YIELD_VALUE);
py/emitnative: Implement yield and yield-from in native emitter. This commit adds first class support for yield and yield-from in the native emitter, including send and throw support, and yields enclosed in exception handlers (which requires pulling down the NLR stack before yielding, then rebuilding it when resuming). This has been fully tested and is working on unix x86 and x86-64, and stm32. Also basic tests have been done with the esp8266 port. Performance of existing native code is unchanged.
2018-09-30 23:07:04 -04:00
reserve_labels_for_native(comp, 1);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
#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) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, (mp_parse_node_t)pns, translate("'await' outside function"));
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
return;
}
require async for and async with to actually be in an async def method instead of just a generator
2020-07-22 01:43:15 -04:00
compile_require_async_context(comp, pns);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
compile_atom_expr_normal(comp, pns);
async def syntax rigor and __await__ magic method Some examples of improved compliance with CPython that currently have divergent behavior in CircuitPython are listed below: * yield from is not allowed in async methods ``` >>> async def f(): ... yield from 'abc' ... Traceback (most recent call last): File "<stdin>", line 2, in f SyntaxError: 'yield from' inside async function ``` * await only works on awaitable expressions ``` >>> async def f(): ... await 'not awaitable' ... >>> f().send(None) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in f AttributeError: 'str' object has no attribute '__await__' ``` * only __await__()able expressions are awaitable Okay this one actually does not work in circuitpython at all today. This is how CPython works though and pretending __await__ does not exist will only bite users who write both. ``` >>> class c: ... pass ... >>> def f(self): ... yield ... yield ... return 'f to pay respects' ... >>> c.__await__ = f # could just as easily have put it on the class but this shows how it's wired >>> async def g(): ... awaitable_thing = c() ... partial = await awaitable_thing ... return 'press ' + partial ... >>> q = g() >>> q.send(None) >>> q.send(None) >>> q.send(None) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration: press f to pay respects ```
2020-08-05 22:55:40 -04:00
update async tests with less upython workaround and more cpython compatibility
2020-10-11 02:39:32 -04:00
// 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.
i do not know if this is needed but this is not the vm i use anymore
2020-10-10 18:30:37 -04:00
EMIT_ARG(load_method, MP_QSTR___await__, false);
EMIT_ARG(call_method, 0, 0, 0);
update async tests with less upython workaround and more cpython compatibility
2020-10-11 02:39:32 -04:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
EMIT_ARG(yield, MP_EMIT_YIELD_FROM);
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
}
#endif
py: Create str/bytes objects in the parser, not the compiler. Previous to this patch any non-interned str/bytes objects would create a special parse node that held a copy of the str/bytes data. Then in the compiler this data would be turned into a str/bytes object. This actually lead to 2 copies of the data, one in the parse node and one in the object. The parse node's copy of the data would be freed at the end of the compile stage but nevertheless it meant that the peak memory usage of the parse/compile stage was higher than it needed to be (by an amount equal to the number of bytes in all the non-interned str/bytes objects). This patch changes the behaviour so that str/bytes objects are created directly in the parser and the object stored in a const-object parse node (which already exists for bignum, float and complex const objects). This reduces peak RAM usage of the parse/compile stage, simplifies the parser and compiler, and reduces code size by about 170 bytes on Thumb2 archs, and by about 300 bytes on Xtensa archs.
2017-02-23 21:43:43 -05:00
STATIC mp_obj_t get_const_object(mp_parse_node_struct_t *pns) {
py: Add support for 64-bit NaN-boxing object model, on 32-bit machine. To use, put the following in mpconfigport.h: #define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_D) #define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_DOUBLE) typedef int64_t mp_int_t; typedef uint64_t mp_uint_t; #define UINT_FMT "%llu" #define INT_FMT "%lld" Currently does not work with native emitter enabled.
2015-11-27 12:09:11 -05:00
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
// nodes are 32-bit pointers, but need to extract 64-bit object
py: Create str/bytes objects in the parser, not the compiler. Previous to this patch any non-interned str/bytes objects would create a special parse node that held a copy of the str/bytes data. Then in the compiler this data would be turned into a str/bytes object. This actually lead to 2 copies of the data, one in the parse node and one in the object. The parse node's copy of the data would be freed at the end of the compile stage but nevertheless it meant that the peak memory usage of the parse/compile stage was higher than it needed to be (by an amount equal to the number of bytes in all the non-interned str/bytes objects). This patch changes the behaviour so that str/bytes objects are created directly in the parser and the object stored in a const-object parse node (which already exists for bignum, float and complex const objects). This reduces peak RAM usage of the parse/compile stage, simplifies the parser and compiler, and reduces code size by about 170 bytes on Thumb2 archs, and by about 300 bytes on Xtensa archs.
2017-02-23 21:43:43 -05:00
return (uint64_t)pns->nodes[0] | ((uint64_t)pns->nodes[1] << 32);
py: Add support for 64-bit NaN-boxing object model, on 32-bit machine. To use, put the following in mpconfigport.h: #define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_D) #define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_DOUBLE) typedef int64_t mp_int_t; typedef uint64_t mp_uint_t; #define UINT_FMT "%llu" #define INT_FMT "%lld" Currently does not work with native emitter enabled.
2015-11-27 12:09:11 -05:00
#else
py: Create str/bytes objects in the parser, not the compiler. Previous to this patch any non-interned str/bytes objects would create a special parse node that held a copy of the str/bytes data. Then in the compiler this data would be turned into a str/bytes object. This actually lead to 2 copies of the data, one in the parse node and one in the object. The parse node's copy of the data would be freed at the end of the compile stage but nevertheless it meant that the peak memory usage of the parse/compile stage was higher than it needed to be (by an amount equal to the number of bytes in all the non-interned str/bytes objects). This patch changes the behaviour so that str/bytes objects are created directly in the parser and the object stored in a const-object parse node (which already exists for bignum, float and complex const objects). This reduces peak RAM usage of the parse/compile stage, simplifies the parser and compiler, and reduces code size by about 170 bytes on Thumb2 archs, and by about 300 bytes on Xtensa archs.
2017-02-23 21:43:43 -05:00
return (mp_obj_t)pns->nodes[0];
py: Add support for 64-bit NaN-boxing object model, on 32-bit machine. To use, put the following in mpconfigport.h: #define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_D) #define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_DOUBLE) typedef int64_t mp_int_t; typedef uint64_t mp_uint_t; #define UINT_FMT "%llu" #define INT_FMT "%lld" Currently does not work with native emitter enabled.
2015-11-27 12:09:11 -05:00
#endif
py: Parse big-int/float/imag constants directly in parser. Previous to this patch, a big-int, float or imag constant was interned (made into a qstr) and then parsed at runtime to create an object each time it was needed. This is wasteful in RAM and not efficient. Now, these constants are parsed straight away in the parser and turned into objects. This allows constants with large numbers of digits (so addresses issue #1103) and takes us a step closer to #722.
2015-02-07 20:57:40 -05:00
}
py: Create str/bytes objects in the parser, not the compiler. Previous to this patch any non-interned str/bytes objects would create a special parse node that held a copy of the str/bytes data. Then in the compiler this data would be turned into a str/bytes object. This actually lead to 2 copies of the data, one in the parse node and one in the object. The parse node's copy of the data would be freed at the end of the compile stage but nevertheless it meant that the peak memory usage of the parse/compile stage was higher than it needed to be (by an amount equal to the number of bytes in all the non-interned str/bytes objects). This patch changes the behaviour so that str/bytes objects are created directly in the parser and the object stored in a const-object parse node (which already exists for bignum, float and complex const objects). This reduces peak RAM usage of the parse/compile stage, simplifies the parser and compiler, and reduces code size by about 170 bytes on Thumb2 archs, and by about 300 bytes on Xtensa archs.
2017-02-23 21:43:43 -05:00
STATIC void compile_const_object(compiler_t *comp, mp_parse_node_struct_t *pns) {
EMIT_ARG(load_const_obj, get_const_object(pns));
}
run code formatting script
2021-03-15 09:57:36 -04:00
typedef void (*compile_function_t)(compiler_t *, mp_parse_node_struct_t *);
py: Declare constant data as properly constant. Otherwise some compilers (eg without optimisation) will put this read-only data in RAM instead of ROM.
2016-05-20 07:38:15 -04:00
STATIC const compile_function_t compile_function[] = {
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
// only define rules with a compile function
Initial commit.
2013-10-04 14:53:11 -04:00
#define c(f) compile_##f
py: Remove name of var arg from macros with var args.
2014-02-26 11:57:08 -05:00
#define DEF_RULE(rule, comp, kind, ...) comp,
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
#define DEF_RULE_NC(rule, kind, ...)
run code formatting script
2021-03-15 09:57:36 -04:00
#include "py/grammar.h"
Initial commit.
2013-10-04 14:53:11 -04:00
#undef c
#undef DEF_RULE
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
#undef DEF_RULE_NC
py: Parse big-int/float/imag constants directly in parser. Previous to this patch, a big-int, float or imag constant was interned (made into a qstr) and then parsed at runtime to create an object each time it was needed. This is wasteful in RAM and not efficient. Now, these constants are parsed straight away in the parser and turned into objects. This allows constants with large numbers of digits (so addresses issue #1103) and takes us a step closer to #722.
2015-02-07 20:57:40 -05:00
compile_const_object,
Initial commit.
2013-10-04 14:53:11 -04:00
};
py: Clean up and simplify functions in scope; add STATIC in compiler. Some small code clean-ups that result in about 80 bytes ROM saving for stmhal.
2014-08-15 09:30:52 -04:00
STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pn)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// pass
parse: Refactor parse node encoding to support full range of small ints. Based on suggestion by @dpgeorge at https://github.com/micropython/micropython/pull/313
2014-02-22 09:39:45 -05:00
} else if (MP_PARSE_NODE_IS_SMALL_INT(pn)) {
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 08:25:24 -04:00
mp_int_t arg = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
py: Add MICROPY_DYNAMIC_COMPILER option to config compiler at runtime. This new compile-time option allows to make the bytecode compiler configurable at runtime by setting the fields in the mp_dynamic_compiler structure. By using this feature, the compiler can generate bytecode that targets any MicroPython runtime/VM, regardless of the host and target compile-time settings. Options so far that fall under this dynamic setting are: - maximum number of bits that a small int can hold; - whether caching of lookups is used in the bytecode; - whether to use unicode strings or not (lexer behaviour differs, and therefore generated string constants differ).
2016-02-11 17:30:53 -05:00
#if MICROPY_DYNAMIC_COMPILER
py/compile: For dynamic compiler, widen literal 1 to get correct shift. Without this patch, on 64-bit architectures the "1 << (small_int_bits - 1)" is computed using only 32-bit values (since small_int_bits is a uint8_t) and so will overflow (and give the wrong result) if small_int_bits is larger than 32.
2018-08-13 09:34:47 -04:00
mp_uint_t sign_mask = -((mp_uint_t)1 << (mp_dynamic_compiler.small_int_bits - 1));
py: Add MICROPY_DYNAMIC_COMPILER option to config compiler at runtime. This new compile-time option allows to make the bytecode compiler configurable at runtime by setting the fields in the mp_dynamic_compiler structure. By using this feature, the compiler can generate bytecode that targets any MicroPython runtime/VM, regardless of the host and target compile-time settings. Options so far that fall under this dynamic setting are: - maximum number of bits that a small int can hold; - whether caching of lookups is used in the bytecode; - whether to use unicode strings or not (lexer behaviour differs, and therefore generated string constants differ).
2016-02-11 17:30:53 -05:00
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
parse: Refactor parse node encoding to support full range of small ints. Based on suggestion by @dpgeorge at https://github.com/micropython/micropython/pull/313
2014-02-22 09:39:45 -05:00
EMIT_ARG(load_const_small_int, arg);
py: Add MICROPY_DYNAMIC_COMPILER option to config compiler at runtime. This new compile-time option allows to make the bytecode compiler configurable at runtime by setting the fields in the mp_dynamic_compiler structure. By using this feature, the compiler can generate bytecode that targets any MicroPython runtime/VM, regardless of the host and target compile-time settings. Options so far that fall under this dynamic setting are: - maximum number of bits that a small int can hold; - whether caching of lookups is used in the bytecode; - whether to use unicode strings or not (lexer behaviour differs, and therefore generated string constants differ).
2016-02-11 17:30:53 -05:00
#endif
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_LEAF(pn)) {
py/compile: Use size_t or uintptr_t instead of mp_uint_t.
2015-12-17 08:13:18 -05:00
uintptr_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
run code formatting script
2021-03-15 09:57:36 -04:00
case MP_PARSE_NODE_ID:
compile_load_id(comp, arg);
break;
case MP_PARSE_NODE_STRING:
EMIT_ARG(load_const_str, arg);
break;
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
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 {
py: Change qstr_* functions to use size_t as the type for str len arg.
2015-11-27 07:23:18 -05:00
size_t len;
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
const byte *data = qstr_data(arg, &len);
EMIT_ARG(load_const_obj, mp_obj_new_bytes(data, len));
}
break;
run code formatting script
2021-03-15 09:57:36 -04:00
case MP_PARSE_NODE_TOKEN:
default:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (arg == MP_TOKEN_NEWLINE) {
Improve indent/dedent error checking and reporting.
2013-10-09 10:09:52 -04:00
// this can occur when file_input lets through a NEWLINE (eg if file starts with a newline)
Implement REPL.
2013-10-18 14:58:12 -04:00
// or when single_input lets through a NEWLINE (user enters a blank line)
Improve indent/dedent error checking and reporting.
2013-10-09 10:09:52 -04:00
// do nothing
} else {
run code formatting script
2021-03-15 09:57:36 -04:00
EMIT_ARG(load_const_tok, arg);
Improve indent/dedent error checking and reporting.
2013-10-09 10:09:52 -04:00
}
break;
Initial commit.
2013-10-04 14:53:11 -04:00
}
} else {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
EMIT_ARG(set_source_line, pns->source_line);
py/grammar: Group no-compile grammar rules together to shrink tables. Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.
2017-02-14 18:58:05 -05:00
assert(MP_PARSE_NODE_STRUCT_KIND(pns) <= PN_const_object);
py: Only allocate strings/bytes once for load_const_obj.
2015-01-14 16:17:27 -05:00
compile_function_t f = compile_function[MP_PARSE_NODE_STRUCT_KIND(pns)];
py/compile: Remove debugging code for compiler dispatch. It was a relic from the days of developing the compiler and is no longer needed, and it's impossible to trigger via a test.
2016-10-11 19:20:48 -04:00
f(comp, pns);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py/compile: Factor code that compiles viper type annotations.
2018-09-14 23:43:49 -04:00
#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) {
Merge MicroPython 1.10 into CircuitPython
2021-04-20 21:04:23 -04:00
comp->compile_error = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, translate("unknown type '%q'"), type_name);
py/compile: Factor code that compiles viper type annotations.
2018-09-14 23:43:49 -04:00
native_type = 0;
}
} else {
Merge MicroPython 1.10 into CircuitPython
2021-04-20 21:04:23 -04:00
compile_syntax_error(comp, pn_annotation, translate("annotation must be an identifier"));
py/compile: Factor code that compiles viper type annotations.
2018-09-14 23:43:49 -04:00
}
return native_type;
}
#endif
py: Allow viper to have type annotations. Viper functions can now be annotated with the type of their arguments and return value. Eg: @micropython.viper def f(x:int) -> int: return x + 1
2014-08-15 11:45:41 -04:00
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) {
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
(void)pn_dbl_star;
py/compile: Do proper checking of * and ** in function definition. This patch checks that there is only one *, and that ** is last in the arg list.
2015-11-23 11:50:42 -05:00
// check that **kw is last
if ((comp->scope_cur->scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("invalid syntax"));
py/compile: Do proper checking of * and ** in function definition. This patch checks that there is only one *, and that ** is last in the arg list.
2015-11-23 11:50:42 -05:00
return;
}
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
qstr param_name = MP_QSTRnull;
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
uint param_flag = ID_FLAG_IS_PARAM;
py/compile: Merge viper annotation and normal param compilation stages. Now that the compiler can store the results of the viper types in the scope, the viper parameter annotation compilation stage can be merged with the normal parameter compilation stage.
2018-09-14 23:20:54 -04:00
mp_parse_node_struct_t *pns = NULL;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_ID(pn)) {
param_name = MP_PARSE_NODE_LEAF_ARG(pn);
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
if (comp->have_star) {
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
// comes after a star, so counts as a keyword-only parameter
comp->scope_cur->num_kwonly_args += 1;
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
// comes before a star, so counts as a positional parameter
comp->scope_cur->num_pos_args += 1;
Initial commit.
2013-10-04 14:53:11 -04:00
}
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
} else {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(pn));
codeformat
2021-04-20 01:22:44 -04:00
pns = (mp_parse_node_struct_t *)pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
py/compile: Merge viper annotation and normal param compilation stages. Now that the compiler can store the results of the viper types in the scope, the viper parameter annotation compilation stage can be merged with the normal parameter compilation stage.
2018-09-14 23:20:54 -04:00
// named parameter with possible annotation
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
if (comp->have_star) {
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
// comes after a star, so counts as a keyword-only parameter
comp->scope_cur->num_kwonly_args += 1;
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
} else {
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
// comes before a star, so counts as a positional parameter
comp->scope_cur->num_pos_args += 1;
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
}
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
py/compile: Do proper checking of * and ** in function definition. This patch checks that there is only one *, and that ** is last in the arg list.
2015-11-23 11:50:42 -05:00
if (comp->have_star) {
// more than one star
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("invalid syntax"));
py/compile: Do proper checking of * and ** in function definition. This patch checks that there is only one *, and that ** is last in the arg list.
2015-11-23 11:50:42 -05:00
return;
}
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
comp->have_star = true;
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
param_flag = ID_FLAG_IS_PARAM | ID_FLAG_IS_STAR_PARAM;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// bare star
// TODO see http://www.python.org/dev/peps/pep-3102/
run code formatting script
2021-03-15 09:57:36 -04:00
// assert(comp->scope_cur->num_dict_params == 0);
py/compile: Merge viper annotation and normal param compilation stages. Now that the compiler can store the results of the viper types in the scope, the viper parameter annotation compilation stage can be merged with the normal parameter compilation stage.
2018-09-14 23:20:54 -04:00
pns = NULL;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
// named star
py: Pass all scope flags through to runtime.
2014-02-15 14:33:11 -05:00
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARARGS;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
py/compile: Merge viper annotation and normal param compilation stages. Now that the compiler can store the results of the viper types in the scope, the viper parameter annotation compilation stage can be merged with the normal parameter compilation stage.
2018-09-14 23:20:54 -04:00
pns = NULL;
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)); // should be
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
// named star with possible annotation
py: Pass all scope flags through to runtime.
2014-02-15 14:33:11 -05:00
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARARGS;
run code formatting script
2021-03-15 09:57:36 -04:00
pns = (mp_parse_node_struct_t *)pns->nodes[0];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Optimise typedargslist_name to not create a node if just an id.
2013-10-05 19:28:28 -04:00
}
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
py/compile: Merge viper annotation and normal param compilation stages. Now that the compiler can store the results of the viper types in the scope, the viper parameter annotation compilation stage can be merged with the normal parameter compilation stage.
2018-09-14 23:20:54 -04:00
// double star with possible annotation
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == pn_dbl_star); // should be
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
param_flag = ID_FLAG_IS_PARAM | ID_FLAG_IS_DBL_STAR_PARAM;
py: Pass all scope flags through to runtime.
2014-02-15 14:33:11 -05:00
comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARKEYWORDS;
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
if (param_name != MP_QSTRnull) {
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
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) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn, translate("name reused for argument"));
Initial commit.
2013-10-04 14:53:11 -04:00
return;
}
id_info->kind = ID_INFO_KIND_LOCAL;
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
id_info->flags = param_flag;
py/compile: Merge viper annotation and normal param compilation stages. Now that the compiler can store the results of the viper types in the scope, the viper parameter annotation compilation stage can be merged with the normal parameter compilation stage.
2018-09-14 23:20:54 -04:00
#if MICROPY_EMIT_NATIVE
if (comp->scope_cur->emit_options == MP_EMIT_OPT_VIPER && pn_name == PN_typedargslist_name && pns != NULL) {
py/compile: Factor code that compiles viper type annotations.
2018-09-14 23:43:49 -04:00
id_info->flags |= compile_viper_type_annotation(comp, pns->nodes[1]) << ID_FLAG_VIPER_TYPE_POS;
py/compile: Merge viper annotation and normal param compilation stages. Now that the compiler can store the results of the viper types in the scope, the viper parameter annotation compilation stage can be merged with the normal parameter compilation stage.
2018-09-14 23:20:54 -04:00
}
#else
(void)pns;
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
STATIC void compile_scope_func_param(compiler_t *comp, mp_parse_node_t pn) {
py: Allow viper to have type annotations. Viper functions can now be annotated with the type of their arguments and return value. Eg: @micropython.viper def f(x:int) -> int: return x + 1
2014-08-15 11:45:41 -04:00
compile_scope_func_lambda_param(comp, pn, PN_typedargslist_name, PN_typedargslist_star, PN_typedargslist_dbl_star);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
STATIC void compile_scope_lambda_param(compiler_t *comp, mp_parse_node_t pn) {
py: Allow viper to have type annotations. Viper functions can now be annotated with the type of their arguments and return value. Eg: @micropython.viper def f(x:int) -> int: return x + 1
2014-08-15 11:45:41 -04:00
compile_scope_func_lambda_param(comp, pn, PN_varargslist_name, PN_varargslist_star, PN_varargslist_dbl_star);
}
py/compile: Simplify compilation of comprehension iterators. Saves 88 bytes on Thumb2, and 200 bytes on x86-64 archs.
2015-12-17 20:37:55 -05:00
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];
run code formatting script
2021-03-15 09:57:36 -04:00
tail_recursion:
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_NULL(pn_iter)) {
Initial commit.
2013-10-04 14:53:11 -04:00
// no more nested if/for; compile inner expression
compile_node(comp, pn_inner_expr);
py: Combine 3 comprehension emit functions (list/dict/set) into 1. The 3 kinds of comprehensions are similar enough that merging their emit functions reduces code size. Decreases in code size in bytes are: bare-arm:24, minimal:96, unix(NDEBUG,x86-64):328, stmhal:80, esp8266:76.
2016-09-18 09:59:47 -04:00
if (comp->scope_cur->kind == SCOPE_GEN_EXPR) {
py/emit: Combine yield value and yield-from emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -72 unix x64: -200 unix nanbox: -72 stm32: -52 cc3200: -32 esp8266: -84 esp32: -24
2018-05-18 10:30:42 -04:00
EMIT_ARG(yield, MP_EMIT_YIELD_VALUE);
py/emitnative: Implement yield and yield-from in native emitter. This commit adds first class support for yield and yield-from in the native emitter, including send and throw support, and yields enclosed in exception handlers (which requires pulling down the NLR stack before yielding, then rebuilding it when resuming). This has been fully tested and is working on unix x86 and x86-64, and stm32. Also basic tests have been done with the esp8266 port. Performance of existing native code is unchanged.
2018-09-30 23:07:04 -04:00
reserve_labels_for_native(comp, 1);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(pop_top);
py: Combine 3 comprehension emit functions (list/dict/set) into 1. The 3 kinds of comprehensions are similar enough that merging their emit functions reduces code size. Decreases in code size in bytes are: bare-arm:24, minimal:96, unix(NDEBUG,x86-64):328, stmhal:80, esp8266:76.
2016-09-18 09:59:47 -04:00
} else {
py: Optimise storage of iterator so it takes only 4 slots on Py stack.
2017-01-16 23:27:37 -05:00
EMIT_ARG(store_comp, comp->scope_cur->kind, 4 * for_depth + 5);
Initial commit.
2013-10-04 14:53:11 -04:00
}
run code formatting script
2021-03-15 09:57:36 -04:00
} else if (MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_iter) == PN_comp_if) {
Initial commit.
2013-10-04 14:53:11 -04:00
// if condition
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_comp_if = (mp_parse_node_struct_t *)pn_iter;
Initial commit.
2013-10-04 14:53:11 -04:00
c_if_cond(comp, pns_comp_if->nodes[0], false, l_top);
pn_iter = pns_comp_if->nodes[1];
goto tail_recursion;
py: Transform assert logic in compiler to save code space. Saves about 250 code bytes for Thumb2 archs.
2015-02-27 09:25:47 -05:00
} else {
run code formatting script
2021-03-15 09:57:36 -04:00
assert(MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_iter) == PN_comp_for); // should be
Initial commit.
2013-10-04 14:53:11 -04:00
// for loop
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_comp_for2 = (mp_parse_node_struct_t *)pn_iter;
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, pns_comp_for2->nodes[1]);
py: Make FOR_ITER opcode pop 1+4 slots from the stack when finished. The extra 4 slots correspond to the iterator object stored on the stack.
2017-01-16 22:32:50 -05:00
EMIT_ARG(get_iter, true);
py/compile: Simplify compilation of comprehension iterators. Saves 88 bytes on Thumb2, and 200 bytes on x86-64 archs.
2015-12-17 20:37:55 -05:00
compile_scope_comp_iter(comp, pns_comp_for2, pn_inner_expr, for_depth + 1);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Simplify compilation of comprehension iterators. Saves 88 bytes on Thumb2, and 200 bytes on x86-64 archs.
2015-12-17 20:37:55 -05:00
EMIT_ARG(jump, l_top);
EMIT_ARG(label_assign, l_end);
py: Remove unused "use_stack" argument from for_iter_end emit function.
2017-01-16 23:30:18 -05:00
EMIT(for_iter_end);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Add MICROPY_ENABLE_DOC_STRING, disabled by default. Also add a few STATIC's to some compile functions that should have them. Addresses issue #521.
2014-04-25 18:52:57 -04:00
STATIC void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
run code formatting script
2021-03-15 09:57:36 -04:00
#if MICROPY_ENABLE_DOC_STRING
Initial commit.
2013-10-04 14:53:11 -04:00
// see http://www.python.org/dev/peps/pep-0257/
// look for the first statement
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// a statement; fall through
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// file input; find the first non-newline node
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
for (int i = 0; i < num_nodes; i++) {
pn = pns->nodes[i];
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
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)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// 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
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
py: fix bug with doc string not recognised after first newline of file.
2013-12-12 10:24:38 -05:00
// a list of statements; get the first one
run code formatting script
2021-03-15 09:57:36 -04:00
pn = ((mp_parse_node_struct_t *)pn)->nodes[0];
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
return;
}
// check the first statement for a doc string
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
py: Don't automatically intern strings in parser. This completes non-automatic interning of strings in the parser, so that doc strings don't take up RAM. It complicates the parser and compiler, and bloats stmhal by about 300 bytes. It's complicated because now there are 2 kinds of parse-nodes that can be strings: interned leaves and non-interned structs.
2014-05-25 17:06:06 -04:00
if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0])
run code formatting script
2021-03-15 09:57:36 -04:00
&& MP_PARSE_NODE_LEAF_KIND(pns->nodes[0]) == MP_PARSE_NODE_STRING)
py: Create str/bytes objects in the parser, not the compiler. Previous to this patch any non-interned str/bytes objects would create a special parse node that held a copy of the str/bytes data. Then in the compiler this data would be turned into a str/bytes object. This actually lead to 2 copies of the data, one in the parse node and one in the object. The parse node's copy of the data would be freed at the end of the compile stage but nevertheless it meant that the peak memory usage of the parse/compile stage was higher than it needed to be (by an amount equal to the number of bytes in all the non-interned str/bytes objects). This patch changes the behaviour so that str/bytes objects are created directly in the parser and the object stored in a const-object parse node (which already exists for bignum, float and complex const objects). This reduces peak RAM usage of the parse/compile stage, simplifies the parser and compiler, and reduces code size by about 170 bytes on Thumb2 archs, and by about 300 bytes on Xtensa archs.
2017-02-23 21:43:43 -05:00
|| (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
&& mp_obj_is_str(get_const_object((mp_parse_node_struct_t *)pns->nodes[0])))) {
run code formatting script
2021-03-15 09:57:36 -04:00
// compile the doc string
compile_node(comp, pns->nodes[0]);
// store the doc string
compile_store_id(comp, MP_QSTR___doc__);
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
run code formatting script
2021-03-15 09:57:36 -04:00
#else
py, unix: Allow to compile with -Wunused-parameter. See issue #699.
2015-01-20 07:47:20 -05:00
(void)comp;
(void)pn;
run code formatting script
2021-03-15 09:57:36 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Add MICROPY_ENABLE_DOC_STRING, disabled by default. Also add a few STATIC's to some compile functions that should have them. Addresses issue #521.
2014-04-25 18:52:57 -04:00
STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
Initial commit.
2013-10-04 14:53:11 -04:00
comp->pass = pass;
comp->scope_cur = scope;
py/compile: Optimise emitter label indices to save a word of heap. Previous to this patch, a label with value "0" was used to indicate an invalid label, but that meant a wasted word (at slot 0) in the array of label offsets. This patch adjusts the label indices so the first one starts at 0, and the maximum value indicates an invalid label.
2017-06-22 01:05:58 -04:00
comp->next_label = 0;
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(start_pass, pass, scope);
py: Make viper functions have the same entry signature as native. This commit makes viper functions have the same signature as native functions, at the level of the emitter/assembler. This means that viper functions can now be wrapped in the same uPy object as native functions. Viper functions are now responsible for parsing their arguments (before it was done by the runtime), and this makes calling them more efficient (in most cases) because the viper entry code can be custom generated to suit the signature of the function. This change also opens the way forward for viper functions to take arbitrary numbers of arguments, and for them to handle globals correctly, among other things.
2018-09-14 03:40:59 -04:00
reserve_labels_for_native(comp, 6); // used by native's start_pass
Initial commit.
2013-10-04 14:53:11 -04:00
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
// reset maximum stack sizes in scope
// they will be computed in this first pass
Initial commit.
2013-10-04 14:53:11 -04:00
scope->stack_size = 0;
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
scope->exc_stack_size = 0;
Initial commit.
2013-10-04 14:53:11 -04:00
}
// compile
Implement eval.
2014-01-15 17:14:03 -05:00
if (MP_PARSE_NODE_IS_STRUCT_KIND(scope->pn, PN_eval_input)) {
assert(scope->kind == SCOPE_MODULE);
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
Implement eval.
2014-01-15 17:14:03 -05:00
compile_node(comp, pns->nodes[0]); // compile the expression
EMIT(return_value);
} else if (scope->kind == SCOPE_MODULE) {
Implement REPL.
2013-10-18 14:58:12 -04:00
if (!comp->is_repl) {
check_for_doc_string(comp, scope->pn);
}
Initial commit.
2013-10-04 14:53:11 -04:00
compile_node(comp, scope->pn);
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(return_value);
} else if (scope->kind == SCOPE_FUNCTION) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
Initial commit.
2013-10-04 14:53:11 -04:00
// work out number of parameters, keywords and default parameters, and add them to the id_info array
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
comp->have_star = false;
Initial commit.
2013-10-04 14:53:11 -04:00
apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_scope_func_param);
py/compile: Factor code that compiles viper type annotations.
2018-09-14 23:43:49 -04:00
#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;
py: Allow viper to have type annotations. Viper functions can now be annotated with the type of their arguments and return value. Eg: @micropython.viper def f(x:int) -> int: return x + 1
2014-08-15 11:45:41 -04:00
}
py/compile: Factor code that compiles viper type annotations.
2018-09-14 23:43:49 -04:00
#endif // MICROPY_EMIT_NATIVE
Initial commit.
2013-10-04 14:53:11 -04:00
}
compile_node(comp, pns->nodes[3]); // 3 is function body
// emit return if it wasn't the last opcode
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
if (!EMIT(last_emit_was_return_value)) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(return_value);
}
} else if (scope->kind == SCOPE_LAMBDA) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
Initial commit.
2013-10-04 14:53:11 -04:00
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
// Set the source line number for the start of the lambda
EMIT_ARG(set_source_line, pns->source_line);
Initial commit.
2013-10-04 14:53:11 -04:00
// work out number of parameters, keywords and default parameters, and add them to the id_info array
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
py, compiler: Fix compiling of keyword args following named star.
2014-04-11 18:25:34 -04:00
comp->have_star = false;
Initial commit.
2013-10-04 14:53:11 -04:00
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
py, compiler: Allow lambda's to yield.
2014-04-11 09:10:21 -04:00
// 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);
}
Initial commit.
2013-10-04 14:53:11 -04:00
EMIT(return_value);
} else if (scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
// a bit of a hack at the moment
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t *)pns->nodes[1];
Initial commit.
2013-10-04 14:53:11 -04:00
py: Add '*' qstr for 'import *'; use blank qstr for comprehension arg.
2014-04-27 14:23:46 -04:00
// 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_;
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
scope_find_or_add_id(comp->scope_cur, qstr_arg, ID_INFO_KIND_LOCAL);
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
scope->num_pos_args = 1;
Initial commit.
2013-10-04 14:53:11 -04:00
}
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
// Set the source line number for the start of the comprehension
EMIT_ARG(set_source_line, pns->source_line);
Initial commit.
2013-10-04 14:53:11 -04:00
if (scope->kind == SCOPE_LIST_COMP) {
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 0, MP_EMIT_BUILD_LIST);
Initial commit.
2013-10-04 14:53:11 -04:00
} else if (scope->kind == SCOPE_DICT_COMP) {
py/emit: Combine build tuple/list/map emit funcs into one. Reduces code size by: bare-arm: -24 minimal x86: -192 unix x64: -288 unix nanbox: -184 stm32: -72 cc3200: -16 esp8266: -148 esp32: -32
2018-05-18 10:41:40 -04:00
EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
#if MICROPY_PY_BUILTINS_SET
Initial commit.
2013-10-04 14:53:11 -04:00
} else if (scope->kind == SCOPE_SET_COMP) {
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
EMIT_ARG(build, 0, MP_EMIT_BUILD_SET);
py: Allow to properly disable builtin "set" object. This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully disable the builtin set object (when set to 0). This includes removing set constructor/comprehension from the grammar, the compiler and the emitters. Now, enabling set costs 8168 bytes on unix x64, and 3576 bytes on stmhal.
2014-12-27 12:07:16 -05:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Optimise storage of iterator so it takes only 4 slots on Py stack.
2017-01-16 23:27:37 -05:00
// 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.
py/compile: Optimise list/dict/set comprehensions to use stack iter.
2017-02-09 23:39:33 -05:00
if (scope->kind == SCOPE_GEN_EXPR) {
py/compile: Change comment about ITER_BUF_NSLOTS to a static assertion.
2018-05-17 23:11:02 -04:00
MP_STATIC_ASSERT(MP_OBJ_ITER_BUF_NSLOTS == 4);
py/compile: Optimise list/dict/set comprehensions to use stack iter.
2017-02-09 23:39:33 -05:00
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);
}
py: Make FOR_ITER opcode pop 1+4 slots from the stack when finished. The extra 4 slots correspond to the iterator object stored on the stack.
2017-01-16 22:32:50 -05:00
py/compile: Simplify compilation of comprehension iterators. Saves 88 bytes on Thumb2, and 200 bytes on x86-64 archs.
2015-12-17 20:37:55 -05:00
compile_scope_comp_iter(comp, pns_comp_for, pns->nodes[0], 0);
Initial commit.
2013-10-04 14:53:11 -04:00
if (scope->kind == SCOPE_GEN_EXPR) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
}
EMIT(return_value);
} else {
assert(scope->kind == SCOPE_CLASS);
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
Initial commit.
2013-10-04 14:53:11 -04:00
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_SCOPE) {
py/scope: Optimise scope_find_or_add_id to not need "added" arg. Taking the address of a local variable is mildly expensive, in code size and stack usage. So optimise scope_find_or_add_id() to not need to take a pointer to the "added" variable, and instead take the kind to use for newly added identifiers.
2018-10-27 07:41:21 -04:00
scope_find_or_add_id(scope, MP_QSTR___class__, ID_INFO_KIND_LOCAL);
Initial commit.
2013-10-04 14:53:11 -04:00
}
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
#if MICROPY_PY_SYS_SETTRACE
EMIT_ARG(set_source_line, pns->source_line);
#endif
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_load_id(comp, MP_QSTR___name__);
compile_store_id(comp, MP_QSTR___module__);
py: Remove mp_load_const_bytes and instead load precreated bytes object. Previous to this patch each time a bytes object was referenced a new instance (with the same data) was created. With this patch a single bytes object is created in the compiler and is loaded directly at execute time as a true constant (similar to loading bignum and float objects). This saves on allocating RAM and means that bytes objects can now be used when the memory manager is locked (eg in interrupts). The MP_BC_LOAD_CONST_BYTES bytecode was removed as part of this. Generated bytecode is slightly larger due to storing a pointer to the bytes object instead of the qstr identifier. Code size is reduced by about 60 bytes on Thumb2 architectures.
2015-06-25 10:42:13 -04:00
EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
compile_store_id(comp, MP_QSTR___qualname__);
Initial commit.
2013-10-04 14:53:11 -04:00
check_for_doc_string(comp, pns->nodes[2]);
compile_node(comp, pns->nodes[2]); // 2 is class body
Split qstr into pools, and put initial pool in ROM. Qstr's are now split into a linked-list of qstr pools. This has 2 benefits: the first pool can be in ROM (huge benefit, since we no longer use RAM for the core qstrs), and subsequent pools use m_new for the next pool instead of m_renew (thus avoiding a huge single table for all the qstrs). Still would be better to use a hash table, but this scheme takes us part of the way (eventually convert the pools to hash tables). Also fixed bug with import. Also improved the way the module code is referenced (not magic number 1 anymore).
2014-01-04 10:57:35 -05:00
id_info_t *id = scope_find(scope, MP_QSTR___class__);
Initial commit.
2013-10-04 14:53:11 -04:00
assert(id != NULL);
if (id->kind == ID_INFO_KIND_LOCAL) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Initial commit.
2013-10-04 14:53:11 -04:00
} else {
py, compiler: Refactor load/store/delete_id logic to reduce code size. Saves around 230 bytes on Thumb2 and 750 bytes on x86.
2015-03-26 10:42:40 -04:00
EMIT_LOAD_FAST(MP_QSTR___class__, id->local_num);
Initial commit.
2013-10-04 14:53:11 -04:00
}
EMIT(return_value);
}
Restructure emit so it goes through a method table.
2013-10-05 07:19:06 -04:00
EMIT(end_pass);
py: Calculate maximum exception stack size in compiler.
2014-03-27 06:55:21 -04:00
// make sure we match all the exception levels
assert(comp->cur_except_level == 0);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#if MICROPY_EMIT_INLINE_ASM
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
// requires 3 passes: SCOPE, CODE_SIZE, EMIT
py: Add MICROPY_ENABLE_DOC_STRING, disabled by default. Also add a few STATIC's to some compile functions that should have them. Addresses issue #521.
2014-04-25 18:52:57 -04:00
STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
comp->pass = pass;
comp->scope_cur = scope;
py/compile: Optimise emitter label indices to save a word of heap. Previous to this patch, a label with value "0" was used to indicate an invalid label, but that meant a wasted word (at slot 0) in the array of label offsets. This patch adjusts the label indices so the first one starts at 0, and the maximum value indicates an invalid label.
2017-06-22 01:05:58 -04:00
comp->next_label = 0;
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
if (scope->kind != SCOPE_FUNCTION) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, MP_PARSE_NODE_NULL, translate("inline assembler must be a function"));
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
return;
}
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass > MP_PASS_SCOPE) {
py/emitinline: Move common code for end of final pass to compiler. This patch moves some common code from the individual inline assemblers to the compiler, the code that calls the emit-glue to assign the machine code to the functions scope.
2016-12-09 05:23:17 -05:00
EMIT_INLINE_ASM_ARG(start_pass, comp->pass, &comp->compile_error);
Almost supports arguments for inline asm functions.
2013-10-05 19:14:13 -04:00
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// get the function definition parse node
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
run code formatting script
2021-03-15 09:57:36 -04:00
// qstr f_id = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
Almost supports arguments for inline asm functions.
2013-10-05 19:14:13 -04:00
// parameters are in pns->nodes[1]
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass == MP_PASS_CODE_SIZE) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *pn_params;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n_params = mp_parse_node_extract_list(&pns->nodes[1], PN_typedargslist, &pn_params);
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
scope->num_pos_args = EMIT_INLINE_ASM_ARG(count_params, n_params, pn_params);
py: Make inline assembler raise proper SyntaxError exception on error. Also gives line number of location of error. Very useful!
2015-02-12 20:00:51 -05:00
if (comp->compile_error != MP_OBJ_NULL) {
goto inline_asm_error;
}
Almost supports arguments for inline asm functions.
2013-10-05 19:14:13 -04:00
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
py/inlineasm: Add ability to specify return type of asm_thumb funcs. Supported return types are: object, bool, int, uint. For example: @micropython.asm_thumb def foo(r0, r1) -> uint: add(r0, r0, r1)
2016-01-15 10:20:43 -05:00
// 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) {
run code formatting script
2021-03-15 09:57:36 -04:00
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, translate("unknown type"));
return;
py/inlineasm: Add ability to specify return type of asm_thumb funcs. Supported return types are: object, bool, int, uint. For example: @micropython.asm_thumb def foo(r0, r1) -> uint: add(r0, r0, r1)
2016-01-15 10:20:43 -05:00
}
} else {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, pn_annotation, translate("return annotation must be an identifier"));
py/inlineasm: Add ability to specify return type of asm_thumb funcs. Supported return types are: object, bool, int, uint. For example: @micropython.asm_thumb def foo(r0, r1) -> uint: add(r0, r0, r1)
2016-01-15 10:20:43 -05:00
}
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t pn_body = pns->nodes[3]; // body
mp_parse_node_t *nodes;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int num = mp_parse_node_extract_list(&pn_body, PN_suite_block_stmts, &nodes);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
for (int i = 0; i < num; i++) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(nodes[i]));
run code formatting script
2021-03-15 09:57:36 -04:00
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)nodes[i];
py: Improve inline assembler; improve compiler constant folding.
2014-04-12 12:54:52 -04:00
if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_pass_stmt) {
// no instructions
continue;
py: More robust checking in inline assembler compiler.
2015-02-16 12:46:28 -05:00
} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_expr_stmt) {
py: Improve inline assembler; improve compiler constant folding.
2014-04-12 12:54:52 -04:00
// not an instruction; error
py: More robust checking in inline assembler compiler.
2015-02-16 12:46:28 -05:00
not_an_instruction:
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, nodes[i], translate("expecting an assembler instruction"));
py: Improve inline assembler; improve compiler constant folding.
2014-04-12 12:54:52 -04:00
return;
}
py: More robust checking in inline assembler compiler.
2015-02-16 12:46:28 -05:00
// check structure of parse node
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
assert(MP_PARSE_NODE_IS_STRUCT(pns2->nodes[0]));
py: More robust checking in inline assembler compiler.
2015-02-16 12:46:28 -05:00
if (!MP_PARSE_NODE_IS_NULL(pns2->nodes[1])) {
goto not_an_instruction;
}
run code formatting script
2021-03-15 09:57:36 -04:00
pns2 = (mp_parse_node_struct_t *)pns2->nodes[0];
py: add async/await/async for/async with syntax They are sugar for marking function as generator, "yield from" and pep492 python "semantically equivalents" respectively. @dpgeorge was the original author of this patch, but @pohmelie made changes to implement `async for` and `async with`.
2016-01-27 15:23:11 -05:00
if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_atom_expr_normal) {
py: More robust checking in inline assembler compiler.
2015-02-16 12:46:28 -05:00
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
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
qstr op = MP_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
run code formatting script
2021-03-15 09:57:36 -04:00
pns2 = (mp_parse_node_struct_t *)pns2->nodes[1]; // PN_trailer_paren
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
mp_parse_node_t *pn_arg;
py: Expose compile.c:list_get as mp_parse_node_extract_list.
2015-02-12 21:29:46 -05:00
int n_args = mp_parse_node_extract_list(&pns2->nodes[0], PN_arglist, &pn_arg);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// emit instructions
py: Add 'align' and 'data' meta-instructions to inline assembler.
2014-04-21 08:33:15 -04:00
if (op == MP_QSTR_label) {
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
if (!(n_args == 1 && MP_PARSE_NODE_IS_ID(pn_arg[0]))) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, nodes[i], translate("'label' requires 1 argument"));
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
return;
}
py: Make labels unsigned ints (converted from int). Labels should never be negative, and this modified type signature reflects that.
2014-04-10 09:11:31 -04:00
uint lab = comp_next_label(comp);
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (pass > MP_PASS_SCOPE) {
py: Give error for duplicate label in inline assembler.
2015-03-03 12:08:02 -05:00
if (!EMIT_INLINE_ASM_ARG(label, lab, MP_PARSE_NODE_LEAF_ARG(pn_arg[0]))) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, nodes[i], translate("label redefined"));
py: Give error for duplicate label in inline assembler.
2015-03-03 12:08:02 -05:00
return;
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
py: Add 'align' and 'data' meta-instructions to inline assembler.
2014-04-21 08:33:15 -04:00
} else if (op == MP_QSTR_align) {
if (!(n_args == 1 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, nodes[i], translate("'align' requires 1 argument"));
py: Add 'align' and 'data' meta-instructions to inline assembler.
2014-04-21 08:33:15 -04:00
return;
}
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (pass > MP_PASS_SCOPE) {
run code formatting script
2021-03-15 09:57:36 -04:00
mp_asm_base_align((mp_asm_base_t *)comp->emit_inline_asm,
py/emitinline: Move inline-asm align and data methods to compiler. These are generic methods that don't depend on the architecture and so can be handled directly by the compiler.
2016-12-09 04:54:54 -05:00
MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]));
py: Add 'align' and 'data' meta-instructions to inline assembler.
2014-04-21 08:33:15 -04:00
}
} else if (op == MP_QSTR_data) {
if (!(n_args >= 2 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, nodes[i], translate("'data' requires at least 2 arguments"));
py: Add 'align' and 'data' meta-instructions to inline assembler.
2014-04-21 08:33:15 -04:00
return;
}
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (pass > MP_PASS_SCOPE) {
Rename machine_(u)int_t to mp_(u)int_t. See discussion in issue #50.
2014-07-03 08:25:24 -04:00
mp_int_t bytesize = MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]);
Allow boards to enable the `micropython.native` decorator Adds the `CIRCUITPY_ENABLE_MPY_NATIVE` for `mpconfigboard.mk` that enables the `micropython.native` decorator.
2019-10-29 13:11:19 -04:00
for (int j = 1; j < n_args; j++) {
py, unix, stmhal: Allow to compile with -Wshadow. See issue #699.
2015-01-20 06:55:10 -05:00
if (!MP_PARSE_NODE_IS_SMALL_INT(pn_arg[j])) {
Two fixes and translate more strings. * Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.
2018-08-08 21:24:49 -04:00
compile_syntax_error(comp, nodes[i], translate("'data' requires integer arguments"));
py: Add 'align' and 'data' meta-instructions to inline assembler.
2014-04-21 08:33:15 -04:00
return;
}
run code formatting script
2021-03-15 09:57:36 -04:00
mp_asm_base_data((mp_asm_base_t *)comp->emit_inline_asm,
py/emitinline: Move inline-asm align and data methods to compiler. These are generic methods that don't depend on the architecture and so can be handled directly by the compiler.
2016-12-09 04:54:54 -05:00
bytesize, MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[j]));
py: Add 'align' and 'data' meta-instructions to inline assembler.
2014-04-21 08:33:15 -04:00
}
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
} else {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (pass > MP_PASS_SCOPE) {
py: Use C99 way of variable macro arguments. Addresses Issue #207.
2014-01-22 19:34:21 -05:00
EMIT_INLINE_ASM_ARG(op, op, n_args, pn_arg);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
}
py: Make inline assembler raise proper SyntaxError exception on error. Also gives line number of location of error. Very useful!
2015-02-12 20:00:51 -05:00
if (comp->compile_error != MP_OBJ_NULL) {
pns = pns2; // this is the parse node that had the error
goto inline_asm_error;
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
if (comp->pass > MP_PASS_SCOPE) {
py/inlineasm: Add ability to specify return type of asm_thumb funcs. Supported return types are: object, bool, int, uint. For example: @micropython.asm_thumb def foo(r0, r1) -> uint: add(r0, r0, r1)
2016-01-15 10:20:43 -05:00
EMIT_INLINE_ASM_ARG(end_pass, type_sig);
py/emitinline: Move common code for end of final pass to compiler. This patch moves some common code from the individual inline assemblers to the compiler, the code that calls the emit-glue to assign the machine code to the functions scope.
2016-12-09 05:23:17 -05:00
if (comp->pass == MP_PASS_EMIT) {
run code formatting script
2021-03-15 09:57:36 -04:00
void *f = mp_asm_base_get_code((mp_asm_base_t *)comp->emit_inline_asm);
py/emitinline: Move common code for end of final pass to compiler. This patch moves some common code from the individual inline assemblers to the compiler, the code that calls the emit-glue to assign the machine code to the functions scope.
2016-12-09 05:23:17 -05:00
mp_emit_glue_assign_native(comp->scope_cur->raw_code, MP_CODE_NATIVE_ASM,
run code formatting script
2021-03-15 09:57:36 -04:00
f, mp_asm_base_get_code_size((mp_asm_base_t *)comp->emit_inline_asm),
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
NULL,
#if MICROPY_PERSISTENT_CODE_SAVE
0, 0, 0, 0, NULL,
#endif
comp->scope_cur->num_pos_args, 0, type_sig);
py/emitinline: Move common code for end of final pass to compiler. This patch moves some common code from the individual inline assemblers to the compiler, the code that calls the emit-glue to assign the machine code to the functions scope.
2016-12-09 05:23:17 -05:00
}
py: Make inline assembler raise proper SyntaxError exception on error. Also gives line number of location of error. Very useful!
2015-02-12 20:00:51 -05:00
}
if (comp->compile_error != MP_OBJ_NULL) {
py/compile: Give more precise line number for compile errors. Previous to this patch there were some cases where line numbers for errors were 0 (unknown). Now the compiler attempts to give a better line number where possible, in some cases giving the line number of the closest statement, and other cases the line number of the inner-most scope of the error (eg the line number of the start of the function). This helps to give good (and sometimes exact) line numbers for ViperTypeError exceptions. This patch also makes sure that the first compile error (eg SyntaxError) that is encountered is reported (previously it was the last one that was reported).
2015-07-29 18:16:01 -04:00
// inline assembler had an error; set line for its exception
py: Make inline assembler raise proper SyntaxError exception on error. Also gives line number of location of error. Very useful!
2015-02-12 20:00:51 -05:00
inline_asm_error:
py/compile: Give more precise line number for compile errors. Previous to this patch there were some cases where line numbers for errors were 0 (unknown). Now the compiler attempts to give a better line number where possible, in some cases giving the line number of the closest statement, and other cases the line number of the inner-most scope of the error (eg the line number of the start of the function). This helps to give good (and sometimes exact) line numbers for ViperTypeError exceptions. This patch also makes sure that the first compile error (eg SyntaxError) that is encountered is reported (previously it was the last one that was reported).
2015-07-29 18:16:01 -04:00
comp->compile_error_line = pns->source_line;
Further factorise PASS_1 out of specific emit code.
2013-10-05 08:37:10 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py: Wrap compile_scope_inline_asm in #if; remove comment from misc.h.
2014-04-02 12:31:27 -04:00
#endif
Initial commit.
2013-10-04 14:53:11 -04:00
py, unix: Allow to compile with -Wunused-parameter. See issue #699.
2015-01-20 07:47:20 -05:00
STATIC void scope_compute_things(scope_t *scope) {
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython we put the *x parameter after all other parameters (except **y)
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
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
run code formatting script
2021-03-15 09:57:36 -04:00
id_info_t temp = *id_param;
*id_param = *id;
*id = temp;
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
}
break;
} else if (id_param == NULL && id->flags == ID_FLAG_IS_PARAM) {
id_param = id;
}
}
}
Initial commit.
2013-10-04 14:53:11 -04:00
// in functions, turn implicit globals into explicit globals
py: make closures work.
2013-12-30 17:32:17 -05:00
// compute the index of each local
Initial commit.
2013-10-04 14:53:11 -04:00
scope->num_locals = 0;
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
py: Convert [u]int to mp_[u]int_t in emit.h and associated .c files. Towards resolving issue #50.
2014-09-08 18:05:16 -04:00
if (scope->kind == SCOPE_CLASS && id->qst == MP_QSTR___class__) {
Initial commit.
2013-10-04 14:53:11 -04:00
// __class__ is not counted as a local; if it's used then it becomes a ID_INFO_KIND_CELL
continue;
}
py/scope: Use lookup-table to determine a scope's simple name. Generates slightly smaller and more efficient code.
2016-09-29 22:34:05 -04:00
if (SCOPE_IS_FUNC_LIKE(scope->kind) && id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
Initial commit.
2013-10-04 14:53:11 -04:00
id->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
}
py: Fix native functions so they run with their correct globals context. Prior to this commit a function compiled with the native decorator @micropython.native would not work correctly when accessing global variables, because the globals dict was not being set upon function entry. This commit fixes this problem by, upon function entry, setting as the current globals dict the globals dict context the function was defined within, as per normal Python semantics, and as bytecode does. Upon function exit the original globals dict is restored. In order to restore the globals dict when an exception is raised the native function must guard its internals with an nlr_push/nlr_pop pair. Because this push/pop is relatively expensive, in both C stack usage for the nlr_buf_t and CPU execution time, the implementation here optimises things as much as possible. First, the compiler keeps track of whether a function even needs to access global variables. Using this information the native emitter then generates three different kinds of code: 1. no globals used, no exception handlers: no nlr handling code and no setting of the globals dict. 2. globals used, no exception handlers: an nlr_buf_t is allocated on the C stack but it is not used if the globals dict is unchanged, saving execution time because nlr_push/nlr_pop don't need to run. 3. function has exception handlers, may use globals: an nlr_buf_t is allocated and nlr_push/nlr_pop are always called. In the end, native functions that don't access globals and don't have exception handlers will run more efficiently than those that do. Fixes issue #1573.
2018-09-13 08:03:48 -04:00
#if MICROPY_EMIT_NATIVE
if (id->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) {
// This function makes a reference to a global variable
py/emitnative: Make viper funcs run with their correct globals context. Viper functions will now capture the globals at the point they were defined and use these globals when executing.
2018-09-15 08:37:07 -04:00
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;
}
py: Fix native functions so they run with their correct globals context. Prior to this commit a function compiled with the native decorator @micropython.native would not work correctly when accessing global variables, because the globals dict was not being set upon function entry. This commit fixes this problem by, upon function entry, setting as the current globals dict the globals dict context the function was defined within, as per normal Python semantics, and as bytecode does. Upon function exit the original globals dict is restored. In order to restore the globals dict when an exception is raised the native function must guard its internals with an nlr_push/nlr_pop pair. Because this push/pop is relatively expensive, in both C stack usage for the nlr_buf_t and CPU execution time, the implementation here optimises things as much as possible. First, the compiler keeps track of whether a function even needs to access global variables. Using this information the native emitter then generates three different kinds of code: 1. no globals used, no exception handlers: no nlr handling code and no setting of the globals dict. 2. globals used, no exception handlers: an nlr_buf_t is allocated on the C stack but it is not used if the globals dict is unchanged, saving execution time because nlr_push/nlr_pop don't need to run. 3. function has exception handlers, may use globals: an nlr_buf_t is allocated and nlr_push/nlr_pop are always called. In the end, native functions that don't access globals and don't have exception handlers will run more efficiently than those that do. Fixes issue #1573.
2018-09-13 08:03:48 -04:00
}
#endif
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
// params always count for 1 local, even if they are a cell
py, compiler: Turn id_info_t.param into a set of flags. So we can add more flags.
2014-04-09 09:42:51 -04:00
if (id->kind == ID_INFO_KIND_LOCAL || (id->flags & ID_FLAG_IS_PARAM)) {
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
id->local_num = scope->num_locals++;
py: work towards working closures.
2013-12-10 19:41:43 -05:00
}
}
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// compute the index of cell vars
py: work towards working closures.
2013-12-10 19:41:43 -05:00
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython the cells come right after the fast locals
py: make closures work.
2013-12-30 17:32:17 -05:00
// parameters are not counted here, since they remain at the start
// of the locals, even if they are cell vars
py, compiler: Turn id_info_t.param into a set of flags. So we can add more flags.
2014-04-09 09:42:51 -04:00
if (id->kind == ID_INFO_KIND_CELL && !(id->flags & ID_FLAG_IS_PARAM)) {
py: make closures work.
2013-12-30 17:32:17 -05:00
id->local_num = scope->num_locals;
scope->num_locals += 1;
py: work towards working closures.
2013-12-10 19:41:43 -05:00
}
}
unix-cpy: Remove unix-cpy. It's no longer needed. unix-cpy was originally written to get semantic equivalent with CPython without writing functional tests. When writing the initial implementation of uPy it was a long way between lexer and functional tests, so the half-way test was to make sure that the bytecode was correct. The idea was that if the uPy bytecode matched CPython 1-1 then uPy would be proper Python if the bytecodes acted correctly. And having matching bytecode meant that it was less likely to miss some deep subtlety in the Python semantics that would require an architectural change later on. But that is all history and it no longer makes sense to retain the ability to output CPython bytecode, because: 1. It outputs CPython 3.3 compatible bytecode. CPython's bytecode changes from version to version, and seems to have changed quite a bit in 3.5. There's no point in changing the bytecode output to match CPython anymore. 2. uPy and CPy do different optimisations to the bytecode which makes it harder to match. 3. The bytecode tests are not run. They were never part of Travis and are not run locally anymore. 4. The EMIT_CPYTHON option needs a lot of extra source code which adds heaps of noise, especially in compile.c. 5. Now that there is an extensive test suite (which tests functionality) there is no need to match the bytecode. Some very subtle behaviour is tested with the test suite and passing these tests is a much better way to stay Python-language compliant, rather than trying to match CPy bytecode.
2015-08-14 07:24:11 -04:00
// compute the index of free vars
py: work towards working closures.
2013-12-10 19:41:43 -05:00
// 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];
py: Convert [u]int to mp_[u]int_t in emit.h and associated .c files. Towards resolving issue #50.
2014-09-08 18:05:16 -04:00
if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {
py, compiler: Turn id_info_t.param into a set of flags. So we can add more flags.
2014-04-09 09:42:51 -04:00
assert(!(id2->flags & ID_FLAG_IS_PARAM)); // free vars should not be params
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython the frees come first, before the params
py: make closures work.
2013-12-30 17:32:17 -05:00
id2->local_num = num_free;
py: work towards working closures.
2013-12-10 19:41:43 -05:00
num_free += 1;
}
}
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
// in MicroPython shift all other locals after the free locals
py: make closures work.
2013-12-30 17:32:17 -05:00
if (num_free > 0) {
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
py: Properly implement deletion of locals and derefs, and detect errors. Needed to reinstate 2 delete opcodes, to specifically check that a local is not deleted twice.
2014-04-09 10:26:46 -04:00
if (id->kind != ID_INFO_KIND_FREE || (id->flags & ID_FLAG_IS_PARAM)) {
py: make closures work.
2013-12-30 17:32:17 -05:00
id->local_num += num_free;
}
}
py: Implement keyword-only args. Implements 'def f(*, a)' and 'def f(*a, b)', but not default keyword-only args, eg 'def f(*, a=1)'. Partially addresses issue #524.
2014-04-27 10:50:52 -04:00
scope->num_pos_args += num_free; // free vars are counted as params for passing them into the function
py: make closures work.
2013-12-30 17:32:17 -05:00
scope->num_locals += num_free;
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
}
py/compile: Add mp_compile_to_raw_code() to return raw code object. This can then be passed to mp_raw_code_save_file to save a .mpy file.
2015-11-13 08:38:28 -05:00
#if !MICROPY_PERSISTENT_CODE_SAVE
STATIC
#endif
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_file, bool is_repl) {
py/compile: Put compiler state on the C stack. It's relatively small (between 44 and 56 bytes) and helps to reduce heap pressure and fragmentation during compilation.
2015-09-24 08:15:57 -04:00
// put compiler state on the stack, it's relatively small
compiler_t comp_state = {0};
compiler_t *comp = &comp_state;
py: Add module/function/class name to exceptions. Exceptions know source file, line and block name. Also tidy up some debug printing functions and provide a global flag to enable/disable them.
2014-01-19 06:48:48 -05:00
comp->source_file = source_file;
Implement REPL.
2013-10-18 14:58:12 -04:00
comp->is_repl = is_repl;
py/compile: Optimise emitter label indices to save a word of heap. Previous to this patch, a label with value "0" was used to indicate an invalid label, but that meant a wasted word (at slot 0) in the array of label offsets. This patch adjusts the label indices so the first one starts at 0, and the maximum value indicates an invalid label.
2017-06-22 01:05:58 -04:00
comp->break_label = INVALID_LABEL;
comp->continue_label = INVALID_LABEL;
Initial commit.
2013-10-04 14:53:11 -04:00
py: Set compiler scope before folding constants so error messages work. Addresses issue #1140.
2015-03-01 07:04:05 -05:00
// create the module scope
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
#if MICROPY_EMIT_NATIVE
const uint emit_opt = MP_STATE_VM(default_emit_opt);
#else
const uint emit_opt = MP_EMIT_OPT_NONE;
#endif
py: Allocate parse nodes in chunks to reduce fragmentation and RAM use. With this patch parse nodes are allocated sequentially in chunks. This reduces fragmentation of the heap and prevents waste at the end of individually allocated parse nodes. Saves roughly 20% of RAM during parse stage.
2015-09-23 05:50:43 -04:00
scope_t *module_scope = scope_new_and_link(comp, SCOPE_MODULE, parse_tree->root, emit_opt);
py: Set compiler scope before folding constants so error messages work. Addresses issue #1140.
2015-03-01 07:04:05 -05:00
py, compiler: Remove emit_pass1 code, using emit_bc to do its job. First pass for the compiler is computing the scope (eg if an identifier is local or not) and originally had an entire table of methods dedicated to this, most of which did nothing. With changes from previous commit, this set of methods can be removed and the methods from the bytecode emitter used instead, with very little modification -- this is what is done in this commit. This factoring has little to no impact on the speed of the compiler (tested by compiling 3763 Python scripts and timing it). This factoring reduces code size by about 270-300 bytes on Thumb2 archs, and 400 bytes on x86.
2015-03-26 11:49:53 -04:00
// create standard emitter; it's used at least for MP_PASS_SCOPE
emit_t *emit_bc = emit_bc_new();
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// compile pass 1
py, compiler: Remove emit_pass1 code, using emit_bc to do its job. First pass for the compiler is computing the scope (eg if an identifier is local or not) and originally had an entire table of methods dedicated to this, most of which did nothing. With changes from previous commit, this set of methods can be removed and the methods from the bytecode emitter used instead, with very little modification -- this is what is done in this commit. This factoring has little to no impact on the speed of the compiler (tested by compiling 3763 Python scripts and timing it). This factoring reduces code size by about 270-300 bytes on Thumb2 archs, and 400 bytes on x86.
2015-03-26 11:49:53 -04:00
comp->emit = emit_bc;
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#if MICROPY_EMIT_NATIVE
py, compiler: Remove emit_pass1 code, using emit_bc to do its job. First pass for the compiler is computing the scope (eg if an identifier is local or not) and originally had an entire table of methods dedicated to this, most of which did nothing. With changes from previous commit, this set of methods can be removed and the methods from the bytecode emitter used instead, with very little modification -- this is what is done in this commit. This factoring has little to no impact on the speed of the compiler (tested by compiling 3763 Python scripts and timing it). This factoring reduces code size by about 270-300 bytes on Thumb2 archs, and 400 bytes on x86.
2015-03-26 11:49:53 -04:00
comp->emit_method_table = &emit_bc_method_table;
#endif
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
uint max_num_labels = 0;
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#if MICROPY_EMIT_INLINE_ASM
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
if (s->emit_options == MP_EMIT_OPT_ASM) {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
compile_scope_inline_asm(comp, s, MP_PASS_SCOPE);
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
} else
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#endif
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
{
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
compile_scope(comp, s, MP_PASS_SCOPE);
py/compile: Fix case of eager implicit conversion of local to nonlocal. This ensures that implicit variables are only converted to implicit closed-over variables (nonlocals) at the very end of the function scope. If variables are closed-over when first used (read from, as was done prior to this commit) then this can be incorrect because the variable may be assigned to later on in the function which means they are just a plain local, not closed over. Fixes issue #4272.
2018-10-26 01:48:07 -04:00
// 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);
}
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
// update maximim number of labels needed
if (comp->next_label > max_num_labels) {
max_num_labels = comp->next_label;
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// compute some things related to scope and identifiers
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
py, unix: Allow to compile with -Wunused-parameter. See issue #699.
2015-01-20 07:47:20 -05:00
scope_compute_things(s);
Initial commit.
2013-10-04 14:53:11 -04:00
}
py, compiler: Remove emit_pass1 code, using emit_bc to do its job. First pass for the compiler is computing the scope (eg if an identifier is local or not) and originally had an entire table of methods dedicated to this, most of which did nothing. With changes from previous commit, this set of methods can be removed and the methods from the bytecode emitter used instead, with very little modification -- this is what is done in this commit. This factoring has little to no impact on the speed of the compiler (tested by compiling 3763 Python scripts and timing it). This factoring reduces code size by about 270-300 bytes on Thumb2 archs, and 400 bytes on x86.
2015-03-26 11:49:53 -04:00
// set max number of labels now that it's calculated
emit_bc_set_max_num_labels(emit_bc, max_num_labels);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
// compile pass 2 and 3
run code formatting script
2021-03-15 09:57:36 -04:00
#if MICROPY_EMIT_NATIVE
Make runtime able to call inline asm with 1 argument.
2013-10-05 20:01:01 -04:00
emit_t *emit_native = NULL;
run code formatting script
2021-03-15 09:57:36 -04:00
#endif
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#if MICROPY_EMIT_INLINE_ASM
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
if (s->emit_options == MP_EMIT_OPT_ASM) {
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
// inline assembly
if (comp->emit_inline_asm == NULL) {
comp->emit_inline_asm = ASM_EMITTER(new)(max_num_labels);
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
}
comp->emit = NULL;
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
comp->emit_inline_asm_method_table = ASM_EMITTER_TABLE;
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
compile_scope_inline_asm(comp, s, MP_PASS_CODE_SIZE);
py/compile: Add an extra pass for Xtensa inline assembler. It needs an extra pass to compute the size of the constant table for the l32r instructions.
2016-12-19 01:42:25 -05:00
#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
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
#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);
}
py/compile: Add an extra pass for Xtensa inline assembler. It needs an extra pass to compute the size of the constant table for the l32r instructions.
2016-12-19 01:42:25 -05:00
#endif
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
if (comp->compile_error == MP_OBJ_NULL) {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
compile_scope_inline_asm(comp, s, MP_PASS_EMIT);
py: Improve inline assembler; improve compiler constant folding.
2014-04-12 12:54:52 -04:00
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
} else
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#endif
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
{
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
// choose the emit type
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
switch (s->emit_options) {
Improve configurability for native x64/thumb emitter. With MICROPY_EMIT_X64 and MICROPY_EMIT_THUMB disabled, the respective emitters and assemblers will not be included in the code. This can significantly reduce binary size for unix version.
2014-01-04 08:55:24 -05:00
run code formatting script
2021-03-15 09:57:36 -04:00
#if MICROPY_EMIT_NATIVE
py: Add option to compiler to specify default code emitter. Also add command line option to unix port to select emitter.
2014-04-06 06:48:15 -04:00
case MP_EMIT_OPT_NATIVE_PYTHON:
case MP_EMIT_OPT_VIPER:
py: Add support for emitting native x86 machine code.
2014-09-06 18:06:36 -04:00
if (emit_native == NULL) {
py/emitnative: Optimise and improve exception handling in native code. Prior to this patch, native code would use a full nlr_buf_t for each exception handler (try-except, try-finally, with). For nested exception handlers this would use a lot of C stack and be rather inefficient. This patch changes how exceptions are handled in native code by setting up only a single nlr_buf_t context for the entire function, and then manages a state machine (using the PC) to work out which exception handler to run when an exception is raised by an nlr_jump. This keeps the C stack usage at a constant level regardless of the depth of Python exception blocks. The patch also fixes an existing bug when local variables are written to within an exception handler, then their value was incorrectly restored if an exception was raised (since the nlr_jump would restore register values, back to the point of the nlr_push). And it also gets nested try-finally+with working with the viper emitter. Broadly speaking, efficiency of executing native code that doesn't use any exception blocks is unchanged, and emitted code size is only slightly increased for such function. C stack usage of all native functions is either equal or less than before. Emitted code size for native functions that use exception blocks is increased by roughly 10% (due in part to fixing of above-mentioned bugs). But, most importantly, this patch allows to implement more Python features in native code, like unwind jumps and yielding from within nested exception blocks.
2018-08-15 23:56:36 -04:00
emit_native = NATIVE_EMITTER(new)(&comp->compile_error, &comp->next_label, max_num_labels);
py: Add support for emitting native x86 machine code.
2014-09-06 18:06:36 -04:00
}
Merge MicroPython v1.11 into CircuitPython
2021-04-22 20:55:39 -04:00
comp->emit_method_table = NATIVE_EMITTER_TABLE;
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
comp->emit = emit_native;
Implement crude viper emit stage.
2013-10-06 19:02:49 -04:00
break;
run code formatting script
2021-03-15 09:57:36 -04:00
#endif // MICROPY_EMIT_NATIVE
Implement crude viper emit stage.
2013-10-06 19:02:49 -04:00
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
default:
comp->emit = emit_bc;
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#if MICROPY_EMIT_NATIVE
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
comp->emit_method_table = &emit_bc_method_table;
py, compiler: When just bytecode, make explicit calls instead of table. When just the bytecode emitter is needed there is no need to have a dynamic method table for the emitter back-end, and we can instead directly call the mp_emit_bc_XXX functions. This gives a significant reduction in code size and a very slight performance boost for the compiler. This patch saves 1160 bytes code on Thumb2 and 972 bytes on x86, when native emitters are disabled. Overall savings in code over the last 3 commits are: bare-arm: 1664 bytes. minimal: 2136 bytes. stmhal: 584 bytes (it has native emitter enabled). cc3200: 1736 bytes.
2015-03-26 12:44:14 -04:00
#endif
Add support for inline thumb assembly.
2013-10-05 18:17:28 -04:00
break;
}
Separate out mpy core and unix version.
2013-10-12 09:30:21 -04:00
py: Reluctantly add an extra pass to bytecode compiler. Bytecode also needs a pass to compute the stack size. This is because the state size of the bytecode function is encoded as a variable uint, so we must know the value of this uint before we encode it (otherwise the size of the generated code changes from one pass to the next). Having an entire pass for this seems wasteful (in time). Alternative is to allocate fixed space for the state size (would need 3-4 bytes to be general, when 1 byte is usually sufficient) which uses a bit of extra RAM per bytecode function, and makes the code less elegant in places where this uint is encoded/decoded. So, for now, opt for an extra pass.
2015-01-13 19:20:28 -05:00
// need a pass to compute stack size
compile_scope(comp, s, MP_PASS_STACK_SIZE);
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
// second last pass: compute code size
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
if (comp->compile_error == MP_OBJ_NULL) {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
compile_scope(comp, s, MP_PASS_CODE_SIZE);
}
// final pass: emit code
py: Make compiler return a proper exception on SyntaxError.
2014-10-05 14:01:34 -04:00
if (comp->compile_error == MP_OBJ_NULL) {
py, compiler: Improve passes; add an extra pass for native emitter.
2014-05-07 12:24:22 -04:00
compile_scope(comp, s, MP_PASS_EMIT);
py: Improve inline assembler; improve compiler constant folding.
2014-04-12 12:54:52 -04:00
}
Implement built-in decorators to select emit type.
2013-10-05 13:08:26 -04:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Give more precise line number for compile errors. Previous to this patch there were some cases where line numbers for errors were 0 (unknown). Now the compiler attempts to give a better line number where possible, in some cases giving the line number of the closest statement, and other cases the line number of the inner-most scope of the error (eg the line number of the start of the function). This helps to give good (and sometimes exact) line numbers for ViperTypeError exceptions. This patch also makes sure that the first compile error (eg SyntaxError) that is encountered is reported (previously it was the last one that was reported).
2015-07-29 18:16:01 -04:00
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);
}
py: Improve freeing of emitters in mp_compile. There can be multiple emitters allocated during compile (eg byte code and native).
2014-01-24 17:42:28 -05:00
// free the emitters
py, compiler: Remove emit_pass1 code, using emit_bc to do its job. First pass for the compiler is computing the scope (eg if an identifier is local or not) and originally had an entire table of methods dedicated to this, most of which did nothing. With changes from previous commit, this set of methods can be removed and the methods from the bytecode emitter used instead, with very little modification -- this is what is done in this commit. This factoring has little to no impact on the speed of the compiler (tested by compiling 3763 Python scripts and timing it). This factoring reduces code size by about 270-300 bytes on Thumb2 archs, and 400 bytes on x86.
2015-03-26 11:49:53 -04:00
emit_bc_free(emit_bc);
run code formatting script
2021-03-15 09:57:36 -04:00
#if MICROPY_EMIT_NATIVE
py: Improve freeing of emitters in mp_compile. There can be multiple emitters allocated during compile (eg byte code and native).
2014-01-24 17:42:28 -05:00
if (emit_native != NULL) {
py/compile: Simplify configuration of native emitter.
2016-12-06 19:17:17 -05:00
NATIVE_EMITTER(free)(emit_native);
py: Improve freeing of emitters in mp_compile. There can be multiple emitters allocated during compile (eg byte code and native).
2014-01-24 17:42:28 -05:00
}
run code formatting script
2021-03-15 09:57:36 -04:00
#endif
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#if MICROPY_EMIT_INLINE_ASM
if (comp->emit_inline_asm != NULL) {
ASM_EMITTER(free)(comp->emit_inline_asm);
py: Improve freeing of emitters in mp_compile. There can be multiple emitters allocated during compile (eg byte code and native).
2014-01-24 17:42:28 -05:00
}
py: Allow inline-assembler emitter to be generic. This patch refactors some code so that it is easier to integrate new inline assemblers for different architectures other than ARM Thumb.
2016-12-08 21:17:49 -05:00
#endif
py: Improve freeing of emitters in mp_compile. There can be multiple emitters allocated during compile (eg byte code and native).
2014-01-24 17:42:28 -05:00
py: Free non-interned strings in the parser when not needed. mp_parse_node_free now frees the memory associated with non-interned strings. And the parser calls mp_parse_node_free when discarding a non-used node (such as a doc string). Also, the compiler now frees the parse tree explicitly just before it exits (as opposed to relying on the caller to do this). Addresses issue #708 as best we can.
2014-09-23 11:31:56 -04:00
// free the parse tree
py: Allocate parse nodes in chunks to reduce fragmentation and RAM use. With this patch parse nodes are allocated sequentially in chunks. This reduces fragmentation of the heap and prevents waste at the end of individually allocated parse nodes. Saves roughly 20% of RAM during parse stage.
2015-09-23 05:50:43 -04:00
mp_parse_tree_clear(parse_tree);
py: Free non-interned strings in the parser when not needed. mp_parse_node_free now frees the memory associated with non-interned strings. And the parser calls mp_parse_node_free when discarding a non-used node (such as a doc string). Also, the compiler now frees the parse tree explicitly just before it exits (as opposed to relying on the caller to do this). Addresses issue #708 as best we can.
2014-09-23 11:31:56 -04:00
py: Improve freeing of emitters in mp_compile. There can be multiple emitters allocated during compile (eg byte code and native).
2014-01-24 17:42:28 -05:00
// free the scopes
py: Remove unique_codes from emitglue.c. Replace with pointers. Attempt to address issue #386. unique_code_id's have been removed and replaced with a pointer to the "raw code" information. This pointer is stored in the actual byte code (aligned, so the GC can trace it), so that raw code (ie byte code, native code and inline assembler) is kept only for as long as it is needed. In memory it's now like a tree: the outer module's byte code points directly to its children's raw code. So when the outer code gets freed, if there are no remaining functions that need the raw code, then the children's code gets freed as well. This is pretty much like CPython does it, except that CPython stores indexes in the byte code rather than machine pointers. These indices index the per-function constant table in order to find the relevant code.
2014-04-13 06:04:33 -04:00
mp_raw_code_t *outer_raw_code = module_scope->raw_code;
mp_compile(): Properly free module_scope and all nested scopes.
2014-01-23 16:05:47 -05:00
for (scope_t *s = module_scope; s;) {
scope_t *next = s->next;
scope_free(s);
s = next;
}
Implement REPL.
2013-10-18 14:58:12 -04:00
py/compile: Put compiler state on the C stack. It's relatively small (between 44 and 56 bytes) and helps to reduce heap pressure and fragmentation during compilation.
2015-09-24 08:15:57 -04:00
if (comp->compile_error != MP_OBJ_NULL) {
nlr_raise(comp->compile_error);
Change mp_compile so that it returns a function object for the module.
2014-01-03 09:22:03 -05:00
} else {
py/compile: Add mp_compile_to_raw_code() to return raw code object. This can then be passed to mp_raw_code_save_file to save a .mpy file.
2015-11-13 08:38:28 -05:00
return outer_raw_code;
Change mp_compile so that it returns a function object for the module.
2014-01-03 09:22:03 -05:00
}
Initial commit.
2013-10-04 14:53:11 -04:00
}
py/compile: Add mp_compile_to_raw_code() to return raw code object. This can then be passed to mp_raw_code_save_file to save a .mpy file.
2015-11-13 08:38:28 -05:00
Merge MicroPython 1.12 into CircuitPython
2021-04-23 15:26:42 -04:00
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);
py/compile: Add mp_compile_to_raw_code() to return raw code object. This can then be passed to mp_raw_code_save_file to save a .mpy file.
2015-11-13 08:38:28 -05:00
// return function that executes the outer module
return mp_make_function_from_raw_code(rc, MP_OBJ_NULL, MP_OBJ_NULL);
}
py: Add MICROPY_ENABLE_COMPILER and MICROPY_PY_BUILTINS_EVAL_EXEC opts. MICROPY_ENABLE_COMPILER can be used to enable/disable the entire compiler, which is useful when only loading of pre-compiled bytecode is supported. It is enabled by default. MICROPY_PY_BUILTINS_EVAL_EXEC controls support of eval and exec builtin functions. By default they are only included if MICROPY_ENABLE_COMPILER is enabled. Disabling both options saves about 40k of code size on 32-bit x86.
2015-12-18 07:35:44 -05:00
#endif // MICROPY_ENABLE_COMPILER
Reference in New Issue Copy Permalink