blob: 3aa70e8bf221a399a6ceadb31a6828b55fa11422 [file] [log] [blame]
Damien George04b91472014-05-03 23:27:38 +01001/*
2 * This file is part of the Micro Python project, http://micropython.org/
3 *
4 * The MIT License (MIT)
5 *
Damien George9d5e5c02015-09-24 13:15:57 +01006 * Copyright (c) 2013-2015 Damien P. George
Damien George04b91472014-05-03 23:27:38 +01007 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 * THE SOFTWARE.
25 */
26
xbeefe34222014-03-16 00:14:26 -070027#include <stdbool.h>
Damien429d7192013-10-04 19:53:11 +010028#include <stdint.h>
29#include <stdio.h>
30#include <string.h>
31#include <assert.h>
32
Damien George51dfcb42015-01-01 20:27:54 +000033#include "py/scope.h"
34#include "py/emit.h"
35#include "py/compile.h"
Damien George51dfcb42015-01-01 20:27:54 +000036#include "py/runtime.h"
Damien Georgedd53b122016-12-09 20:54:54 +110037#include "py/asmbase.h"
Damien429d7192013-10-04 19:53:11 +010038
Damien Georgedd5353a2015-12-18 12:35:44 +000039#if MICROPY_ENABLE_COMPILER
40
Damien429d7192013-10-04 19:53:11 +010041// TODO need to mangle __attr names
42
43typedef enum {
Damien George71019ae2017-02-15 10:58:05 +110044// define rules with a compile function
Damien George00208ce2014-01-23 00:00:53 +000045#define DEF_RULE(rule, comp, kind, ...) PN_##rule,
Damien George71019ae2017-02-15 10:58:05 +110046#define DEF_RULE_NC(rule, kind, ...)
Damien George51dfcb42015-01-01 20:27:54 +000047#include "py/grammar.h"
Damien429d7192013-10-04 19:53:11 +010048#undef DEF_RULE
Damien George71019ae2017-02-15 10:58:05 +110049#undef DEF_RULE_NC
Damien George7d414a12015-02-08 01:57:40 +000050 PN_const_object, // special node for a constant, generic Python object
Damien George71019ae2017-02-15 10:58:05 +110051// define rules without a compile function
52#define DEF_RULE(rule, comp, kind, ...)
53#define DEF_RULE_NC(rule, kind, ...) PN_##rule,
54#include "py/grammar.h"
55#undef DEF_RULE
56#undef DEF_RULE_NC
Damien429d7192013-10-04 19:53:11 +010057} pn_kind_t;
58
Damien George65dc9602015-08-14 12:24:11 +010059#define NEED_METHOD_TABLE MICROPY_EMIT_NATIVE
Damien George41125902015-03-26 16:44:14 +000060
61#if NEED_METHOD_TABLE
62
63// we need a method table to do the lookup for the emitter functions
Damien Georgeb9791222014-01-23 00:34:21 +000064#define EMIT(fun) (comp->emit_method_table->fun(comp->emit))
65#define EMIT_ARG(fun, ...) (comp->emit_method_table->fun(comp->emit, __VA_ARGS__))
Damien George542bd6b2015-03-26 14:42:40 +000066#define EMIT_LOAD_FAST(qst, local_num) (comp->emit_method_table->load_id.fast(comp->emit, qst, local_num))
67#define EMIT_LOAD_GLOBAL(qst) (comp->emit_method_table->load_id.global(comp->emit, qst))
Damien429d7192013-10-04 19:53:11 +010068
Damien George41125902015-03-26 16:44:14 +000069#else
70
71// if we only have the bytecode emitter enabled then we can do a direct call to the functions
72#define EMIT(fun) (mp_emit_bc_##fun(comp->emit))
73#define EMIT_ARG(fun, ...) (mp_emit_bc_##fun(comp->emit, __VA_ARGS__))
74#define EMIT_LOAD_FAST(qst, local_num) (mp_emit_bc_load_fast(comp->emit, qst, local_num))
75#define EMIT_LOAD_GLOBAL(qst) (mp_emit_bc_load_global(comp->emit, qst))
76
77#endif
78
Damien George080a78b2016-12-07 11:17:17 +110079#if MICROPY_EMIT_NATIVE
80// define a macro to access external native emitter
81#if MICROPY_EMIT_X64
82#define NATIVE_EMITTER(f) emit_native_x64_##f
83#elif MICROPY_EMIT_X86
84#define NATIVE_EMITTER(f) emit_native_x86_##f
85#elif MICROPY_EMIT_THUMB
86#define NATIVE_EMITTER(f) emit_native_thumb_##f
87#elif MICROPY_EMIT_ARM
88#define NATIVE_EMITTER(f) emit_native_arm_##f
Damien George8e5aced2016-12-09 16:39:39 +110089#elif MICROPY_EMIT_XTENSA
90#define NATIVE_EMITTER(f) emit_native_xtensa_##f
Damien George080a78b2016-12-07 11:17:17 +110091#else
92#error "unknown native emitter"
93#endif
94#endif
95
Damien Georgead297a12016-12-09 13:17:49 +110096#if MICROPY_EMIT_INLINE_ASM
97// define macros for inline assembler
98#if MICROPY_EMIT_INLINE_THUMB
99#define ASM_DECORATOR_QSTR MP_QSTR_asm_thumb
100#define ASM_EMITTER(f) emit_inline_thumb_##f
Damien Georgef76b1bf2016-12-09 17:03:33 +1100101#elif MICROPY_EMIT_INLINE_XTENSA
102#define ASM_DECORATOR_QSTR MP_QSTR_asm_xtensa
103#define ASM_EMITTER(f) emit_inline_xtensa_##f
Damien Georgead297a12016-12-09 13:17:49 +1100104#else
105#error "unknown asm emitter"
106#endif
107#endif
108
Damien George0496de22015-10-03 17:07:54 +0100109#define EMIT_INLINE_ASM(fun) (comp->emit_inline_asm_method_table->fun(comp->emit_inline_asm))
110#define EMIT_INLINE_ASM_ARG(fun, ...) (comp->emit_inline_asm_method_table->fun(comp->emit_inline_asm, __VA_ARGS__))
111
Damien Georgea91ac202014-10-05 19:01:34 +0100112// elements in this struct are ordered to make it compact
Damien429d7192013-10-04 19:53:11 +0100113typedef struct _compiler_t {
Damien Georgecbd2f742014-01-19 11:48:48 +0000114 qstr source_file;
Damien Georgea91ac202014-10-05 19:01:34 +0100115
Damien George78035b92014-04-09 12:27:39 +0100116 uint8_t is_repl;
117 uint8_t pass; // holds enum type pass_kind_t
Damien George78035b92014-04-09 12:27:39 +0100118 uint8_t func_arg_is_super; // used to compile special case of super() function call
Damien Georgea91ac202014-10-05 19:01:34 +0100119 uint8_t have_star;
120
121 // try to keep compiler clean from nlr
Damien Georgecfc4c332015-07-29 22:16:01 +0000122 mp_obj_t compile_error; // set to an exception object if there's an error
Damien George831137b2015-12-17 13:13:18 +0000123 size_t compile_error_line; // set to best guess of line of error
Damien429d7192013-10-04 19:53:11 +0100124
Damien George6f355fd2014-04-10 14:11:31 +0100125 uint next_label;
Damienb05d7072013-10-05 13:37:10 +0100126
Damien George69b89d22014-04-11 13:38:30 +0000127 uint16_t num_dict_params;
128 uint16_t num_default_params;
Damien429d7192013-10-04 19:53:11 +0100129
Damien Georgea91ac202014-10-05 19:01:34 +0100130 uint16_t break_label; // highest bit set indicates we are breaking out of a for loop
131 uint16_t continue_label;
132 uint16_t cur_except_level; // increased for SETUP_EXCEPT, SETUP_FINALLY; decreased for POP_BLOCK, POP_EXCEPT
Damien George090c9232014-10-17 14:08:49 +0000133 uint16_t break_continue_except_level;
Damien Georgea91ac202014-10-05 19:01:34 +0100134
Damien429d7192013-10-04 19:53:11 +0100135 scope_t *scope_head;
136 scope_t *scope_cur;
137
Damien6cdd3af2013-10-05 18:08:26 +0100138 emit_t *emit; // current emitter
Damien George41125902015-03-26 16:44:14 +0000139 #if NEED_METHOD_TABLE
Damien6cdd3af2013-10-05 18:08:26 +0100140 const emit_method_table_t *emit_method_table; // current emit method table
Damien George41125902015-03-26 16:44:14 +0000141 #endif
Damien826005c2013-10-05 23:17:28 +0100142
Damien Georgead297a12016-12-09 13:17:49 +1100143 #if MICROPY_EMIT_INLINE_ASM
Damien826005c2013-10-05 23:17:28 +0100144 emit_inline_asm_t *emit_inline_asm; // current emitter for inline asm
145 const emit_inline_asm_method_table_t *emit_inline_asm_method_table; // current emit method table for inline asm
Damien Georgea77ffe62015-03-14 12:59:31 +0000146 #endif
Damien429d7192013-10-04 19:53:11 +0100147} compiler_t;
148
Damien Georgecfc4c332015-07-29 22:16:01 +0000149STATIC void compile_error_set_line(compiler_t *comp, mp_parse_node_t pn) {
150 // if the line of the error is unknown then try to update it from the pn
151 if (comp->compile_error_line == 0 && MP_PARSE_NODE_IS_STRUCT(pn)) {
Damien George831137b2015-12-17 13:13:18 +0000152 comp->compile_error_line = ((mp_parse_node_struct_t*)pn)->source_line;
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100153 }
Damien George84d59c22015-07-27 22:20:00 +0100154}
155
156STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, const char *msg) {
Damien Georgecfc4c332015-07-29 22:16:01 +0000157 // only register the error if there has been no other error
158 if (comp->compile_error == MP_OBJ_NULL) {
159 comp->compile_error = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg);
160 compile_error_set_line(comp, pn);
161 }
Damien Georgef41fdd02014-03-03 23:19:11 +0000162}
163
Paul Sokolovsky520e2f52014-02-12 18:31:30 +0200164STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_arglist, bool is_method_call, int n_positional_extra);
Damien George6be0b0a2014-08-15 14:30:52 +0100165STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind);
Damien George8dcc0c72014-03-27 10:55:21 +0000166STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn);
Damien429d7192013-10-04 19:53:11 +0100167
Damien George6f355fd2014-04-10 14:11:31 +0100168STATIC uint comp_next_label(compiler_t *comp) {
Damienb05d7072013-10-05 13:37:10 +0100169 return comp->next_label++;
170}
171
Damien George8dcc0c72014-03-27 10:55:21 +0000172STATIC void compile_increase_except_level(compiler_t *comp) {
173 comp->cur_except_level += 1;
174 if (comp->cur_except_level > comp->scope_cur->exc_stack_size) {
175 comp->scope_cur->exc_stack_size = comp->cur_except_level;
176 }
177}
178
179STATIC void compile_decrease_except_level(compiler_t *comp) {
180 assert(comp->cur_except_level > 0);
181 comp->cur_except_level -= 1;
182}
183
Paul Sokolovsky520e2f52014-02-12 18:31:30 +0200184STATIC scope_t *scope_new_and_link(compiler_t *comp, scope_kind_t kind, mp_parse_node_t pn, uint emit_options) {
Damien Georgedf8127a2014-04-13 11:04:33 +0100185 scope_t *scope = scope_new(kind, pn, comp->source_file, emit_options);
Damien429d7192013-10-04 19:53:11 +0100186 scope->parent = comp->scope_cur;
187 scope->next = NULL;
188 if (comp->scope_head == NULL) {
189 comp->scope_head = scope;
190 } else {
191 scope_t *s = comp->scope_head;
192 while (s->next != NULL) {
193 s = s->next;
194 }
195 s->next = scope;
196 }
197 return scope;
198}
199
Damien George91bc32d2015-04-09 15:31:53 +0000200typedef void (*apply_list_fun_t)(compiler_t *comp, mp_parse_node_t pn);
201
202STATIC 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) {
Damien George963a5a32015-01-16 17:47:07 +0000203 if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, pn_list_kind)) {
Damiend99b0522013-12-21 18:17:45 +0000204 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
205 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +0100206 for (int i = 0; i < num_nodes; i++) {
207 f(comp, pns->nodes[i]);
208 }
Damiend99b0522013-12-21 18:17:45 +0000209 } else if (!MP_PARSE_NODE_IS_NULL(pn)) {
Damien429d7192013-10-04 19:53:11 +0100210 f(comp, pn);
211 }
212}
213
Damien George969a6b32014-12-10 22:07:04 +0000214STATIC void compile_generic_all_nodes(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +0000215 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +0100216 for (int i = 0; i < num_nodes; i++) {
217 compile_node(comp, pns->nodes[i]);
Damien Georgecfc4c332015-07-29 22:16:01 +0000218 if (comp->compile_error != MP_OBJ_NULL) {
219 // add line info for the error in case it didn't have a line number
220 compile_error_set_line(comp, pns->nodes[i]);
221 return;
222 }
Damien429d7192013-10-04 19:53:11 +0100223 }
224}
225
Damien George542bd6b2015-03-26 14:42:40 +0000226STATIC void compile_load_id(compiler_t *comp, qstr qst) {
227 if (comp->pass == MP_PASS_SCOPE) {
228 mp_emit_common_get_id_for_load(comp->scope_cur, qst);
229 } else {
Damien George41125902015-03-26 16:44:14 +0000230 #if NEED_METHOD_TABLE
Damien George542bd6b2015-03-26 14:42:40 +0000231 mp_emit_common_id_op(comp->emit, &comp->emit_method_table->load_id, comp->scope_cur, qst);
Damien George41125902015-03-26 16:44:14 +0000232 #else
233 mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_load_id_ops, comp->scope_cur, qst);
234 #endif
Damien George542bd6b2015-03-26 14:42:40 +0000235 }
236}
237
238STATIC void compile_store_id(compiler_t *comp, qstr qst) {
239 if (comp->pass == MP_PASS_SCOPE) {
240 mp_emit_common_get_id_for_modification(comp->scope_cur, qst);
241 } else {
Damien George41125902015-03-26 16:44:14 +0000242 #if NEED_METHOD_TABLE
Damien George542bd6b2015-03-26 14:42:40 +0000243 mp_emit_common_id_op(comp->emit, &comp->emit_method_table->store_id, comp->scope_cur, qst);
Damien George41125902015-03-26 16:44:14 +0000244 #else
245 mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_store_id_ops, comp->scope_cur, qst);
246 #endif
Damien George542bd6b2015-03-26 14:42:40 +0000247 }
248}
249
250STATIC void compile_delete_id(compiler_t *comp, qstr qst) {
251 if (comp->pass == MP_PASS_SCOPE) {
252 mp_emit_common_get_id_for_modification(comp->scope_cur, qst);
253 } else {
Damien George41125902015-03-26 16:44:14 +0000254 #if NEED_METHOD_TABLE
Damien George542bd6b2015-03-26 14:42:40 +0000255 mp_emit_common_id_op(comp->emit, &comp->emit_method_table->delete_id, comp->scope_cur, qst);
Damien George41125902015-03-26 16:44:14 +0000256 #else
257 mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_delete_id_ops, comp->scope_cur, qst);
258 #endif
Damien George542bd6b2015-03-26 14:42:40 +0000259 }
260}
261
Damien George2c0842b2014-04-27 16:46:51 +0100262STATIC void c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t *pns_list) {
Damien3a205172013-10-12 15:01:56 +0100263 int total = 0;
Damiend99b0522013-12-21 18:17:45 +0000264 if (!MP_PARSE_NODE_IS_NULL(pn)) {
Damien3a205172013-10-12 15:01:56 +0100265 compile_node(comp, pn);
266 total += 1;
267 }
268 if (pns_list != NULL) {
Damiend99b0522013-12-21 18:17:45 +0000269 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
Damien3a205172013-10-12 15:01:56 +0100270 for (int i = 0; i < n; i++) {
271 compile_node(comp, pns_list->nodes[i]);
272 }
273 total += n;
274 }
Damien Georgeb9791222014-01-23 00:34:21 +0000275 EMIT_ARG(build_tuple, total);
Damien3a205172013-10-12 15:01:56 +0100276}
Damien429d7192013-10-04 19:53:11 +0100277
Damien George969a6b32014-12-10 22:07:04 +0000278STATIC void compile_generic_tuple(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +0100279 // a simple tuple expression
Damiend99b0522013-12-21 18:17:45 +0000280 c_tuple(comp, MP_PARSE_NODE_NULL, pns);
Damien429d7192013-10-04 19:53:11 +0100281}
282
Paul Sokolovsky520e2f52014-02-12 18:31:30 +0200283STATIC void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label) {
Damien Georgeb0cbfb02016-11-13 15:32:05 +1100284 if (mp_parse_node_is_const_false(pn)) {
Damien3a205172013-10-12 15:01:56 +0100285 if (jump_if == false) {
Damien Georgeb9791222014-01-23 00:34:21 +0000286 EMIT_ARG(jump, label);
Damien3a205172013-10-12 15:01:56 +0100287 }
288 return;
Damien Georgeb0cbfb02016-11-13 15:32:05 +1100289 } else if (mp_parse_node_is_const_true(pn)) {
Damien3a205172013-10-12 15:01:56 +0100290 if (jump_if == true) {
Damien Georgeb9791222014-01-23 00:34:21 +0000291 EMIT_ARG(jump, label);
Damien3a205172013-10-12 15:01:56 +0100292 }
293 return;
Damiend99b0522013-12-21 18:17:45 +0000294 } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
295 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
296 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
297 if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
Damien3a205172013-10-12 15:01:56 +0100298 if (jump_if == false) {
Damien George0b2fd912015-02-28 14:37:54 +0000299 and_or_logic1:;
Damien George6f355fd2014-04-10 14:11:31 +0100300 uint label2 = comp_next_label(comp);
Damien3a205172013-10-12 15:01:56 +0100301 for (int i = 0; i < n - 1; i++) {
Damien George0b2fd912015-02-28 14:37:54 +0000302 c_if_cond(comp, pns->nodes[i], !jump_if, label2);
Damien3a205172013-10-12 15:01:56 +0100303 }
Damien George0b2fd912015-02-28 14:37:54 +0000304 c_if_cond(comp, pns->nodes[n - 1], jump_if, label);
Damien Georgeb9791222014-01-23 00:34:21 +0000305 EMIT_ARG(label_assign, label2);
Damien3a205172013-10-12 15:01:56 +0100306 } else {
Damien George0b2fd912015-02-28 14:37:54 +0000307 and_or_logic2:
Damien3a205172013-10-12 15:01:56 +0100308 for (int i = 0; i < n; i++) {
Damien George0b2fd912015-02-28 14:37:54 +0000309 c_if_cond(comp, pns->nodes[i], jump_if, label);
Damien3a205172013-10-12 15:01:56 +0100310 }
311 }
312 return;
Damiend99b0522013-12-21 18:17:45 +0000313 } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
Damien3a205172013-10-12 15:01:56 +0100314 if (jump_if == false) {
Damien George0b2fd912015-02-28 14:37:54 +0000315 goto and_or_logic2;
Damien3a205172013-10-12 15:01:56 +0100316 } else {
Damien George0b2fd912015-02-28 14:37:54 +0000317 goto and_or_logic1;
Damien3a205172013-10-12 15:01:56 +0100318 }
Damiend99b0522013-12-21 18:17:45 +0000319 } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
Damien3a205172013-10-12 15:01:56 +0100320 c_if_cond(comp, pns->nodes[0], !jump_if, label);
321 return;
Damien Georgeeb4e18f2014-08-29 20:04:01 +0100322 } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_atom_paren) {
323 // cond is something in parenthesis
324 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
325 // empty tuple, acts as false for the condition
326 if (jump_if == false) {
327 EMIT_ARG(jump, label);
328 }
Damien George93b37262016-01-07 13:07:52 +0000329 } else {
330 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
Damien Georgeeb4e18f2014-08-29 20:04:01 +0100331 // non-empty tuple, acts as true for the condition
332 if (jump_if == true) {
333 EMIT_ARG(jump, label);
334 }
Damien Georgeeb4e18f2014-08-29 20:04:01 +0100335 }
336 return;
Damien3a205172013-10-12 15:01:56 +0100337 }
338 }
339
340 // nothing special, fall back to default compiling for node and jump
341 compile_node(comp, pn);
Damien George63f38322015-02-28 15:04:06 +0000342 EMIT_ARG(pop_jump_if, jump_if, label);
Damien429d7192013-10-04 19:53:11 +0100343}
344
345typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
Damien George6be0b0a2014-08-15 14:30:52 +0100346STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t kind);
Damien429d7192013-10-04 19:53:11 +0100347
pohmelie81ebba72016-01-27 23:23:11 +0300348STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, assign_kind_t assign_kind) {
Damien429d7192013-10-04 19:53:11 +0100349 if (assign_kind != ASSIGN_AUG_STORE) {
350 compile_node(comp, pns->nodes[0]);
351 }
352
Damiend99b0522013-12-21 18:17:45 +0000353 if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
354 mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
pohmelie81ebba72016-01-27 23:23:11 +0300355 if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
Damiend99b0522013-12-21 18:17:45 +0000356 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Damien429d7192013-10-04 19:53:11 +0100357 if (assign_kind != ASSIGN_AUG_STORE) {
358 for (int i = 0; i < n - 1; i++) {
359 compile_node(comp, pns1->nodes[i]);
360 }
361 }
Damiend99b0522013-12-21 18:17:45 +0000362 assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
363 pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
Damien429d7192013-10-04 19:53:11 +0100364 }
Damien Georgeaedf5832015-03-25 22:06:47 +0000365 if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
Damien429d7192013-10-04 19:53:11 +0100366 if (assign_kind == ASSIGN_AUG_STORE) {
367 EMIT(rot_three);
368 EMIT(store_subscr);
369 } else {
370 compile_node(comp, pns1->nodes[0]);
371 if (assign_kind == ASSIGN_AUG_LOAD) {
372 EMIT(dup_top_two);
Damien George729f7b42014-04-17 22:10:53 +0100373 EMIT(load_subscr);
Damien429d7192013-10-04 19:53:11 +0100374 } else {
375 EMIT(store_subscr);
376 }
377 }
Damiend99b0522013-12-21 18:17:45 +0000378 } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
379 assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
Damien429d7192013-10-04 19:53:11 +0100380 if (assign_kind == ASSIGN_AUG_LOAD) {
381 EMIT(dup_top);
Damien Georgeb9791222014-01-23 00:34:21 +0000382 EMIT_ARG(load_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
Damien429d7192013-10-04 19:53:11 +0100383 } else {
384 if (assign_kind == ASSIGN_AUG_STORE) {
385 EMIT(rot_two);
386 }
Damien Georgeb9791222014-01-23 00:34:21 +0000387 EMIT_ARG(store_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
Damien429d7192013-10-04 19:53:11 +0100388 }
389 } else {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100390 goto cannot_assign;
Damien429d7192013-10-04 19:53:11 +0100391 }
392 } else {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100393 goto cannot_assign;
Damien429d7192013-10-04 19:53:11 +0100394 }
395
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100396 return;
397
398cannot_assign:
399 compile_syntax_error(comp, (mp_parse_node_t)pns, "can't assign to expression");
Damien429d7192013-10-04 19:53:11 +0100400}
401
Damien George0288cf02014-04-11 11:53:00 +0000402// we need to allow for a caller passing in 1 initial node (node_head) followed by an array of nodes (nodes_tail)
Damien George6be0b0a2014-08-15 14:30:52 +0100403STATIC void c_assign_tuple(compiler_t *comp, mp_parse_node_t node_head, uint num_tail, mp_parse_node_t *nodes_tail) {
Damien George0288cf02014-04-11 11:53:00 +0000404 uint num_head = (node_head == MP_PARSE_NODE_NULL) ? 0 : 1;
405
406 // look for star expression
Damien George963a5a32015-01-16 17:47:07 +0000407 uint have_star_index = -1;
Damien George0288cf02014-04-11 11:53:00 +0000408 if (num_head != 0 && MP_PARSE_NODE_IS_STRUCT_KIND(node_head, PN_star_expr)) {
409 EMIT_ARG(unpack_ex, 0, num_tail);
410 have_star_index = 0;
411 }
Damien George963a5a32015-01-16 17:47:07 +0000412 for (uint i = 0; i < num_tail; i++) {
Damien George0288cf02014-04-11 11:53:00 +0000413 if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes_tail[i], PN_star_expr)) {
Damien George963a5a32015-01-16 17:47:07 +0000414 if (have_star_index == (uint)-1) {
Damien George0288cf02014-04-11 11:53:00 +0000415 EMIT_ARG(unpack_ex, num_head + i, num_tail - i - 1);
416 have_star_index = num_head + i;
Damien429d7192013-10-04 19:53:11 +0100417 } else {
Damien George9d181f62014-04-27 16:55:27 +0100418 compile_syntax_error(comp, nodes_tail[i], "multiple *x in assignment");
Damien429d7192013-10-04 19:53:11 +0100419 return;
420 }
421 }
422 }
Damien George963a5a32015-01-16 17:47:07 +0000423 if (have_star_index == (uint)-1) {
Damien George0288cf02014-04-11 11:53:00 +0000424 EMIT_ARG(unpack_sequence, num_head + num_tail);
Damien429d7192013-10-04 19:53:11 +0100425 }
Damien George0288cf02014-04-11 11:53:00 +0000426 if (num_head != 0) {
427 if (0 == have_star_index) {
428 c_assign(comp, ((mp_parse_node_struct_t*)node_head)->nodes[0], ASSIGN_STORE);
Damien429d7192013-10-04 19:53:11 +0100429 } else {
Damien George0288cf02014-04-11 11:53:00 +0000430 c_assign(comp, node_head, ASSIGN_STORE);
431 }
432 }
Damien George963a5a32015-01-16 17:47:07 +0000433 for (uint i = 0; i < num_tail; i++) {
Damien George0288cf02014-04-11 11:53:00 +0000434 if (num_head + i == have_star_index) {
435 c_assign(comp, ((mp_parse_node_struct_t*)nodes_tail[i])->nodes[0], ASSIGN_STORE);
436 } else {
437 c_assign(comp, nodes_tail[i], ASSIGN_STORE);
Damien429d7192013-10-04 19:53:11 +0100438 }
439 }
440}
441
442// assigns top of stack to pn
Damien George6be0b0a2014-08-15 14:30:52 +0100443STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_kind) {
Damien Georgeaedf5832015-03-25 22:06:47 +0000444 assert(!MP_PARSE_NODE_IS_NULL(pn));
445 if (MP_PARSE_NODE_IS_LEAF(pn)) {
Damiend99b0522013-12-21 18:17:45 +0000446 if (MP_PARSE_NODE_IS_ID(pn)) {
Damien George42f3de92014-10-03 17:44:14 +0000447 qstr arg = MP_PARSE_NODE_LEAF_ARG(pn);
Damien429d7192013-10-04 19:53:11 +0100448 switch (assign_kind) {
449 case ASSIGN_STORE:
450 case ASSIGN_AUG_STORE:
Damien George542bd6b2015-03-26 14:42:40 +0000451 compile_store_id(comp, arg);
Damien429d7192013-10-04 19:53:11 +0100452 break;
453 case ASSIGN_AUG_LOAD:
Damien Georged2d64f02015-01-14 21:32:42 +0000454 default:
Damien George542bd6b2015-03-26 14:42:40 +0000455 compile_load_id(comp, arg);
Damien429d7192013-10-04 19:53:11 +0100456 break;
457 }
458 } else {
Damien Georgef55a0592017-03-29 12:28:33 +1100459 goto cannot_assign;
Damien429d7192013-10-04 19:53:11 +0100460 }
461 } else {
Damien Georgeaedf5832015-03-25 22:06:47 +0000462 // pn must be a struct
Damiend99b0522013-12-21 18:17:45 +0000463 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
464 switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
pohmelie81ebba72016-01-27 23:23:11 +0300465 case PN_atom_expr_normal:
Damien429d7192013-10-04 19:53:11 +0100466 // lhs is an index or attribute
pohmelie81ebba72016-01-27 23:23:11 +0300467 c_assign_atom_expr(comp, pns, assign_kind);
Damien429d7192013-10-04 19:53:11 +0100468 break;
469
470 case PN_testlist_star_expr:
471 case PN_exprlist:
472 // lhs is a tuple
473 if (assign_kind != ASSIGN_STORE) {
Damien Georgef55a0592017-03-29 12:28:33 +1100474 goto cannot_assign;
Damien429d7192013-10-04 19:53:11 +0100475 }
Damien George0288cf02014-04-11 11:53:00 +0000476 c_assign_tuple(comp, MP_PARSE_NODE_NULL, MP_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
Damien429d7192013-10-04 19:53:11 +0100477 break;
478
479 case PN_atom_paren:
480 // lhs is something in parenthesis
Damiend99b0522013-12-21 18:17:45 +0000481 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +0100482 // empty tuple
Damien George9d181f62014-04-27 16:55:27 +0100483 goto cannot_assign;
Damien George93b37262016-01-07 13:07:52 +0000484 } else {
485 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
Damien George44f65c02015-03-25 23:06:48 +0000486 if (assign_kind != ASSIGN_STORE) {
Damien Georgef55a0592017-03-29 12:28:33 +1100487 goto cannot_assign;
Damien George44f65c02015-03-25 23:06:48 +0000488 }
Damiend99b0522013-12-21 18:17:45 +0000489 pns = (mp_parse_node_struct_t*)pns->nodes[0];
Damien429d7192013-10-04 19:53:11 +0100490 goto testlist_comp;
Damien429d7192013-10-04 19:53:11 +0100491 }
492 break;
493
494 case PN_atom_bracket:
495 // lhs is something in brackets
496 if (assign_kind != ASSIGN_STORE) {
Damien Georgef55a0592017-03-29 12:28:33 +1100497 goto cannot_assign;
Damien429d7192013-10-04 19:53:11 +0100498 }
Damiend99b0522013-12-21 18:17:45 +0000499 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +0100500 // empty list, assignment allowed
Damien George0288cf02014-04-11 11:53:00 +0000501 c_assign_tuple(comp, MP_PARSE_NODE_NULL, 0, NULL);
Damiend99b0522013-12-21 18:17:45 +0000502 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
503 pns = (mp_parse_node_struct_t*)pns->nodes[0];
Damien429d7192013-10-04 19:53:11 +0100504 goto testlist_comp;
505 } else {
506 // brackets around 1 item
Damien George0288cf02014-04-11 11:53:00 +0000507 c_assign_tuple(comp, pns->nodes[0], 0, NULL);
Damien429d7192013-10-04 19:53:11 +0100508 }
509 break;
510
511 default:
Damien George9d181f62014-04-27 16:55:27 +0100512 goto cannot_assign;
Damien429d7192013-10-04 19:53:11 +0100513 }
514 return;
515
516 testlist_comp:
517 // lhs is a sequence
Damiend99b0522013-12-21 18:17:45 +0000518 if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
519 mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
520 if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
Damien429d7192013-10-04 19:53:11 +0100521 // sequence of one item, with trailing comma
Damiend99b0522013-12-21 18:17:45 +0000522 assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
Damien George0288cf02014-04-11 11:53:00 +0000523 c_assign_tuple(comp, pns->nodes[0], 0, NULL);
Damiend99b0522013-12-21 18:17:45 +0000524 } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
Damien429d7192013-10-04 19:53:11 +0100525 // sequence of many items
Damien George0288cf02014-04-11 11:53:00 +0000526 uint n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns2);
527 c_assign_tuple(comp, pns->nodes[0], n, pns2->nodes);
Damien George216a7112016-09-30 14:48:06 +1000528 } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
Damien George9d181f62014-04-27 16:55:27 +0100529 goto cannot_assign;
Damien429d7192013-10-04 19:53:11 +0100530 } else {
531 // sequence with 2 items
532 goto sequence_with_2_items;
533 }
534 } else {
535 // sequence with 2 items
536 sequence_with_2_items:
Damien George0288cf02014-04-11 11:53:00 +0000537 c_assign_tuple(comp, MP_PARSE_NODE_NULL, 2, pns->nodes);
Damien429d7192013-10-04 19:53:11 +0100538 }
539 return;
540 }
541 return;
542
Damien George9d181f62014-04-27 16:55:27 +0100543 cannot_assign:
544 compile_syntax_error(comp, pn, "can't assign to expression");
Damien429d7192013-10-04 19:53:11 +0100545}
546
Damien George65dc9602015-08-14 12:24:11 +0100547// stuff for lambda and comprehensions and generators:
Damien Georgee337f1e2014-03-31 15:18:37 +0100548// if n_pos_defaults > 0 then there is a tuple on the stack with the positional defaults
549// if n_kw_defaults > 0 then there is a dictionary on the stack with the keyword defaults
550// if both exist, the tuple is above the dictionary (ie the first pop gets the tuple)
Damien George6be0b0a2014-08-15 14:30:52 +0100551STATIC void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int n_pos_defaults, int n_kw_defaults) {
Damien George30565092014-03-31 11:30:17 +0100552 assert(n_pos_defaults >= 0);
553 assert(n_kw_defaults >= 0);
554
Damien George3a3db4d2015-10-22 23:45:37 +0100555 // set flags
556 if (n_kw_defaults > 0) {
557 this_scope->scope_flags |= MP_SCOPE_FLAG_DEFKWARGS;
558 }
559 this_scope->num_def_pos_args = n_pos_defaults;
560
Damien429d7192013-10-04 19:53:11 +0100561 // make closed over variables, if any
Damien318aec62013-12-10 18:28:17 +0000562 // ensure they are closed over in the order defined in the outer scope (mainly to agree with CPython)
Damien429d7192013-10-04 19:53:11 +0100563 int nfree = 0;
564 if (comp->scope_cur->kind != SCOPE_MODULE) {
Damien318aec62013-12-10 18:28:17 +0000565 for (int i = 0; i < comp->scope_cur->id_info_len; i++) {
566 id_info_t *id = &comp->scope_cur->id_info[i];
567 if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
568 for (int j = 0; j < this_scope->id_info_len; j++) {
569 id_info_t *id2 = &this_scope->id_info[j];
Damien George7ff996c2014-09-08 23:05:16 +0100570 if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {
Damien George6baf76e2013-12-30 22:32:17 +0000571 // in Micro Python we load closures using LOAD_FAST
Damien George542bd6b2015-03-26 14:42:40 +0000572 EMIT_LOAD_FAST(id->qst, id->local_num);
Damien318aec62013-12-10 18:28:17 +0000573 nfree += 1;
574 }
575 }
Damien429d7192013-10-04 19:53:11 +0100576 }
577 }
578 }
Damien429d7192013-10-04 19:53:11 +0100579
580 // make the function/closure
581 if (nfree == 0) {
Damien George30565092014-03-31 11:30:17 +0100582 EMIT_ARG(make_function, this_scope, n_pos_defaults, n_kw_defaults);
Damien429d7192013-10-04 19:53:11 +0100583 } else {
Damien George3558f622014-04-20 17:50:40 +0100584 EMIT_ARG(make_closure, this_scope, nfree, n_pos_defaults, n_kw_defaults);
Damien429d7192013-10-04 19:53:11 +0100585 }
586}
587
Damien George2c838942015-11-17 14:00:14 +0000588STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn) {
Damien George40b40ff2017-04-22 14:23:47 +1000589 // For efficiency of the code below we extract the parse-node kind here
590 int pn_kind;
591 if (MP_PARSE_NODE_IS_ID(pn)) {
592 pn_kind = -1;
593 } else {
594 assert(MP_PARSE_NODE_IS_STRUCT(pn));
595 pn_kind = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn);
596 }
597
598 if (pn_kind == PN_typedargslist_star || pn_kind == PN_varargslist_star) {
Damien George8b19db02014-04-11 23:25:34 +0100599 comp->have_star = true;
600 /* don't need to distinguish bare from named star
Damiend99b0522013-12-21 18:17:45 +0000601 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
602 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +0100603 // bare star
Damien George8b19db02014-04-11 23:25:34 +0100604 } else {
605 // named star
Damien429d7192013-10-04 19:53:11 +0100606 }
Damien George8b19db02014-04-11 23:25:34 +0100607 */
Damien Georgef41fdd02014-03-03 23:19:11 +0000608
Damien George40b40ff2017-04-22 14:23:47 +1000609 } else if (pn_kind == PN_typedargslist_dbl_star || pn_kind == PN_varargslist_dbl_star) {
Damien George8b19db02014-04-11 23:25:34 +0100610 // named double star
Damien Georgef41fdd02014-03-03 23:19:11 +0000611 // TODO do we need to do anything with this?
612
613 } else {
614 mp_parse_node_t pn_id;
615 mp_parse_node_t pn_colon;
616 mp_parse_node_t pn_equal;
Damien George40b40ff2017-04-22 14:23:47 +1000617 if (pn_kind == -1) {
Damien Georgef41fdd02014-03-03 23:19:11 +0000618 // this parameter is just an id
619
620 pn_id = pn;
621 pn_colon = MP_PARSE_NODE_NULL;
622 pn_equal = MP_PARSE_NODE_NULL;
623
Damien George40b40ff2017-04-22 14:23:47 +1000624 } else if (pn_kind == PN_typedargslist_name) {
Damien Georgef41fdd02014-03-03 23:19:11 +0000625 // this parameter has a colon and/or equal specifier
626
627 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
628 pn_id = pns->nodes[0];
629 pn_colon = pns->nodes[1];
630 pn_equal = pns->nodes[2];
Damien George2c838942015-11-17 14:00:14 +0000631
632 } else {
Damien George40b40ff2017-04-22 14:23:47 +1000633 assert(pn_kind == PN_varargslist_name); // should be
Damien George2c838942015-11-17 14:00:14 +0000634 // this parameter has an equal specifier
635
636 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
637 pn_id = pns->nodes[0];
638 pn_equal = pns->nodes[1];
Damien Georgef41fdd02014-03-03 23:19:11 +0000639 }
640
641 if (MP_PARSE_NODE_IS_NULL(pn_equal)) {
642 // this parameter does not have a default value
643
644 // check for non-default parameters given after default parameters (allowed by parser, but not syntactically valid)
Damien George8b19db02014-04-11 23:25:34 +0100645 if (!comp->have_star && comp->num_default_params != 0) {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100646 compile_syntax_error(comp, pn, "non-default argument follows default argument");
Damien Georgef41fdd02014-03-03 23:19:11 +0000647 return;
648 }
649
650 } else {
651 // this parameter has a default value
652 // in CPython, None (and True, False?) as default parameters are loaded with LOAD_NAME; don't understandy why
653
Damien George8b19db02014-04-11 23:25:34 +0100654 if (comp->have_star) {
Damien George69b89d22014-04-11 13:38:30 +0000655 comp->num_dict_params += 1;
Damien George69b89d22014-04-11 13:38:30 +0000656 // in Micro Python we put the default dict parameters into a dictionary using the bytecode
657 if (comp->num_dict_params == 1) {
Damien George7b433012014-04-12 00:05:49 +0100658 // in Micro Python we put the default positional parameters into a tuple using the bytecode
659 // we need to do this here before we start building the map for the default keywords
660 if (comp->num_default_params > 0) {
661 EMIT_ARG(build_tuple, comp->num_default_params);
Damien George3558f622014-04-20 17:50:40 +0100662 } else {
663 EMIT(load_null); // sentinel indicating empty default positional args
Damien George7b433012014-04-12 00:05:49 +0100664 }
Damien George69b89d22014-04-11 13:38:30 +0000665 // first default dict param, so make the map
666 EMIT_ARG(build_map, 0);
Damien Georgef41fdd02014-03-03 23:19:11 +0000667 }
Damien Georgef0778a72014-06-07 22:01:00 +0100668
669 // compile value then key, then store it to the dict
Damien George69b89d22014-04-11 13:38:30 +0000670 compile_node(comp, pn_equal);
Damien George59fba2d2015-06-25 14:42:13 +0000671 EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pn_id));
Damien George69b89d22014-04-11 13:38:30 +0000672 EMIT(store_map);
Damien Georgef41fdd02014-03-03 23:19:11 +0000673 } else {
Damien George69b89d22014-04-11 13:38:30 +0000674 comp->num_default_params += 1;
675 compile_node(comp, pn_equal);
Damien Georgef41fdd02014-03-03 23:19:11 +0000676 }
677 }
678
679 // TODO pn_colon not implemented
680 (void)pn_colon;
Damien429d7192013-10-04 19:53:11 +0100681 }
682}
683
Damien George2c838942015-11-17 14:00:14 +0000684STATIC void compile_funcdef_lambdef(compiler_t *comp, scope_t *scope, mp_parse_node_t pn_params, pn_kind_t pn_list_kind) {
Damien George29e9db02015-12-12 13:42:51 +0000685 // When we call compile_funcdef_lambdef_param below it can compile an arbitrary
686 // expression for default arguments, which may contain a lambda. The lambda will
687 // call here in a nested way, so we must save and restore the relevant state.
688 bool orig_have_star = comp->have_star;
689 uint16_t orig_num_dict_params = comp->num_dict_params;
690 uint16_t orig_num_default_params = comp->num_default_params;
691
Damien George2c838942015-11-17 14:00:14 +0000692 // compile default parameters
693 comp->have_star = false;
694 comp->num_dict_params = 0;
695 comp->num_default_params = 0;
696 apply_to_single_or_list(comp, pn_params, pn_list_kind, compile_funcdef_lambdef_param);
697
698 if (comp->compile_error != MP_OBJ_NULL) {
699 return;
700 }
701
702 // in Micro Python we put the default positional parameters into a tuple using the bytecode
703 // the default keywords args may have already made the tuple; if not, do it now
704 if (comp->num_default_params > 0 && comp->num_dict_params == 0) {
705 EMIT_ARG(build_tuple, comp->num_default_params);
706 EMIT(load_null); // sentinel indicating empty default keyword args
707 }
708
709 // make the function
710 close_over_variables_etc(comp, scope, comp->num_default_params, comp->num_dict_params);
Damien George29e9db02015-12-12 13:42:51 +0000711
712 // restore state
713 comp->have_star = orig_have_star;
714 comp->num_dict_params = orig_num_dict_params;
715 comp->num_default_params = orig_num_default_params;
Damien George2c838942015-11-17 14:00:14 +0000716}
717
Damien429d7192013-10-04 19:53:11 +0100718// leaves function object on stack
719// returns function name
Damien George969a6b32014-12-10 22:07:04 +0000720STATIC qstr compile_funcdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
Damien George36db6bc2014-05-07 17:24:22 +0100721 if (comp->pass == MP_PASS_SCOPE) {
Damien429d7192013-10-04 19:53:11 +0100722 // create a new scope for this function
Damiend99b0522013-12-21 18:17:45 +0000723 scope_t *s = scope_new_and_link(comp, SCOPE_FUNCTION, (mp_parse_node_t)pns, emit_options);
Damien429d7192013-10-04 19:53:11 +0100724 // store the function scope so the compiling function can use it at each pass
Damiend99b0522013-12-21 18:17:45 +0000725 pns->nodes[4] = (mp_parse_node_t)s;
Damien429d7192013-10-04 19:53:11 +0100726 }
727
Damien429d7192013-10-04 19:53:11 +0100728 // get the scope for this function
729 scope_t *fscope = (scope_t*)pns->nodes[4];
730
Damien George2c838942015-11-17 14:00:14 +0000731 // compile the function definition
732 compile_funcdef_lambdef(comp, fscope, pns->nodes[1], PN_typedargslist);
Damien429d7192013-10-04 19:53:11 +0100733
Damien429d7192013-10-04 19:53:11 +0100734 // return its name (the 'f' in "def f(...):")
735 return fscope->simple_name;
736}
737
738// leaves class object on stack
739// returns class name
Damien George969a6b32014-12-10 22:07:04 +0000740STATIC qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
Damien George36db6bc2014-05-07 17:24:22 +0100741 if (comp->pass == MP_PASS_SCOPE) {
Damien429d7192013-10-04 19:53:11 +0100742 // create a new scope for this class
Damiend99b0522013-12-21 18:17:45 +0000743 scope_t *s = scope_new_and_link(comp, SCOPE_CLASS, (mp_parse_node_t)pns, emit_options);
Damien429d7192013-10-04 19:53:11 +0100744 // store the class scope so the compiling function can use it at each pass
Damiend99b0522013-12-21 18:17:45 +0000745 pns->nodes[3] = (mp_parse_node_t)s;
Damien429d7192013-10-04 19:53:11 +0100746 }
747
748 EMIT(load_build_class);
749
750 // scope for this class
751 scope_t *cscope = (scope_t*)pns->nodes[3];
752
753 // compile the class
754 close_over_variables_etc(comp, cscope, 0, 0);
755
756 // get its name
Damien George59fba2d2015-06-25 14:42:13 +0000757 EMIT_ARG(load_const_str, cscope->simple_name);
Damien429d7192013-10-04 19:53:11 +0100758
759 // nodes[1] has parent classes, if any
Damien George804760b2014-03-30 23:06:37 +0100760 // empty parenthesis (eg class C():) gets here as an empty PN_classdef_2 and needs special handling
761 mp_parse_node_t parents = pns->nodes[1];
762 if (MP_PARSE_NODE_IS_STRUCT_KIND(parents, PN_classdef_2)) {
763 parents = MP_PARSE_NODE_NULL;
764 }
Damien Georgebbcd49a2014-02-06 20:30:16 +0000765 comp->func_arg_is_super = false;
Damien George804760b2014-03-30 23:06:37 +0100766 compile_trailer_paren_helper(comp, parents, false, 2);
Damien429d7192013-10-04 19:53:11 +0100767
768 // return its name (the 'C' in class C(...):")
769 return cscope->simple_name;
770}
771
Damien6cdd3af2013-10-05 18:08:26 +0100772// returns true if it was a built-in decorator (even if the built-in had an error)
Paul Sokolovsky520e2f52014-02-12 18:31:30 +0200773STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_node_t *name_nodes, uint *emit_options) {
Damien Georgeeb7bfcb2014-01-04 15:57:35 +0000774 if (MP_PARSE_NODE_LEAF_ARG(name_nodes[0]) != MP_QSTR_micropython) {
Damien6cdd3af2013-10-05 18:08:26 +0100775 return false;
776 }
777
778 if (name_len != 2) {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100779 compile_syntax_error(comp, name_nodes[0], "invalid micropython decorator");
Damien6cdd3af2013-10-05 18:08:26 +0100780 return true;
781 }
782
Damiend99b0522013-12-21 18:17:45 +0000783 qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
Damien George3417bc22014-05-10 10:36:38 +0100784 if (attr == MP_QSTR_bytecode) {
Damien George96f137b2014-05-12 22:35:37 +0100785 *emit_options = MP_EMIT_OPT_BYTECODE;
Damience89a212013-10-15 22:25:17 +0100786#if MICROPY_EMIT_NATIVE
Damien Georgeeb7bfcb2014-01-04 15:57:35 +0000787 } else if (attr == MP_QSTR_native) {
Damien George65cad122014-04-06 11:48:15 +0100788 *emit_options = MP_EMIT_OPT_NATIVE_PYTHON;
Damien Georgeeb7bfcb2014-01-04 15:57:35 +0000789 } else if (attr == MP_QSTR_viper) {
Damien George65cad122014-04-06 11:48:15 +0100790 *emit_options = MP_EMIT_OPT_VIPER;
Damience89a212013-10-15 22:25:17 +0100791#endif
Damien Georgead297a12016-12-09 13:17:49 +1100792 #if MICROPY_EMIT_INLINE_ASM
793 } else if (attr == ASM_DECORATOR_QSTR) {
794 *emit_options = MP_EMIT_OPT_ASM;
795 #endif
Damien6cdd3af2013-10-05 18:08:26 +0100796 } else {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100797 compile_syntax_error(comp, name_nodes[1], "invalid micropython decorator");
Damien6cdd3af2013-10-05 18:08:26 +0100798 }
799
800 return true;
801}
802
Damien George969a6b32014-12-10 22:07:04 +0000803STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +0100804 // get the list of decorators
Damiend99b0522013-12-21 18:17:45 +0000805 mp_parse_node_t *nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +0000806 int n = mp_parse_node_extract_list(&pns->nodes[0], PN_decorators, &nodes);
Damien429d7192013-10-04 19:53:11 +0100807
Damien6cdd3af2013-10-05 18:08:26 +0100808 // inherit emit options for this function/class definition
809 uint emit_options = comp->scope_cur->emit_options;
810
811 // compile each decorator
812 int num_built_in_decorators = 0;
Damien429d7192013-10-04 19:53:11 +0100813 for (int i = 0; i < n; i++) {
Damiend99b0522013-12-21 18:17:45 +0000814 assert(MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be
815 mp_parse_node_struct_t *pns_decorator = (mp_parse_node_struct_t*)nodes[i];
Damien6cdd3af2013-10-05 18:08:26 +0100816
817 // nodes[0] contains the decorator function, which is a dotted name
Damiend99b0522013-12-21 18:17:45 +0000818 mp_parse_node_t *name_nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +0000819 int name_len = mp_parse_node_extract_list(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);
Damien6cdd3af2013-10-05 18:08:26 +0100820
821 // check for built-in decorators
822 if (compile_built_in_decorator(comp, name_len, name_nodes, &emit_options)) {
823 // this was a built-in
824 num_built_in_decorators += 1;
825
826 } else {
827 // not a built-in, compile normally
828
829 // compile the decorator function
830 compile_node(comp, name_nodes[0]);
Damien George50912e72015-01-20 11:55:10 +0000831 for (int j = 1; j < name_len; j++) {
832 assert(MP_PARSE_NODE_IS_ID(name_nodes[j])); // should be
833 EMIT_ARG(load_attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[j]));
Damien6cdd3af2013-10-05 18:08:26 +0100834 }
835
836 // nodes[1] contains arguments to the decorator function, if any
Damiend99b0522013-12-21 18:17:45 +0000837 if (!MP_PARSE_NODE_IS_NULL(pns_decorator->nodes[1])) {
Damien6cdd3af2013-10-05 18:08:26 +0100838 // call the decorator function with the arguments in nodes[1]
Damien George35e2a4e2014-02-05 00:51:47 +0000839 comp->func_arg_is_super = false;
Damien6cdd3af2013-10-05 18:08:26 +0100840 compile_node(comp, pns_decorator->nodes[1]);
841 }
Damien429d7192013-10-04 19:53:11 +0100842 }
843 }
844
pohmelie81ebba72016-01-27 23:23:11 +0300845 // compile the body (funcdef, async funcdef or classdef) and get its name
Damiend99b0522013-12-21 18:17:45 +0000846 mp_parse_node_struct_t *pns_body = (mp_parse_node_struct_t*)pns->nodes[1];
Damien429d7192013-10-04 19:53:11 +0100847 qstr body_name = 0;
Damiend99b0522013-12-21 18:17:45 +0000848 if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
Damien6cdd3af2013-10-05 18:08:26 +0100849 body_name = compile_funcdef_helper(comp, pns_body, emit_options);
pohmelie81ebba72016-01-27 23:23:11 +0300850 #if MICROPY_PY_ASYNC_AWAIT
851 } else if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_async_funcdef) {
852 assert(MP_PARSE_NODE_IS_STRUCT(pns_body->nodes[0]));
853 mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns_body->nodes[0];
854 body_name = compile_funcdef_helper(comp, pns0, emit_options);
855 scope_t *fscope = (scope_t*)pns0->nodes[4];
856 fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
857 #endif
Damien429d7192013-10-04 19:53:11 +0100858 } else {
Damien George0bb97132015-02-27 14:25:47 +0000859 assert(MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef); // should be
860 body_name = compile_classdef_helper(comp, pns_body, emit_options);
Damien429d7192013-10-04 19:53:11 +0100861 }
862
863 // call each decorator
Damien6cdd3af2013-10-05 18:08:26 +0100864 for (int i = 0; i < n - num_built_in_decorators; i++) {
Damien George922ddd62014-04-09 12:43:17 +0100865 EMIT_ARG(call_function, 1, 0, 0);
Damien429d7192013-10-04 19:53:11 +0100866 }
867
868 // store func/class object into name
Damien George542bd6b2015-03-26 14:42:40 +0000869 compile_store_id(comp, body_name);
Damien429d7192013-10-04 19:53:11 +0100870}
871
Damien George969a6b32014-12-10 22:07:04 +0000872STATIC void compile_funcdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien6cdd3af2013-10-05 18:08:26 +0100873 qstr fname = compile_funcdef_helper(comp, pns, comp->scope_cur->emit_options);
Damien429d7192013-10-04 19:53:11 +0100874 // store function object into function name
Damien George542bd6b2015-03-26 14:42:40 +0000875 compile_store_id(comp, fname);
Damien429d7192013-10-04 19:53:11 +0100876}
877
Damien George6be0b0a2014-08-15 14:30:52 +0100878STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
Damiend99b0522013-12-21 18:17:45 +0000879 if (MP_PARSE_NODE_IS_ID(pn)) {
Damien George542bd6b2015-03-26 14:42:40 +0000880 compile_delete_id(comp, MP_PARSE_NODE_LEAF_ARG(pn));
pohmelie81ebba72016-01-27 23:23:11 +0300881 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_expr_normal)) {
Damiend99b0522013-12-21 18:17:45 +0000882 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Damien429d7192013-10-04 19:53:11 +0100883
pohmelie81ebba72016-01-27 23:23:11 +0300884 compile_node(comp, pns->nodes[0]); // base of the atom_expr_normal node
Damien429d7192013-10-04 19:53:11 +0100885
Damiend99b0522013-12-21 18:17:45 +0000886 if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
887 mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
pohmelie81ebba72016-01-27 23:23:11 +0300888 if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
Damiend99b0522013-12-21 18:17:45 +0000889 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Damien429d7192013-10-04 19:53:11 +0100890 for (int i = 0; i < n - 1; i++) {
891 compile_node(comp, pns1->nodes[i]);
892 }
Damiend99b0522013-12-21 18:17:45 +0000893 assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
894 pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
Damien429d7192013-10-04 19:53:11 +0100895 }
Damien Georgeaedf5832015-03-25 22:06:47 +0000896 if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
Damien429d7192013-10-04 19:53:11 +0100897 compile_node(comp, pns1->nodes[0]);
898 EMIT(delete_subscr);
Damiend99b0522013-12-21 18:17:45 +0000899 } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
900 assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
Damien Georgeb9791222014-01-23 00:34:21 +0000901 EMIT_ARG(delete_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
Damien429d7192013-10-04 19:53:11 +0100902 } else {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100903 goto cannot_delete;
Damien429d7192013-10-04 19:53:11 +0100904 }
905 } else {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100906 goto cannot_delete;
Damien429d7192013-10-04 19:53:11 +0100907 }
908
Damiend99b0522013-12-21 18:17:45 +0000909 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {
910 pn = ((mp_parse_node_struct_t*)pn)->nodes[0];
Damien George93b37262016-01-07 13:07:52 +0000911 if (MP_PARSE_NODE_IS_NULL(pn)) {
912 goto cannot_delete;
913 } else {
914 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp));
Damiend99b0522013-12-21 18:17:45 +0000915 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Damien429d7192013-10-04 19:53:11 +0100916 // TODO perhaps factorise testlist_comp code with other uses of PN_testlist_comp
917
Damiend99b0522013-12-21 18:17:45 +0000918 if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
919 mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
920 if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {
Damien429d7192013-10-04 19:53:11 +0100921 // sequence of one item, with trailing comma
Damiend99b0522013-12-21 18:17:45 +0000922 assert(MP_PARSE_NODE_IS_NULL(pns1->nodes[0]));
Damien429d7192013-10-04 19:53:11 +0100923 c_del_stmt(comp, pns->nodes[0]);
Damiend99b0522013-12-21 18:17:45 +0000924 } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3c) {
Damien429d7192013-10-04 19:53:11 +0100925 // sequence of many items
Damiend99b0522013-12-21 18:17:45 +0000926 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
Damien429d7192013-10-04 19:53:11 +0100927 c_del_stmt(comp, pns->nodes[0]);
928 for (int i = 0; i < n; i++) {
929 c_del_stmt(comp, pns1->nodes[i]);
930 }
Damien George216a7112016-09-30 14:48:06 +1000931 } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for) {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100932 goto cannot_delete;
Damien429d7192013-10-04 19:53:11 +0100933 } else {
934 // sequence with 2 items
935 goto sequence_with_2_items;
936 }
937 } else {
938 // sequence with 2 items
939 sequence_with_2_items:
940 c_del_stmt(comp, pns->nodes[0]);
941 c_del_stmt(comp, pns->nodes[1]);
942 }
Damien429d7192013-10-04 19:53:11 +0100943 }
944 } else {
Damien George93b37262016-01-07 13:07:52 +0000945 // some arbitrary statment that we can't delete (eg del 1)
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100946 goto cannot_delete;
Damien429d7192013-10-04 19:53:11 +0100947 }
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100948
949 return;
950
951cannot_delete:
952 compile_syntax_error(comp, (mp_parse_node_t)pn, "can't delete expression");
Damien429d7192013-10-04 19:53:11 +0100953}
954
Damien George969a6b32014-12-10 22:07:04 +0000955STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +0100956 apply_to_single_or_list(comp, pns->nodes[0], PN_exprlist, c_del_stmt);
957}
958
Damien George969a6b32014-12-10 22:07:04 +0000959STATIC void compile_break_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +0100960 if (comp->break_label == 0) {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100961 compile_syntax_error(comp, (mp_parse_node_t)pns, "'break' outside loop");
Damien429d7192013-10-04 19:53:11 +0100962 }
Damien George090c9232014-10-17 14:08:49 +0000963 assert(comp->cur_except_level >= comp->break_continue_except_level);
Damien Georgecbddb272014-02-01 20:08:18 +0000964 EMIT_ARG(break_loop, comp->break_label, comp->cur_except_level - comp->break_continue_except_level);
Damien429d7192013-10-04 19:53:11 +0100965}
966
Damien George969a6b32014-12-10 22:07:04 +0000967STATIC void compile_continue_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +0100968 if (comp->continue_label == 0) {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100969 compile_syntax_error(comp, (mp_parse_node_t)pns, "'continue' outside loop");
Damien429d7192013-10-04 19:53:11 +0100970 }
Damien George090c9232014-10-17 14:08:49 +0000971 assert(comp->cur_except_level >= comp->break_continue_except_level);
Damien Georgecbddb272014-02-01 20:08:18 +0000972 EMIT_ARG(continue_loop, comp->continue_label, comp->cur_except_level - comp->break_continue_except_level);
Damien429d7192013-10-04 19:53:11 +0100973}
974
Damien George969a6b32014-12-10 22:07:04 +0000975STATIC void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien5ac1b2e2013-10-18 19:58:12 +0100976 if (comp->scope_cur->kind != SCOPE_FUNCTION) {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +0100977 compile_syntax_error(comp, (mp_parse_node_t)pns, "'return' outside function");
Damien5ac1b2e2013-10-18 19:58:12 +0100978 return;
979 }
Damiend99b0522013-12-21 18:17:45 +0000980 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien5ac1b2e2013-10-18 19:58:12 +0100981 // no argument to 'return', so return None
Damien Georgeb9791222014-01-23 00:34:21 +0000982 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damiend99b0522013-12-21 18:17:45 +0000983 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
Damien429d7192013-10-04 19:53:11 +0100984 // special case when returning an if-expression; to match CPython optimisation
Damiend99b0522013-12-21 18:17:45 +0000985 mp_parse_node_struct_t *pns_test_if_expr = (mp_parse_node_struct_t*)pns->nodes[0];
986 mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns_test_if_expr->nodes[1];
Damien429d7192013-10-04 19:53:11 +0100987
Damien George6f355fd2014-04-10 14:11:31 +0100988 uint l_fail = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +0100989 c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
990 compile_node(comp, pns_test_if_expr->nodes[0]); // success value
991 EMIT(return_value);
Damien Georgeb9791222014-01-23 00:34:21 +0000992 EMIT_ARG(label_assign, l_fail);
Damien429d7192013-10-04 19:53:11 +0100993 compile_node(comp, pns_test_if_else->nodes[1]); // failure value
994 } else {
995 compile_node(comp, pns->nodes[0]);
996 }
997 EMIT(return_value);
998}
999
Damien George969a6b32014-12-10 22:07:04 +00001000STATIC void compile_yield_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01001001 compile_node(comp, pns->nodes[0]);
1002 EMIT(pop_top);
1003}
1004
Damien George969a6b32014-12-10 22:07:04 +00001005STATIC void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00001006 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +01001007 // raise
Damien Georgeb9791222014-01-23 00:34:21 +00001008 EMIT_ARG(raise_varargs, 0);
Damiend99b0522013-12-21 18:17:45 +00001009 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
Damien429d7192013-10-04 19:53:11 +01001010 // raise x from y
Damiend99b0522013-12-21 18:17:45 +00001011 pns = (mp_parse_node_struct_t*)pns->nodes[0];
Damien429d7192013-10-04 19:53:11 +01001012 compile_node(comp, pns->nodes[0]);
1013 compile_node(comp, pns->nodes[1]);
Damien Georgeb9791222014-01-23 00:34:21 +00001014 EMIT_ARG(raise_varargs, 2);
Damien429d7192013-10-04 19:53:11 +01001015 } else {
1016 // raise x
1017 compile_node(comp, pns->nodes[0]);
Damien Georgeb9791222014-01-23 00:34:21 +00001018 EMIT_ARG(raise_varargs, 1);
Damien429d7192013-10-04 19:53:11 +01001019 }
1020}
1021
Damien George635543c2014-04-10 12:56:52 +01001022// q_base holds the base of the name
1023// eg a -> q_base=a
1024// a.b.c -> q_base=a
Damien George6be0b0a2014-08-15 14:30:52 +01001025STATIC void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q_base) {
Damien429d7192013-10-04 19:53:11 +01001026 bool is_as = false;
Damiend99b0522013-12-21 18:17:45 +00001027 if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
1028 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Damien429d7192013-10-04 19:53:11 +01001029 // a name of the form x as y; unwrap it
Damien George635543c2014-04-10 12:56:52 +01001030 *q_base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
Damien429d7192013-10-04 19:53:11 +01001031 pn = pns->nodes[0];
1032 is_as = true;
1033 }
Damien George635543c2014-04-10 12:56:52 +01001034 if (MP_PARSE_NODE_IS_NULL(pn)) {
1035 // empty name (eg, from . import x)
1036 *q_base = MP_QSTR_;
1037 EMIT_ARG(import_name, MP_QSTR_); // import the empty string
1038 } else if (MP_PARSE_NODE_IS_ID(pn)) {
Damien429d7192013-10-04 19:53:11 +01001039 // just a simple name
Damien George635543c2014-04-10 12:56:52 +01001040 qstr q_full = MP_PARSE_NODE_LEAF_ARG(pn);
Damien429d7192013-10-04 19:53:11 +01001041 if (!is_as) {
Damien George635543c2014-04-10 12:56:52 +01001042 *q_base = q_full;
Damien429d7192013-10-04 19:53:11 +01001043 }
Damien George635543c2014-04-10 12:56:52 +01001044 EMIT_ARG(import_name, q_full);
Damien George0bb97132015-02-27 14:25:47 +00001045 } else {
1046 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_name)); // should be
Damiend99b0522013-12-21 18:17:45 +00001047 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Damien George0bb97132015-02-27 14:25:47 +00001048 {
Damien429d7192013-10-04 19:53:11 +01001049 // a name of the form a.b.c
1050 if (!is_as) {
Damien George635543c2014-04-10 12:56:52 +01001051 *q_base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Damien429d7192013-10-04 19:53:11 +01001052 }
Damiend99b0522013-12-21 18:17:45 +00001053 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01001054 int len = n - 1;
1055 for (int i = 0; i < n; i++) {
Damien George55baff42014-01-21 21:40:13 +00001056 len += qstr_len(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
Damien429d7192013-10-04 19:53:11 +01001057 }
Damien George55baff42014-01-21 21:40:13 +00001058 byte *q_ptr;
1059 byte *str_dest = qstr_build_start(len, &q_ptr);
Damien429d7192013-10-04 19:53:11 +01001060 for (int i = 0; i < n; i++) {
1061 if (i > 0) {
Damien Georgefe8fb912014-01-02 16:36:09 +00001062 *str_dest++ = '.';
Damien429d7192013-10-04 19:53:11 +01001063 }
Damien Georgec3f64d92015-11-27 12:23:18 +00001064 size_t str_src_len;
Damien George55baff42014-01-21 21:40:13 +00001065 const byte *str_src = qstr_data(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]), &str_src_len);
Damien Georgefe8fb912014-01-02 16:36:09 +00001066 memcpy(str_dest, str_src, str_src_len);
1067 str_dest += str_src_len;
Damien429d7192013-10-04 19:53:11 +01001068 }
Damien George635543c2014-04-10 12:56:52 +01001069 qstr q_full = qstr_build_end(q_ptr);
1070 EMIT_ARG(import_name, q_full);
Damien429d7192013-10-04 19:53:11 +01001071 if (is_as) {
1072 for (int i = 1; i < n; i++) {
Damien Georgeb9791222014-01-23 00:34:21 +00001073 EMIT_ARG(load_attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
Damien429d7192013-10-04 19:53:11 +01001074 }
1075 }
Damien429d7192013-10-04 19:53:11 +01001076 }
Damien429d7192013-10-04 19:53:11 +01001077 }
1078}
1079
Damien George6be0b0a2014-08-15 14:30:52 +01001080STATIC void compile_dotted_as_name(compiler_t *comp, mp_parse_node_t pn) {
Damien George635543c2014-04-10 12:56:52 +01001081 EMIT_ARG(load_const_small_int, 0); // level 0 import
1082 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE); // not importing from anything
1083 qstr q_base;
1084 do_import_name(comp, pn, &q_base);
Damien George542bd6b2015-03-26 14:42:40 +00001085 compile_store_id(comp, q_base);
Damien429d7192013-10-04 19:53:11 +01001086}
1087
Damien George969a6b32014-12-10 22:07:04 +00001088STATIC void compile_import_name(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01001089 apply_to_single_or_list(comp, pns->nodes[0], PN_dotted_as_names, compile_dotted_as_name);
1090}
1091
Damien George969a6b32014-12-10 22:07:04 +00001092STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George635543c2014-04-10 12:56:52 +01001093 mp_parse_node_t pn_import_source = pns->nodes[0];
1094
1095 // extract the preceeding .'s (if any) for a relative import, to compute the import level
1096 uint import_level = 0;
1097 do {
1098 mp_parse_node_t pn_rel;
1099 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)) {
1100 // This covers relative imports with dots only like "from .. import"
1101 pn_rel = pn_import_source;
1102 pn_import_source = MP_PARSE_NODE_NULL;
1103 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_import_source, PN_import_from_2b)) {
1104 // This covers relative imports starting with dot(s) like "from .foo import"
1105 mp_parse_node_struct_t *pns_2b = (mp_parse_node_struct_t*)pn_import_source;
1106 pn_rel = pns_2b->nodes[0];
1107 pn_import_source = pns_2b->nodes[1];
1108 assert(!MP_PARSE_NODE_IS_NULL(pn_import_source)); // should not be
1109 } else {
1110 // Not a relative import
1111 break;
1112 }
1113
1114 // get the list of . and/or ...'s
1115 mp_parse_node_t *nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +00001116 int n = mp_parse_node_extract_list(&pn_rel, PN_one_or_more_period_or_ellipsis, &nodes);
Damien George635543c2014-04-10 12:56:52 +01001117
1118 // count the total number of .'s
1119 for (int i = 0; i < n; i++) {
1120 if (MP_PARSE_NODE_IS_TOKEN_KIND(nodes[i], MP_TOKEN_DEL_PERIOD)) {
1121 import_level++;
1122 } else {
1123 // should be an MP_TOKEN_ELLIPSIS
1124 import_level += 3;
1125 }
1126 }
1127 } while (0);
1128
Damiend99b0522013-12-21 18:17:45 +00001129 if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
Damien George635543c2014-04-10 12:56:52 +01001130 EMIT_ARG(load_const_small_int, import_level);
Damiendb4c3612013-12-10 17:27:24 +00001131
1132 // build the "fromlist" tuple
Damien George59fba2d2015-06-25 14:42:13 +00001133 EMIT_ARG(load_const_str, MP_QSTR__star_);
Damien Georgeb9791222014-01-23 00:34:21 +00001134 EMIT_ARG(build_tuple, 1);
Damiendb4c3612013-12-10 17:27:24 +00001135
1136 // do the import
Damien George635543c2014-04-10 12:56:52 +01001137 qstr dummy_q;
1138 do_import_name(comp, pn_import_source, &dummy_q);
Damien429d7192013-10-04 19:53:11 +01001139 EMIT(import_star);
Damiendb4c3612013-12-10 17:27:24 +00001140
Damien429d7192013-10-04 19:53:11 +01001141 } else {
Damien George635543c2014-04-10 12:56:52 +01001142 EMIT_ARG(load_const_small_int, import_level);
Damiendb4c3612013-12-10 17:27:24 +00001143
1144 // build the "fromlist" tuple
Damiend99b0522013-12-21 18:17:45 +00001145 mp_parse_node_t *pn_nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +00001146 int n = mp_parse_node_extract_list(&pns->nodes[1], PN_import_as_names, &pn_nodes);
Damiendb4c3612013-12-10 17:27:24 +00001147 for (int i = 0; i < n; i++) {
Damiend99b0522013-12-21 18:17:45 +00001148 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
1149 mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
1150 qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
Damien George59fba2d2015-06-25 14:42:13 +00001151 EMIT_ARG(load_const_str, id2);
Damiendb4c3612013-12-10 17:27:24 +00001152 }
Damien Georgeb9791222014-01-23 00:34:21 +00001153 EMIT_ARG(build_tuple, n);
Damiendb4c3612013-12-10 17:27:24 +00001154
1155 // do the import
Damien George635543c2014-04-10 12:56:52 +01001156 qstr dummy_q;
1157 do_import_name(comp, pn_import_source, &dummy_q);
Damien429d7192013-10-04 19:53:11 +01001158 for (int i = 0; i < n; i++) {
Damiend99b0522013-12-21 18:17:45 +00001159 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
1160 mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
1161 qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
Damien Georgeb9791222014-01-23 00:34:21 +00001162 EMIT_ARG(import_from, id2);
Damiend99b0522013-12-21 18:17:45 +00001163 if (MP_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
Damien George542bd6b2015-03-26 14:42:40 +00001164 compile_store_id(comp, id2);
Damien429d7192013-10-04 19:53:11 +01001165 } else {
Damien George542bd6b2015-03-26 14:42:40 +00001166 compile_store_id(comp, MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
Damien429d7192013-10-04 19:53:11 +01001167 }
1168 }
1169 EMIT(pop_top);
1170 }
1171}
1172
Damien George584ba672014-12-21 17:26:45 +00001173STATIC void compile_declare_global(compiler_t *comp, mp_parse_node_t pn, qstr qst) {
1174 bool added;
1175 id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qst, &added);
Damien George558a0162015-09-07 16:55:02 +01001176 if (!added && id_info->kind != ID_INFO_KIND_GLOBAL_EXPLICIT) {
1177 compile_syntax_error(comp, pn, "identifier redefined as global");
Damien George584ba672014-12-21 17:26:45 +00001178 return;
1179 }
1180 id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
1181
1182 // if the id exists in the global scope, set its kind to EXPLICIT_GLOBAL
1183 id_info = scope_find_global(comp->scope_cur, qst);
1184 if (id_info != NULL) {
1185 id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
1186 }
1187}
1188
Damien George969a6b32014-12-10 22:07:04 +00001189STATIC void compile_global_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George36db6bc2014-05-07 17:24:22 +01001190 if (comp->pass == MP_PASS_SCOPE) {
Damien George584ba672014-12-21 17:26:45 +00001191 mp_parse_node_t *nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +00001192 int n = mp_parse_node_extract_list(&pns->nodes[0], PN_name_list, &nodes);
Damien George584ba672014-12-21 17:26:45 +00001193 for (int i = 0; i < n; i++) {
1194 compile_declare_global(comp, (mp_parse_node_t)pns, MP_PARSE_NODE_LEAF_ARG(nodes[i]));
Damien429d7192013-10-04 19:53:11 +01001195 }
1196 }
1197}
1198
Damien George584ba672014-12-21 17:26:45 +00001199STATIC void compile_declare_nonlocal(compiler_t *comp, mp_parse_node_t pn, qstr qst) {
1200 bool added;
1201 id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qst, &added);
Damien George0d105172016-09-30 13:53:00 +10001202 if (added) {
1203 scope_find_local_and_close_over(comp->scope_cur, id_info, qst);
1204 if (id_info->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
1205 compile_syntax_error(comp, pn, "no binding for nonlocal found");
1206 }
1207 } else if (id_info->kind != ID_INFO_KIND_FREE) {
Damien George558a0162015-09-07 16:55:02 +01001208 compile_syntax_error(comp, pn, "identifier redefined as nonlocal");
Damien George584ba672014-12-21 17:26:45 +00001209 }
Damien George584ba672014-12-21 17:26:45 +00001210}
1211
Damien George969a6b32014-12-10 22:07:04 +00001212STATIC void compile_nonlocal_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George36db6bc2014-05-07 17:24:22 +01001213 if (comp->pass == MP_PASS_SCOPE) {
Damien George584ba672014-12-21 17:26:45 +00001214 if (comp->scope_cur->kind == SCOPE_MODULE) {
1215 compile_syntax_error(comp, (mp_parse_node_t)pns, "can't declare nonlocal in outer code");
1216 return;
1217 }
1218 mp_parse_node_t *nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +00001219 int n = mp_parse_node_extract_list(&pns->nodes[0], PN_name_list, &nodes);
Damien George584ba672014-12-21 17:26:45 +00001220 for (int i = 0; i < n; i++) {
1221 compile_declare_nonlocal(comp, (mp_parse_node_t)pns, MP_PARSE_NODE_LEAF_ARG(nodes[i]));
Damien429d7192013-10-04 19:53:11 +01001222 }
1223 }
1224}
1225
Damien George969a6b32014-12-10 22:07:04 +00001226STATIC void compile_assert_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George24df30c2016-08-26 22:28:22 +10001227 // with optimisations enabled we don't compile assertions
1228 if (MP_STATE_VM(mp_optimise_value) != 0) {
1229 return;
1230 }
1231
Damien George6f355fd2014-04-10 14:11:31 +01001232 uint l_end = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +01001233 c_if_cond(comp, pns->nodes[0], true, l_end);
Damien George542bd6b2015-03-26 14:42:40 +00001234 EMIT_LOAD_GLOBAL(MP_QSTR_AssertionError); // we load_global instead of load_id, to be consistent with CPython
Damiend99b0522013-12-21 18:17:45 +00001235 if (!MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Damien429d7192013-10-04 19:53:11 +01001236 // assertion message
1237 compile_node(comp, pns->nodes[1]);
Damien George922ddd62014-04-09 12:43:17 +01001238 EMIT_ARG(call_function, 1, 0, 0);
Damien429d7192013-10-04 19:53:11 +01001239 }
Damien Georgeb9791222014-01-23 00:34:21 +00001240 EMIT_ARG(raise_varargs, 1);
1241 EMIT_ARG(label_assign, l_end);
Damien429d7192013-10-04 19:53:11 +01001242}
1243
Damien George969a6b32014-12-10 22:07:04 +00001244STATIC void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George6f355fd2014-04-10 14:11:31 +01001245 uint l_end = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +01001246
Damien George65dc9602015-08-14 12:24:11 +01001247 // optimisation: don't emit anything when "if False"
Damien Georgeb0cbfb02016-11-13 15:32:05 +11001248 if (!mp_parse_node_is_const_false(pns->nodes[0])) {
Damien George391db862014-10-17 17:57:33 +00001249 uint l_fail = comp_next_label(comp);
1250 c_if_cond(comp, pns->nodes[0], false, l_fail); // if condition
Damien429d7192013-10-04 19:53:11 +01001251
Damien George391db862014-10-17 17:57:33 +00001252 compile_node(comp, pns->nodes[1]); // if block
Damien Georgeaf6edc62014-04-02 16:12:28 +01001253
Damien George65dc9602015-08-14 12:24:11 +01001254 // optimisation: skip everything else when "if True"
Damien Georgeb0cbfb02016-11-13 15:32:05 +11001255 if (mp_parse_node_is_const_true(pns->nodes[0])) {
Damien George391db862014-10-17 17:57:33 +00001256 goto done;
1257 }
1258
1259 if (
Damien George65dc9602015-08-14 12:24:11 +01001260 // optimisation: don't jump over non-existent elif/else blocks
1261 !(MP_PARSE_NODE_IS_NULL(pns->nodes[2]) && MP_PARSE_NODE_IS_NULL(pns->nodes[3]))
Damien George391db862014-10-17 17:57:33 +00001262 // optimisation: don't jump if last instruction was return
1263 && !EMIT(last_emit_was_return_value)
1264 ) {
1265 // jump over elif/else blocks
1266 EMIT_ARG(jump, l_end);
1267 }
1268
1269 EMIT_ARG(label_assign, l_fail);
Damien Georgeaf6edc62014-04-02 16:12:28 +01001270 }
1271
Damien George235f9b32014-10-17 17:30:16 +00001272 // compile elif blocks (if any)
1273 mp_parse_node_t *pn_elif;
Damien Georgedfe944c2015-02-13 02:29:46 +00001274 int n_elif = mp_parse_node_extract_list(&pns->nodes[2], PN_if_stmt_elif_list, &pn_elif);
Damien George235f9b32014-10-17 17:30:16 +00001275 for (int i = 0; i < n_elif; i++) {
1276 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_elif[i], PN_if_stmt_elif)); // should be
1277 mp_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t*)pn_elif[i];
Damien429d7192013-10-04 19:53:11 +01001278
Damien George65dc9602015-08-14 12:24:11 +01001279 // optimisation: don't emit anything when "if False"
Damien Georgeb0cbfb02016-11-13 15:32:05 +11001280 if (!mp_parse_node_is_const_false(pns_elif->nodes[0])) {
Damien George391db862014-10-17 17:57:33 +00001281 uint l_fail = comp_next_label(comp);
1282 c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition
Damien429d7192013-10-04 19:53:11 +01001283
Damien George391db862014-10-17 17:57:33 +00001284 compile_node(comp, pns_elif->nodes[1]); // elif block
1285
Damien George65dc9602015-08-14 12:24:11 +01001286 // optimisation: skip everything else when "elif True"
Damien Georgeb0cbfb02016-11-13 15:32:05 +11001287 if (mp_parse_node_is_const_true(pns_elif->nodes[0])) {
Damien George391db862014-10-17 17:57:33 +00001288 goto done;
1289 }
1290
1291 // optimisation: don't jump if last instruction was return
1292 if (!EMIT(last_emit_was_return_value)) {
1293 EMIT_ARG(jump, l_end);
1294 }
1295 EMIT_ARG(label_assign, l_fail);
Damien429d7192013-10-04 19:53:11 +01001296 }
1297 }
1298
1299 // compile else block
1300 compile_node(comp, pns->nodes[3]); // can be null
1301
Damien George391db862014-10-17 17:57:33 +00001302done:
Damien Georgeb9791222014-01-23 00:34:21 +00001303 EMIT_ARG(label_assign, l_end);
Damien429d7192013-10-04 19:53:11 +01001304}
1305
Damien Georgecbddb272014-02-01 20:08:18 +00001306#define START_BREAK_CONTINUE_BLOCK \
Damien George090c9232014-10-17 14:08:49 +00001307 uint16_t old_break_label = comp->break_label; \
1308 uint16_t old_continue_label = comp->continue_label; \
1309 uint16_t old_break_continue_except_level = comp->break_continue_except_level; \
Damien George6f355fd2014-04-10 14:11:31 +01001310 uint break_label = comp_next_label(comp); \
1311 uint continue_label = comp_next_label(comp); \
Damien Georgecbddb272014-02-01 20:08:18 +00001312 comp->break_label = break_label; \
1313 comp->continue_label = continue_label; \
1314 comp->break_continue_except_level = comp->cur_except_level;
1315
1316#define END_BREAK_CONTINUE_BLOCK \
1317 comp->break_label = old_break_label; \
1318 comp->continue_label = old_continue_label; \
Damien George090c9232014-10-17 14:08:49 +00001319 comp->break_continue_except_level = old_break_continue_except_level;
Damien Georgecbddb272014-02-01 20:08:18 +00001320
Damien George969a6b32014-12-10 22:07:04 +00001321STATIC void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien Georgecbddb272014-02-01 20:08:18 +00001322 START_BREAK_CONTINUE_BLOCK
Damien429d7192013-10-04 19:53:11 +01001323
Damien Georgeb0cbfb02016-11-13 15:32:05 +11001324 if (!mp_parse_node_is_const_false(pns->nodes[0])) { // optimisation: don't emit anything for "while False"
Damien George391db862014-10-17 17:57:33 +00001325 uint top_label = comp_next_label(comp);
Damien Georgeb0cbfb02016-11-13 15:32:05 +11001326 if (!mp_parse_node_is_const_true(pns->nodes[0])) { // optimisation: don't jump to cond for "while True"
Damien George391db862014-10-17 17:57:33 +00001327 EMIT_ARG(jump, continue_label);
1328 }
1329 EMIT_ARG(label_assign, top_label);
1330 compile_node(comp, pns->nodes[1]); // body
1331 EMIT_ARG(label_assign, continue_label);
1332 c_if_cond(comp, pns->nodes[0], true, top_label); // condition
1333 }
Damience89a212013-10-15 22:25:17 +01001334
1335 // break/continue apply to outer loop (if any) in the else block
Damien Georgecbddb272014-02-01 20:08:18 +00001336 END_BREAK_CONTINUE_BLOCK
Damien429d7192013-10-04 19:53:11 +01001337
1338 compile_node(comp, pns->nodes[2]); // else
1339
Damien Georgeb9791222014-01-23 00:34:21 +00001340 EMIT_ARG(label_assign, break_label);
Damien429d7192013-10-04 19:53:11 +01001341}
1342
Damien Georgee181c0d2014-12-12 17:19:56 +00001343// This function compiles an optimised for-loop of the form:
1344// for <var> in range(<start>, <end>, <step>):
1345// <body>
1346// else:
1347// <else>
1348// <var> must be an identifier and <step> must be a small-int.
1349//
1350// Semantics of for-loop require:
1351// - final failing value should not be stored in the loop variable
1352// - if the loop never runs, the loop variable should never be assigned
1353// - assignments to <var>, <end> or <step> in the body do not alter the loop
1354// (<step> is a constant for us, so no need to worry about it changing)
1355//
1356// If <end> is a small-int, then the stack during the for-loop contains just
1357// the current value of <var>. Otherwise, the stack contains <end> then the
1358// current value of <var>.
Damien George6be0b0a2014-08-15 14:30:52 +01001359STATIC 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) {
Damien Georgecbddb272014-02-01 20:08:18 +00001360 START_BREAK_CONTINUE_BLOCK
Damienf72fd0e2013-11-06 20:20:49 +00001361
Damien George6f355fd2014-04-10 14:11:31 +01001362 uint top_label = comp_next_label(comp);
1363 uint entry_label = comp_next_label(comp);
Damienf72fd0e2013-11-06 20:20:49 +00001364
Damien Georgee181c0d2014-12-12 17:19:56 +00001365 // put the end value on the stack if it's not a small-int constant
1366 bool end_on_stack = !MP_PARSE_NODE_IS_SMALL_INT(pn_end);
1367 if (end_on_stack) {
1368 compile_node(comp, pn_end);
1369 }
1370
1371 // compile: start
Damienf72fd0e2013-11-06 20:20:49 +00001372 compile_node(comp, pn_start);
Damienf72fd0e2013-11-06 20:20:49 +00001373
Damien Georgeb9791222014-01-23 00:34:21 +00001374 EMIT_ARG(jump, entry_label);
1375 EMIT_ARG(label_assign, top_label);
Damienf72fd0e2013-11-06 20:20:49 +00001376
Damien Georgec33ce602014-12-11 17:35:23 +00001377 // duplicate next value and store it to var
1378 EMIT(dup_top);
Damien George3ff2d032014-03-31 18:02:22 +01001379 c_assign(comp, pn_var, ASSIGN_STORE);
1380
Damienf3822fc2013-11-09 20:12:03 +00001381 // compile body
1382 compile_node(comp, pn_body);
1383
Damien Georgeb9791222014-01-23 00:34:21 +00001384 EMIT_ARG(label_assign, continue_label);
Damien George600ae732014-01-21 23:48:04 +00001385
Damien Georgee181c0d2014-12-12 17:19:56 +00001386 // compile: var + step
Damienf72fd0e2013-11-06 20:20:49 +00001387 compile_node(comp, pn_step);
Damien Georged17926d2014-03-30 13:35:08 +01001388 EMIT_ARG(binary_op, MP_BINARY_OP_INPLACE_ADD);
Damienf72fd0e2013-11-06 20:20:49 +00001389
Damien Georgeb9791222014-01-23 00:34:21 +00001390 EMIT_ARG(label_assign, entry_label);
Damienf72fd0e2013-11-06 20:20:49 +00001391
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001392 // compile: if var <cond> end: goto top
Damien Georgee181c0d2014-12-12 17:19:56 +00001393 if (end_on_stack) {
1394 EMIT(dup_top_two);
1395 EMIT(rot_two);
1396 } else {
1397 EMIT(dup_top);
1398 compile_node(comp, pn_end);
1399 }
Paul Sokolovsky56e5ef22014-02-22 16:39:45 +02001400 assert(MP_PARSE_NODE_IS_SMALL_INT(pn_step));
1401 if (MP_PARSE_NODE_LEAF_SMALL_INT(pn_step) >= 0) {
Damien Georged17926d2014-03-30 13:35:08 +01001402 EMIT_ARG(binary_op, MP_BINARY_OP_LESS);
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001403 } else {
Damien Georged17926d2014-03-30 13:35:08 +01001404 EMIT_ARG(binary_op, MP_BINARY_OP_MORE);
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001405 }
Damien George63f38322015-02-28 15:04:06 +00001406 EMIT_ARG(pop_jump_if, true, top_label);
Damienf72fd0e2013-11-06 20:20:49 +00001407
1408 // break/continue apply to outer loop (if any) in the else block
Damien Georgecbddb272014-02-01 20:08:18 +00001409 END_BREAK_CONTINUE_BLOCK
Damienf72fd0e2013-11-06 20:20:49 +00001410
1411 compile_node(comp, pn_else);
1412
Damien Georgeb9791222014-01-23 00:34:21 +00001413 EMIT_ARG(label_assign, break_label);
Damien Georgee181c0d2014-12-12 17:19:56 +00001414
1415 // discard final value of var that failed the loop condition
1416 EMIT(pop_top);
1417
1418 // discard <end> value if it's on the stack
1419 if (end_on_stack) {
1420 EMIT(pop_top);
1421 }
Damienf72fd0e2013-11-06 20:20:49 +00001422}
1423
Damien George969a6b32014-12-10 22:07:04 +00001424STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damienf72fd0e2013-11-06 20:20:49 +00001425 // this bit optimises: for <x> in range(...), turning it into an explicitly incremented variable
1426 // this is actually slower, but uses no heap memory
1427 // for viper it will be much, much faster
pohmelie81ebba72016-01-27 23:23:11 +03001428 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)) {
Damiend99b0522013-12-21 18:17:45 +00001429 mp_parse_node_struct_t *pns_it = (mp_parse_node_struct_t*)pns->nodes[1];
pohmelie81ebba72016-01-27 23:23:11 +03001430 if (MP_PARSE_NODE_IS_ID(pns_it->nodes[0])
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001431 && MP_PARSE_NODE_LEAF_ARG(pns_it->nodes[0]) == MP_QSTR_range
Damien Georgefa03bbf2017-04-22 14:13:37 +10001432 && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pns_it->nodes[1]) == PN_trailer_paren) {
Damiend99b0522013-12-21 18:17:45 +00001433 mp_parse_node_t pn_range_args = ((mp_parse_node_struct_t*)pns_it->nodes[1])->nodes[0];
1434 mp_parse_node_t *args;
Damien Georgedfe944c2015-02-13 02:29:46 +00001435 int n_args = mp_parse_node_extract_list(&pn_range_args, PN_arglist, &args);
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001436 mp_parse_node_t pn_range_start;
1437 mp_parse_node_t pn_range_end;
1438 mp_parse_node_t pn_range_step;
1439 bool optimize = false;
Damienf72fd0e2013-11-06 20:20:49 +00001440 if (1 <= n_args && n_args <= 3) {
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001441 optimize = true;
Damienf72fd0e2013-11-06 20:20:49 +00001442 if (n_args == 1) {
Damien Georgeed9c93f2016-11-13 15:35:11 +11001443 pn_range_start = mp_parse_node_new_small_int(0);
Damienf72fd0e2013-11-06 20:20:49 +00001444 pn_range_end = args[0];
Damien Georgeed9c93f2016-11-13 15:35:11 +11001445 pn_range_step = mp_parse_node_new_small_int(1);
Damienf72fd0e2013-11-06 20:20:49 +00001446 } else if (n_args == 2) {
1447 pn_range_start = args[0];
1448 pn_range_end = args[1];
Damien Georgeed9c93f2016-11-13 15:35:11 +11001449 pn_range_step = mp_parse_node_new_small_int(1);
Damienf72fd0e2013-11-06 20:20:49 +00001450 } else {
1451 pn_range_start = args[0];
1452 pn_range_end = args[1];
1453 pn_range_step = args[2];
Damien Georgede9b5362017-04-05 10:50:26 +10001454 // the step must be a non-zero constant integer to do the optimisation
1455 if (!MP_PARSE_NODE_IS_SMALL_INT(pn_range_step)
1456 || MP_PARSE_NODE_LEAF_SMALL_INT(pn_range_step) == 0) {
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001457 optimize = false;
1458 }
Damienf72fd0e2013-11-06 20:20:49 +00001459 }
Damien George33ac0fd2015-12-08 21:05:14 +00001460 // arguments must be able to be compiled as standard expressions
1461 if (optimize && MP_PARSE_NODE_IS_STRUCT(pn_range_start)) {
1462 int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn_range_start);
1463 if (k == PN_arglist_star || k == PN_arglist_dbl_star || k == PN_argument) {
1464 optimize = false;
1465 }
1466 }
1467 if (optimize && MP_PARSE_NODE_IS_STRUCT(pn_range_end)) {
1468 int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn_range_end);
1469 if (k == PN_arglist_star || k == PN_arglist_dbl_star || k == PN_argument) {
1470 optimize = false;
1471 }
1472 }
Paul Sokolovsky899c69f2014-01-10 20:38:57 +02001473 }
1474 if (optimize) {
Damienf72fd0e2013-11-06 20:20:49 +00001475 compile_for_stmt_optimised_range(comp, pns->nodes[0], pn_range_start, pn_range_end, pn_range_step, pns->nodes[2], pns->nodes[3]);
1476 return;
1477 }
1478 }
1479 }
Damienf72fd0e2013-11-06 20:20:49 +00001480
Damien Georgecbddb272014-02-01 20:08:18 +00001481 START_BREAK_CONTINUE_BLOCK
Damien George25c84642014-05-30 15:20:41 +01001482 comp->break_label |= MP_EMIT_BREAK_FROM_FOR;
Damien429d7192013-10-04 19:53:11 +01001483
Damien George6f355fd2014-04-10 14:11:31 +01001484 uint pop_label = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +01001485
Damien429d7192013-10-04 19:53:11 +01001486 compile_node(comp, pns->nodes[1]); // iterator
Damien Georgef4df3aa2016-01-09 23:59:52 +00001487 EMIT_ARG(get_iter, true);
Damien Georgecbddb272014-02-01 20:08:18 +00001488 EMIT_ARG(label_assign, continue_label);
Damien Georgeb9791222014-01-23 00:34:21 +00001489 EMIT_ARG(for_iter, pop_label);
Damien429d7192013-10-04 19:53:11 +01001490 c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
1491 compile_node(comp, pns->nodes[2]); // body
Damien415eb6f2013-10-05 12:19:06 +01001492 if (!EMIT(last_emit_was_return_value)) {
Damien Georgecbddb272014-02-01 20:08:18 +00001493 EMIT_ARG(jump, continue_label);
Damien429d7192013-10-04 19:53:11 +01001494 }
Damien Georgeb9791222014-01-23 00:34:21 +00001495 EMIT_ARG(label_assign, pop_label);
Damien George30b42dd2017-01-17 15:30:18 +11001496 EMIT(for_iter_end);
Damien429d7192013-10-04 19:53:11 +01001497
1498 // break/continue apply to outer loop (if any) in the else block
Damien Georgecbddb272014-02-01 20:08:18 +00001499 END_BREAK_CONTINUE_BLOCK
Damien429d7192013-10-04 19:53:11 +01001500
Damien429d7192013-10-04 19:53:11 +01001501 compile_node(comp, pns->nodes[3]); // else (not tested)
1502
Damien Georgeb9791222014-01-23 00:34:21 +00001503 EMIT_ARG(label_assign, break_label);
Damien429d7192013-10-04 19:53:11 +01001504}
1505
Damien George6be0b0a2014-08-15 14:30:52 +01001506STATIC 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) {
Damien429d7192013-10-04 19:53:11 +01001507 // setup code
Damien George6f355fd2014-04-10 14:11:31 +01001508 uint l1 = comp_next_label(comp);
1509 uint success_label = comp_next_label(comp);
Damien Georgecbddb272014-02-01 20:08:18 +00001510
Damien Georgeb9791222014-01-23 00:34:21 +00001511 EMIT_ARG(setup_except, l1);
Damien George8dcc0c72014-03-27 10:55:21 +00001512 compile_increase_except_level(comp);
Damien Georgecbddb272014-02-01 20:08:18 +00001513
Damien429d7192013-10-04 19:53:11 +01001514 compile_node(comp, pn_body); // body
1515 EMIT(pop_block);
Damien George069a35e2014-04-10 17:22:19 +00001516 EMIT_ARG(jump, success_label); // jump over exception handler
1517
1518 EMIT_ARG(label_assign, l1); // start of exception handler
Damien Georgeb601d952014-06-30 05:17:25 +01001519 EMIT(start_except_handler);
Damien George069a35e2014-04-10 17:22:19 +00001520
Damien Georgef0406852016-09-27 12:37:21 +10001521 // at this point the top of the stack contains the exception instance that was raised
1522
Damien George6f355fd2014-04-10 14:11:31 +01001523 uint l2 = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +01001524
1525 for (int i = 0; i < n_except; i++) {
Damiend99b0522013-12-21 18:17:45 +00001526 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
1527 mp_parse_node_struct_t *pns_except = (mp_parse_node_struct_t*)pn_excepts[i];
Damien429d7192013-10-04 19:53:11 +01001528
1529 qstr qstr_exception_local = 0;
Damien George6f355fd2014-04-10 14:11:31 +01001530 uint end_finally_label = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +01001531
Damiend99b0522013-12-21 18:17:45 +00001532 if (MP_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +01001533 // this is a catch all exception handler
1534 if (i + 1 != n_except) {
Damien George18c059f2017-03-29 12:36:46 +11001535 compile_syntax_error(comp, pn_excepts[i], "default 'except' must be last");
Damien Georgec935d692015-01-13 23:33:16 +00001536 compile_decrease_except_level(comp);
Damien429d7192013-10-04 19:53:11 +01001537 return;
1538 }
1539 } else {
1540 // this exception handler requires a match to a certain type of exception
Damiend99b0522013-12-21 18:17:45 +00001541 mp_parse_node_t pns_exception_expr = pns_except->nodes[0];
1542 if (MP_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
1543 mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns_exception_expr;
1544 if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
Damien429d7192013-10-04 19:53:11 +01001545 // handler binds the exception to a local
1546 pns_exception_expr = pns3->nodes[0];
Damiend99b0522013-12-21 18:17:45 +00001547 qstr_exception_local = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]);
Damien429d7192013-10-04 19:53:11 +01001548 }
1549 }
1550 EMIT(dup_top);
1551 compile_node(comp, pns_exception_expr);
Damien Georged17926d2014-03-30 13:35:08 +01001552 EMIT_ARG(binary_op, MP_BINARY_OP_EXCEPTION_MATCH);
Damien George63f38322015-02-28 15:04:06 +00001553 EMIT_ARG(pop_jump_if, false, end_finally_label);
Damien429d7192013-10-04 19:53:11 +01001554 }
1555
Damien Georgef0406852016-09-27 12:37:21 +10001556 // either discard or store the exception instance
Damien429d7192013-10-04 19:53:11 +01001557 if (qstr_exception_local == 0) {
1558 EMIT(pop_top);
1559 } else {
Damien George542bd6b2015-03-26 14:42:40 +00001560 compile_store_id(comp, qstr_exception_local);
Damien429d7192013-10-04 19:53:11 +01001561 }
1562
Damien George6f355fd2014-04-10 14:11:31 +01001563 uint l3 = 0;
Damien429d7192013-10-04 19:53:11 +01001564 if (qstr_exception_local != 0) {
Damienb05d7072013-10-05 13:37:10 +01001565 l3 = comp_next_label(comp);
Damien Georgeb9791222014-01-23 00:34:21 +00001566 EMIT_ARG(setup_finally, l3);
Damien George8dcc0c72014-03-27 10:55:21 +00001567 compile_increase_except_level(comp);
Damien429d7192013-10-04 19:53:11 +01001568 }
1569 compile_node(comp, pns_except->nodes[1]);
1570 if (qstr_exception_local != 0) {
1571 EMIT(pop_block);
1572 }
1573 EMIT(pop_except);
1574 if (qstr_exception_local != 0) {
Damien Georgeb9791222014-01-23 00:34:21 +00001575 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
1576 EMIT_ARG(label_assign, l3);
1577 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien George542bd6b2015-03-26 14:42:40 +00001578 compile_store_id(comp, qstr_exception_local);
1579 compile_delete_id(comp, qstr_exception_local);
Damien Georgecbddb272014-02-01 20:08:18 +00001580
Damien George8dcc0c72014-03-27 10:55:21 +00001581 compile_decrease_except_level(comp);
Damien429d7192013-10-04 19:53:11 +01001582 EMIT(end_finally);
1583 }
Damien Georgeb9791222014-01-23 00:34:21 +00001584 EMIT_ARG(jump, l2);
1585 EMIT_ARG(label_assign, end_finally_label);
Damien Georgef0406852016-09-27 12:37:21 +10001586 EMIT_ARG(adjust_stack_size, 1); // stack adjust for the exception instance
Damien429d7192013-10-04 19:53:11 +01001587 }
1588
Damien George8dcc0c72014-03-27 10:55:21 +00001589 compile_decrease_except_level(comp);
Damien429d7192013-10-04 19:53:11 +01001590 EMIT(end_finally);
Damien Georgeb601d952014-06-30 05:17:25 +01001591 EMIT(end_except_handler);
Damien Georgecbddb272014-02-01 20:08:18 +00001592
Damien Georgeb9791222014-01-23 00:34:21 +00001593 EMIT_ARG(label_assign, success_label);
Damien429d7192013-10-04 19:53:11 +01001594 compile_node(comp, pn_else); // else block, can be null
Damien Georgeb9791222014-01-23 00:34:21 +00001595 EMIT_ARG(label_assign, l2);
Damien429d7192013-10-04 19:53:11 +01001596}
1597
Damien George6be0b0a2014-08-15 14:30:52 +01001598STATIC 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) {
Damien George6f355fd2014-04-10 14:11:31 +01001599 uint l_finally_block = comp_next_label(comp);
Damien Georgecbddb272014-02-01 20:08:18 +00001600
Damien Georgeb9791222014-01-23 00:34:21 +00001601 EMIT_ARG(setup_finally, l_finally_block);
Damien George8dcc0c72014-03-27 10:55:21 +00001602 compile_increase_except_level(comp);
Damien Georgecbddb272014-02-01 20:08:18 +00001603
Damien429d7192013-10-04 19:53:11 +01001604 if (n_except == 0) {
Damiend99b0522013-12-21 18:17:45 +00001605 assert(MP_PARSE_NODE_IS_NULL(pn_else));
Damien Georged66ae182014-04-10 17:28:54 +00001606 EMIT_ARG(adjust_stack_size, 3); // stack adjust for possible UNWIND_JUMP state
Damien429d7192013-10-04 19:53:11 +01001607 compile_node(comp, pn_body);
Damien Georged66ae182014-04-10 17:28:54 +00001608 EMIT_ARG(adjust_stack_size, -3);
Damien429d7192013-10-04 19:53:11 +01001609 } else {
1610 compile_try_except(comp, pn_body, n_except, pn_except, pn_else);
1611 }
1612 EMIT(pop_block);
Damien Georgeb9791222014-01-23 00:34:21 +00001613 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
1614 EMIT_ARG(label_assign, l_finally_block);
Damien429d7192013-10-04 19:53:11 +01001615 compile_node(comp, pn_finally);
Damien Georgecbddb272014-02-01 20:08:18 +00001616
Damien George8dcc0c72014-03-27 10:55:21 +00001617 compile_decrease_except_level(comp);
Damien429d7192013-10-04 19:53:11 +01001618 EMIT(end_finally);
Damien429d7192013-10-04 19:53:11 +01001619}
1620
Damien George969a6b32014-12-10 22:07:04 +00001621STATIC void compile_try_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George0bb97132015-02-27 14:25:47 +00001622 assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should be
1623 {
Damiend99b0522013-12-21 18:17:45 +00001624 mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
1625 if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
Damien429d7192013-10-04 19:53:11 +01001626 // just try-finally
Damiend99b0522013-12-21 18:17:45 +00001627 compile_try_finally(comp, pns->nodes[0], 0, NULL, MP_PARSE_NODE_NULL, pns2->nodes[0]);
1628 } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_except_and_more) {
Damien429d7192013-10-04 19:53:11 +01001629 // try-except and possibly else and/or finally
Damiend99b0522013-12-21 18:17:45 +00001630 mp_parse_node_t *pn_excepts;
Damien Georgedfe944c2015-02-13 02:29:46 +00001631 int n_except = mp_parse_node_extract_list(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
Damiend99b0522013-12-21 18:17:45 +00001632 if (MP_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
Damien429d7192013-10-04 19:53:11 +01001633 // no finally
1634 compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1]);
1635 } else {
1636 // have finally
Damiend99b0522013-12-21 18:17:45 +00001637 compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((mp_parse_node_struct_t*)pns2->nodes[2])->nodes[0]);
Damien429d7192013-10-04 19:53:11 +01001638 }
1639 } else {
1640 // just try-except
Damiend99b0522013-12-21 18:17:45 +00001641 mp_parse_node_t *pn_excepts;
Damien Georgedfe944c2015-02-13 02:29:46 +00001642 int n_except = mp_parse_node_extract_list(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
Damiend99b0522013-12-21 18:17:45 +00001643 compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, MP_PARSE_NODE_NULL);
Damien429d7192013-10-04 19:53:11 +01001644 }
Damien429d7192013-10-04 19:53:11 +01001645 }
1646}
1647
Damien George6be0b0a2014-08-15 14:30:52 +01001648STATIC void compile_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *nodes, mp_parse_node_t body) {
Damien429d7192013-10-04 19:53:11 +01001649 if (n == 0) {
1650 // no more pre-bits, compile the body of the with
1651 compile_node(comp, body);
1652 } else {
Damien George6f355fd2014-04-10 14:11:31 +01001653 uint l_end = comp_next_label(comp);
Damien George2c915e12016-04-07 08:53:24 +01001654 if (MICROPY_EMIT_NATIVE && comp->scope_cur->emit_options != MP_EMIT_OPT_BYTECODE) {
1655 // we need to allocate an extra label for the native emitter
1656 // it will use l_end+1 as an auxiliary label
1657 comp_next_label(comp);
1658 }
Damiend99b0522013-12-21 18:17:45 +00001659 if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
Damien429d7192013-10-04 19:53:11 +01001660 // this pre-bit is of the form "a as b"
Damiend99b0522013-12-21 18:17:45 +00001661 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)nodes[0];
Damien429d7192013-10-04 19:53:11 +01001662 compile_node(comp, pns->nodes[0]);
Damien Georgeb9791222014-01-23 00:34:21 +00001663 EMIT_ARG(setup_with, l_end);
Damien429d7192013-10-04 19:53:11 +01001664 c_assign(comp, pns->nodes[1], ASSIGN_STORE);
1665 } else {
1666 // this pre-bit is just an expression
1667 compile_node(comp, nodes[0]);
Damien Georgeb9791222014-01-23 00:34:21 +00001668 EMIT_ARG(setup_with, l_end);
Damien429d7192013-10-04 19:53:11 +01001669 EMIT(pop_top);
1670 }
Paul Sokolovsky44307d52014-03-29 04:10:11 +02001671 compile_increase_except_level(comp);
Damien429d7192013-10-04 19:53:11 +01001672 // compile additional pre-bits and the body
1673 compile_with_stmt_helper(comp, n - 1, nodes + 1, body);
1674 // finish this with block
Damien Georgece8b4e82016-04-07 08:50:38 +01001675 EMIT_ARG(with_cleanup, l_end);
Paul Sokolovsky44307d52014-03-29 04:10:11 +02001676 compile_decrease_except_level(comp);
Damien429d7192013-10-04 19:53:11 +01001677 EMIT(end_finally);
1678 }
1679}
1680
Damien George969a6b32014-12-10 22:07:04 +00001681STATIC void compile_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01001682 // get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
Damiend99b0522013-12-21 18:17:45 +00001683 mp_parse_node_t *nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +00001684 int n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
Damien429d7192013-10-04 19:53:11 +01001685 assert(n > 0);
1686
1687 // compile in a nested fashion
1688 compile_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
1689}
1690
pohmelie81ebba72016-01-27 23:23:11 +03001691STATIC void compile_yield_from(compiler_t *comp) {
Damien Georgef4df3aa2016-01-09 23:59:52 +00001692 EMIT_ARG(get_iter, false);
pohmelie81ebba72016-01-27 23:23:11 +03001693 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
1694 EMIT(yield_from);
1695}
1696
1697#if MICROPY_PY_ASYNC_AWAIT
1698STATIC void compile_await_object_method(compiler_t *comp, qstr method) {
1699 EMIT_ARG(load_method, method);
1700 EMIT_ARG(call_method, 0, 0, 0);
1701 compile_yield_from(comp);
1702}
1703
1704STATIC void compile_async_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
1705 // comp->break_label |= MP_EMIT_BREAK_FROM_FOR;
1706
1707 qstr context = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
1708 uint while_else_label = comp_next_label(comp);
1709 uint try_exception_label = comp_next_label(comp);
1710 uint try_else_label = comp_next_label(comp);
1711 uint try_finally_label = comp_next_label(comp);
1712
1713 compile_node(comp, pns->nodes[1]); // iterator
1714 compile_await_object_method(comp, MP_QSTR___aiter__);
1715 compile_store_id(comp, context);
1716
1717 START_BREAK_CONTINUE_BLOCK
1718
1719 EMIT_ARG(label_assign, continue_label);
1720
1721 EMIT_ARG(setup_except, try_exception_label);
1722 compile_increase_except_level(comp);
1723
1724 compile_load_id(comp, context);
1725 compile_await_object_method(comp, MP_QSTR___anext__);
1726 c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
1727 EMIT(pop_block);
1728 EMIT_ARG(jump, try_else_label);
1729
1730 EMIT_ARG(label_assign, try_exception_label);
1731 EMIT(start_except_handler);
1732 EMIT(dup_top);
1733 EMIT_LOAD_GLOBAL(MP_QSTR_StopAsyncIteration);
1734 EMIT_ARG(binary_op, MP_BINARY_OP_EXCEPTION_MATCH);
1735 EMIT_ARG(pop_jump_if, false, try_finally_label);
Damien Georgeb32c01b2016-09-28 11:52:13 +10001736 EMIT(pop_top); // pop exception instance
pohmelie81ebba72016-01-27 23:23:11 +03001737 EMIT(pop_except);
1738 EMIT_ARG(jump, while_else_label);
1739
1740 EMIT_ARG(label_assign, try_finally_label);
Damien Georgeb32c01b2016-09-28 11:52:13 +10001741 EMIT_ARG(adjust_stack_size, 1); // if we jump here, the exc is on the stack
pohmelie81ebba72016-01-27 23:23:11 +03001742 compile_decrease_except_level(comp);
1743 EMIT(end_finally);
1744 EMIT(end_except_handler);
1745
1746 EMIT_ARG(label_assign, try_else_label);
1747 compile_node(comp, pns->nodes[2]); // body
1748
1749 EMIT_ARG(jump, continue_label);
1750 // break/continue apply to outer loop (if any) in the else block
1751 END_BREAK_CONTINUE_BLOCK
1752
1753 EMIT_ARG(label_assign, while_else_label);
1754 compile_node(comp, pns->nodes[3]); // else
1755
1756 EMIT_ARG(label_assign, break_label);
1757}
1758
1759STATIC void compile_async_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *nodes, mp_parse_node_t body) {
1760 if (n == 0) {
1761 // no more pre-bits, compile the body of the with
1762 compile_node(comp, body);
1763 } else {
1764 uint try_exception_label = comp_next_label(comp);
1765 uint no_reraise_label = comp_next_label(comp);
1766 uint try_else_label = comp_next_label(comp);
1767 uint end_label = comp_next_label(comp);
1768 qstr context;
1769
1770 if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
1771 // this pre-bit is of the form "a as b"
1772 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)nodes[0];
1773 compile_node(comp, pns->nodes[0]);
1774 context = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
1775 compile_store_id(comp, context);
1776 compile_load_id(comp, context);
1777 compile_await_object_method(comp, MP_QSTR___aenter__);
1778 c_assign(comp, pns->nodes[1], ASSIGN_STORE);
1779 } else {
1780 // this pre-bit is just an expression
1781 compile_node(comp, nodes[0]);
1782 context = MP_PARSE_NODE_LEAF_ARG(nodes[0]);
1783 compile_store_id(comp, context);
1784 compile_load_id(comp, context);
1785 compile_await_object_method(comp, MP_QSTR___aenter__);
1786 EMIT(pop_top);
1787 }
1788
1789 compile_load_id(comp, context);
1790 EMIT_ARG(load_method, MP_QSTR___aexit__);
1791
1792 EMIT_ARG(setup_except, try_exception_label);
1793 compile_increase_except_level(comp);
1794 // compile additional pre-bits and the body
1795 compile_async_with_stmt_helper(comp, n - 1, nodes + 1, body);
1796 // finish this with block
1797 EMIT(pop_block);
1798 EMIT_ARG(jump, try_else_label); // jump over exception handler
1799
1800 EMIT_ARG(label_assign, try_exception_label); // start of exception handler
1801 EMIT(start_except_handler);
Damien Georgeb32c01b2016-09-28 11:52:13 +10001802
1803 // at this point the stack contains: ..., __aexit__, self, exc
1804 EMIT(dup_top);
1805 #if MICROPY_CPYTHON_COMPAT
1806 EMIT_ARG(load_attr, MP_QSTR___class__); // get type(exc)
1807 #else
1808 compile_load_id(comp, MP_QSTR_type);
pohmelie81ebba72016-01-27 23:23:11 +03001809 EMIT(rot_two);
Damien Georgeb32c01b2016-09-28 11:52:13 +10001810 EMIT_ARG(call_function, 1, 0, 0); // get type(exc)
1811 #endif
1812 EMIT(rot_two);
1813 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE); // dummy traceback value
1814 // at this point the stack contains: ..., __aexit__, self, type(exc), exc, None
pohmelie81ebba72016-01-27 23:23:11 +03001815 EMIT_ARG(call_method, 3, 0, 0);
Damien Georgeb32c01b2016-09-28 11:52:13 +10001816
pohmelie81ebba72016-01-27 23:23:11 +03001817 compile_yield_from(comp);
1818 EMIT_ARG(pop_jump_if, true, no_reraise_label);
1819 EMIT_ARG(raise_varargs, 0);
1820
1821 EMIT_ARG(label_assign, no_reraise_label);
1822 EMIT(pop_except);
1823 EMIT_ARG(jump, end_label);
1824
Damien Georgeb32c01b2016-09-28 11:52:13 +10001825 EMIT_ARG(adjust_stack_size, 3); // adjust for __aexit__, self, exc
pohmelie81ebba72016-01-27 23:23:11 +03001826 compile_decrease_except_level(comp);
1827 EMIT(end_finally);
1828 EMIT(end_except_handler);
1829
1830 EMIT_ARG(label_assign, try_else_label); // start of try-else handler
1831 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
1832 EMIT(dup_top);
1833 EMIT(dup_top);
1834 EMIT_ARG(call_method, 3, 0, 0);
1835 compile_yield_from(comp);
1836 EMIT(pop_top);
1837
1838 EMIT_ARG(label_assign, end_label);
1839
1840 }
1841}
1842
1843STATIC void compile_async_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
1844 // get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
1845 mp_parse_node_t *nodes;
1846 int n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
1847 assert(n > 0);
1848
1849 // compile in a nested fashion
1850 compile_async_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
1851}
1852
1853STATIC void compile_async_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
1854 assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[0]));
1855 mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
1856 if (MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_funcdef) {
1857 // async def
1858 compile_funcdef(comp, pns0);
1859 scope_t *fscope = (scope_t*)pns0->nodes[4];
1860 fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
1861 } else if (MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_for_stmt) {
1862 // async for
1863 compile_async_for_stmt(comp, pns0);
1864 } else {
1865 // async with
1866 assert(MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_with_stmt);
1867 compile_async_with_stmt(comp, pns0);
1868 }
1869}
1870#endif
1871
Damien George969a6b32014-12-10 22:07:04 +00001872STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00001873 if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
Damien5ac1b2e2013-10-18 19:58:12 +01001874 if (comp->is_repl && comp->scope_cur->kind == SCOPE_MODULE) {
1875 // for REPL, evaluate then print the expression
Damien George542bd6b2015-03-26 14:42:40 +00001876 compile_load_id(comp, MP_QSTR___repl_print__);
Damien5ac1b2e2013-10-18 19:58:12 +01001877 compile_node(comp, pns->nodes[0]);
Damien George922ddd62014-04-09 12:43:17 +01001878 EMIT_ARG(call_function, 1, 0, 0);
Damien5ac1b2e2013-10-18 19:58:12 +01001879 EMIT(pop_top);
1880
Damien429d7192013-10-04 19:53:11 +01001881 } else {
Damien5ac1b2e2013-10-18 19:58:12 +01001882 // for non-REPL, evaluate then discard the expression
Damien George5042bce2014-05-25 22:06:06 +01001883 if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !MP_PARSE_NODE_IS_ID(pns->nodes[0]))
Damien George7d414a12015-02-08 01:57:40 +00001884 || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)) {
Damien5ac1b2e2013-10-18 19:58:12 +01001885 // do nothing with a lonely constant
1886 } else {
1887 compile_node(comp, pns->nodes[0]); // just an expression
1888 EMIT(pop_top); // discard last result since this is a statement and leaves nothing on the stack
1889 }
Damien429d7192013-10-04 19:53:11 +01001890 }
Damien Georgeb948de32015-10-08 14:26:01 +01001891 } else if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
Damiend99b0522013-12-21 18:17:45 +00001892 mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
1893 int kind = MP_PARSE_NODE_STRUCT_KIND(pns1);
Damien429d7192013-10-04 19:53:11 +01001894 if (kind == PN_expr_stmt_augassign) {
1895 c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
1896 compile_node(comp, pns1->nodes[1]); // rhs
Damiend99b0522013-12-21 18:17:45 +00001897 assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
Damien Georged17926d2014-03-30 13:35:08 +01001898 mp_binary_op_t op;
Damiend99b0522013-12-21 18:17:45 +00001899 switch (MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0])) {
Damien Georged17926d2014-03-30 13:35:08 +01001900 case MP_TOKEN_DEL_PIPE_EQUAL: op = MP_BINARY_OP_INPLACE_OR; break;
1901 case MP_TOKEN_DEL_CARET_EQUAL: op = MP_BINARY_OP_INPLACE_XOR; break;
1902 case MP_TOKEN_DEL_AMPERSAND_EQUAL: op = MP_BINARY_OP_INPLACE_AND; break;
1903 case MP_TOKEN_DEL_DBL_LESS_EQUAL: op = MP_BINARY_OP_INPLACE_LSHIFT; break;
1904 case MP_TOKEN_DEL_DBL_MORE_EQUAL: op = MP_BINARY_OP_INPLACE_RSHIFT; break;
1905 case MP_TOKEN_DEL_PLUS_EQUAL: op = MP_BINARY_OP_INPLACE_ADD; break;
1906 case MP_TOKEN_DEL_MINUS_EQUAL: op = MP_BINARY_OP_INPLACE_SUBTRACT; break;
1907 case MP_TOKEN_DEL_STAR_EQUAL: op = MP_BINARY_OP_INPLACE_MULTIPLY; break;
1908 case MP_TOKEN_DEL_DBL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_FLOOR_DIVIDE; break;
1909 case MP_TOKEN_DEL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_TRUE_DIVIDE; break;
1910 case MP_TOKEN_DEL_PERCENT_EQUAL: op = MP_BINARY_OP_INPLACE_MODULO; break;
Damien Georged2d64f02015-01-14 21:32:42 +00001911 case MP_TOKEN_DEL_DBL_STAR_EQUAL: default: op = MP_BINARY_OP_INPLACE_POWER; break;
Damien429d7192013-10-04 19:53:11 +01001912 }
Damien George7e5fb242014-02-01 22:18:47 +00001913 EMIT_ARG(binary_op, op);
Damien429d7192013-10-04 19:53:11 +01001914 c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
1915 } else if (kind == PN_expr_stmt_assign_list) {
Damiend99b0522013-12-21 18:17:45 +00001916 int rhs = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1) - 1;
Damien Georgeb948de32015-10-08 14:26:01 +01001917 compile_node(comp, pns1->nodes[rhs]); // rhs
Damien429d7192013-10-04 19:53:11 +01001918 // following CPython, we store left-most first
1919 if (rhs > 0) {
1920 EMIT(dup_top);
1921 }
1922 c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
1923 for (int i = 0; i < rhs; i++) {
1924 if (i + 1 < rhs) {
1925 EMIT(dup_top);
1926 }
Damien Georgeb948de32015-10-08 14:26:01 +01001927 c_assign(comp, pns1->nodes[i], ASSIGN_STORE); // middle store
Damien429d7192013-10-04 19:53:11 +01001928 }
Damien George0bb97132015-02-27 14:25:47 +00001929 } else {
Damien Georgeb948de32015-10-08 14:26:01 +01001930 plain_assign:
Damien George42e0c592015-03-14 13:11:35 +00001931 if (MICROPY_COMP_DOUBLE_TUPLE_ASSIGN
Damien Georgeb948de32015-10-08 14:26:01 +01001932 && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_testlist_star_expr)
Damiend99b0522013-12-21 18:17:45 +00001933 && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
Damien Georgeb948de32015-10-08 14:26:01 +01001934 && MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[1]) == 2
Damiend99b0522013-12-21 18:17:45 +00001935 && MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[0]) == 2) {
Damien George65dc9602015-08-14 12:24:11 +01001936 // optimisation for a, b = c, d
Damien Georgeb948de32015-10-08 14:26:01 +01001937 mp_parse_node_struct_t *pns10 = (mp_parse_node_struct_t*)pns->nodes[1];
Damien George4dea9222015-04-09 15:29:54 +00001938 mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
Damien George495d7812014-04-08 17:51:47 +01001939 if (MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[0], PN_star_expr)
1940 || MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[1], PN_star_expr)) {
1941 // can't optimise when it's a star expression on the lhs
1942 goto no_optimisation;
1943 }
Damien429d7192013-10-04 19:53:11 +01001944 compile_node(comp, pns10->nodes[0]); // rhs
1945 compile_node(comp, pns10->nodes[1]); // rhs
1946 EMIT(rot_two);
1947 c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
1948 c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
Damien George42e0c592015-03-14 13:11:35 +00001949 } else if (MICROPY_COMP_TRIPLE_TUPLE_ASSIGN
Damien Georgeb948de32015-10-08 14:26:01 +01001950 && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_testlist_star_expr)
Damiend99b0522013-12-21 18:17:45 +00001951 && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
Damien Georgeb948de32015-10-08 14:26:01 +01001952 && MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[1]) == 3
Damiend99b0522013-12-21 18:17:45 +00001953 && MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[0]) == 3) {
Damien George65dc9602015-08-14 12:24:11 +01001954 // optimisation for a, b, c = d, e, f
Damien Georgeb948de32015-10-08 14:26:01 +01001955 mp_parse_node_struct_t *pns10 = (mp_parse_node_struct_t*)pns->nodes[1];
Damien George4dea9222015-04-09 15:29:54 +00001956 mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
Damien George495d7812014-04-08 17:51:47 +01001957 if (MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[0], PN_star_expr)
1958 || MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[1], PN_star_expr)
1959 || MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[2], PN_star_expr)) {
1960 // can't optimise when it's a star expression on the lhs
1961 goto no_optimisation;
1962 }
Damien429d7192013-10-04 19:53:11 +01001963 compile_node(comp, pns10->nodes[0]); // rhs
1964 compile_node(comp, pns10->nodes[1]); // rhs
1965 compile_node(comp, pns10->nodes[2]); // rhs
1966 EMIT(rot_three);
1967 EMIT(rot_two);
1968 c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
1969 c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
1970 c_assign(comp, pns0->nodes[2], ASSIGN_STORE); // lhs store
1971 } else {
Damien George495d7812014-04-08 17:51:47 +01001972 no_optimisation:
Damien Georgeb948de32015-10-08 14:26:01 +01001973 compile_node(comp, pns->nodes[1]); // rhs
Damien429d7192013-10-04 19:53:11 +01001974 c_assign(comp, pns->nodes[0], ASSIGN_STORE); // lhs store
1975 }
Damien429d7192013-10-04 19:53:11 +01001976 }
Damien Georgeb948de32015-10-08 14:26:01 +01001977 } else {
1978 goto plain_assign;
Damien429d7192013-10-04 19:53:11 +01001979 }
1980}
1981
Damien George6be0b0a2014-08-15 14:30:52 +01001982STATIC void c_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns, mp_binary_op_t binary_op) {
Damiend99b0522013-12-21 18:17:45 +00001983 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01001984 compile_node(comp, pns->nodes[0]);
1985 for (int i = 1; i < num_nodes; i += 1) {
1986 compile_node(comp, pns->nodes[i]);
Damien Georgeb9791222014-01-23 00:34:21 +00001987 EMIT_ARG(binary_op, binary_op);
Damien429d7192013-10-04 19:53:11 +01001988 }
1989}
1990
Damien George969a6b32014-12-10 22:07:04 +00001991STATIC void compile_test_if_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00001992 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
1993 mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns->nodes[1];
Damien429d7192013-10-04 19:53:11 +01001994
Damien George6f355fd2014-04-10 14:11:31 +01001995 uint l_fail = comp_next_label(comp);
1996 uint l_end = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +01001997 c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
1998 compile_node(comp, pns->nodes[0]); // success value
Damien Georgeb9791222014-01-23 00:34:21 +00001999 EMIT_ARG(jump, l_end);
2000 EMIT_ARG(label_assign, l_fail);
Damien Georged66ae182014-04-10 17:28:54 +00002001 EMIT_ARG(adjust_stack_size, -1); // adjust stack size
Damien429d7192013-10-04 19:53:11 +01002002 compile_node(comp, pns_test_if_else->nodes[1]); // failure value
Damien Georgeb9791222014-01-23 00:34:21 +00002003 EMIT_ARG(label_assign, l_end);
Damien429d7192013-10-04 19:53:11 +01002004}
2005
Damien George969a6b32014-12-10 22:07:04 +00002006STATIC void compile_lambdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George36db6bc2014-05-07 17:24:22 +01002007 if (comp->pass == MP_PASS_SCOPE) {
Damien429d7192013-10-04 19:53:11 +01002008 // create a new scope for this lambda
Damiend99b0522013-12-21 18:17:45 +00002009 scope_t *s = scope_new_and_link(comp, SCOPE_LAMBDA, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
Damien429d7192013-10-04 19:53:11 +01002010 // store the lambda scope so the compiling function (this one) can use it at each pass
Damiend99b0522013-12-21 18:17:45 +00002011 pns->nodes[2] = (mp_parse_node_t)s;
Damien429d7192013-10-04 19:53:11 +01002012 }
2013
2014 // get the scope for this lambda
2015 scope_t *this_scope = (scope_t*)pns->nodes[2];
2016
Damien George2c838942015-11-17 14:00:14 +00002017 // compile the lambda definition
2018 compile_funcdef_lambdef(comp, this_scope, pns->nodes[0], PN_varargslist);
Damien429d7192013-10-04 19:53:11 +01002019}
2020
Damien George7711afb2015-02-28 15:10:18 +00002021STATIC void compile_or_and_test(compiler_t *comp, mp_parse_node_struct_t *pns, bool cond) {
Damien George6f355fd2014-04-10 14:11:31 +01002022 uint l_end = comp_next_label(comp);
Damiend99b0522013-12-21 18:17:45 +00002023 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01002024 for (int i = 0; i < n; i += 1) {
2025 compile_node(comp, pns->nodes[i]);
2026 if (i + 1 < n) {
Damien George7711afb2015-02-28 15:10:18 +00002027 EMIT_ARG(jump_if_or_pop, cond, l_end);
Damien429d7192013-10-04 19:53:11 +01002028 }
2029 }
Damien Georgeb9791222014-01-23 00:34:21 +00002030 EMIT_ARG(label_assign, l_end);
Damien429d7192013-10-04 19:53:11 +01002031}
2032
Damien George7711afb2015-02-28 15:10:18 +00002033STATIC void compile_or_test(compiler_t *comp, mp_parse_node_struct_t *pns) {
2034 compile_or_and_test(comp, pns, true);
2035}
2036
Damien George969a6b32014-12-10 22:07:04 +00002037STATIC void compile_and_test(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George7711afb2015-02-28 15:10:18 +00002038 compile_or_and_test(comp, pns, false);
Damien429d7192013-10-04 19:53:11 +01002039}
2040
Damien George969a6b32014-12-10 22:07:04 +00002041STATIC void compile_not_test_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01002042 compile_node(comp, pns->nodes[0]);
Damien Georged17926d2014-03-30 13:35:08 +01002043 EMIT_ARG(unary_op, MP_UNARY_OP_NOT);
Damien429d7192013-10-04 19:53:11 +01002044}
2045
Damien George969a6b32014-12-10 22:07:04 +00002046STATIC void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002047 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01002048 compile_node(comp, pns->nodes[0]);
2049 bool multi = (num_nodes > 3);
Damien George6f355fd2014-04-10 14:11:31 +01002050 uint l_fail = 0;
Damien429d7192013-10-04 19:53:11 +01002051 if (multi) {
Damienb05d7072013-10-05 13:37:10 +01002052 l_fail = comp_next_label(comp);
Damien429d7192013-10-04 19:53:11 +01002053 }
2054 for (int i = 1; i + 1 < num_nodes; i += 2) {
2055 compile_node(comp, pns->nodes[i + 1]);
2056 if (i + 2 < num_nodes) {
2057 EMIT(dup_top);
2058 EMIT(rot_three);
2059 }
Damien George7e5fb242014-02-01 22:18:47 +00002060 if (MP_PARSE_NODE_IS_TOKEN(pns->nodes[i])) {
Damien Georged17926d2014-03-30 13:35:08 +01002061 mp_binary_op_t op;
Damien George7e5fb242014-02-01 22:18:47 +00002062 switch (MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])) {
Damien Georged17926d2014-03-30 13:35:08 +01002063 case MP_TOKEN_OP_LESS: op = MP_BINARY_OP_LESS; break;
2064 case MP_TOKEN_OP_MORE: op = MP_BINARY_OP_MORE; break;
2065 case MP_TOKEN_OP_DBL_EQUAL: op = MP_BINARY_OP_EQUAL; break;
2066 case MP_TOKEN_OP_LESS_EQUAL: op = MP_BINARY_OP_LESS_EQUAL; break;
2067 case MP_TOKEN_OP_MORE_EQUAL: op = MP_BINARY_OP_MORE_EQUAL; break;
2068 case MP_TOKEN_OP_NOT_EQUAL: op = MP_BINARY_OP_NOT_EQUAL; break;
Damien Georged2d64f02015-01-14 21:32:42 +00002069 case MP_TOKEN_KW_IN: default: op = MP_BINARY_OP_IN; break;
Damien George7e5fb242014-02-01 22:18:47 +00002070 }
2071 EMIT_ARG(binary_op, op);
Damien George0bb97132015-02-27 14:25:47 +00002072 } else {
2073 assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])); // should be
Damiend99b0522013-12-21 18:17:45 +00002074 mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[i];
2075 int kind = MP_PARSE_NODE_STRUCT_KIND(pns2);
Damien429d7192013-10-04 19:53:11 +01002076 if (kind == PN_comp_op_not_in) {
Damien Georged17926d2014-03-30 13:35:08 +01002077 EMIT_ARG(binary_op, MP_BINARY_OP_NOT_IN);
Damien George0bb97132015-02-27 14:25:47 +00002078 } else {
2079 assert(kind == PN_comp_op_is); // should be
Damiend99b0522013-12-21 18:17:45 +00002080 if (MP_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
Damien Georged17926d2014-03-30 13:35:08 +01002081 EMIT_ARG(binary_op, MP_BINARY_OP_IS);
Damien429d7192013-10-04 19:53:11 +01002082 } else {
Damien Georged17926d2014-03-30 13:35:08 +01002083 EMIT_ARG(binary_op, MP_BINARY_OP_IS_NOT);
Damien429d7192013-10-04 19:53:11 +01002084 }
Damien429d7192013-10-04 19:53:11 +01002085 }
Damien429d7192013-10-04 19:53:11 +01002086 }
2087 if (i + 2 < num_nodes) {
Damien George63f38322015-02-28 15:04:06 +00002088 EMIT_ARG(jump_if_or_pop, false, l_fail);
Damien429d7192013-10-04 19:53:11 +01002089 }
2090 }
2091 if (multi) {
Damien George6f355fd2014-04-10 14:11:31 +01002092 uint l_end = comp_next_label(comp);
Damien Georgeb9791222014-01-23 00:34:21 +00002093 EMIT_ARG(jump, l_end);
2094 EMIT_ARG(label_assign, l_fail);
Damien Georged66ae182014-04-10 17:28:54 +00002095 EMIT_ARG(adjust_stack_size, 1);
Damien429d7192013-10-04 19:53:11 +01002096 EMIT(rot_two);
2097 EMIT(pop_top);
Damien Georgeb9791222014-01-23 00:34:21 +00002098 EMIT_ARG(label_assign, l_end);
Damien429d7192013-10-04 19:53:11 +01002099 }
2100}
2101
Damien George969a6b32014-12-10 22:07:04 +00002102STATIC void compile_star_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George9d181f62014-04-27 16:55:27 +01002103 compile_syntax_error(comp, (mp_parse_node_t)pns, "*x must be assignment target");
Damien429d7192013-10-04 19:53:11 +01002104}
2105
Damien George969a6b32014-12-10 22:07:04 +00002106STATIC void compile_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien Georged17926d2014-03-30 13:35:08 +01002107 c_binary_op(comp, pns, MP_BINARY_OP_OR);
Damien429d7192013-10-04 19:53:11 +01002108}
2109
Damien George969a6b32014-12-10 22:07:04 +00002110STATIC void compile_xor_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien Georged17926d2014-03-30 13:35:08 +01002111 c_binary_op(comp, pns, MP_BINARY_OP_XOR);
Damien429d7192013-10-04 19:53:11 +01002112}
2113
Damien George969a6b32014-12-10 22:07:04 +00002114STATIC void compile_and_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien Georged17926d2014-03-30 13:35:08 +01002115 c_binary_op(comp, pns, MP_BINARY_OP_AND);
Damien429d7192013-10-04 19:53:11 +01002116}
2117
Damien George969a6b32014-12-10 22:07:04 +00002118STATIC void compile_shift_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002119 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01002120 compile_node(comp, pns->nodes[0]);
2121 for (int i = 1; i + 1 < num_nodes; i += 2) {
2122 compile_node(comp, pns->nodes[i + 1]);
Damiend99b0522013-12-21 18:17:45 +00002123 if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_LESS)) {
Damien Georged17926d2014-03-30 13:35:08 +01002124 EMIT_ARG(binary_op, MP_BINARY_OP_LSHIFT);
Damien429d7192013-10-04 19:53:11 +01002125 } else {
Damien George0bb97132015-02-27 14:25:47 +00002126 assert(MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_MORE)); // should be
2127 EMIT_ARG(binary_op, MP_BINARY_OP_RSHIFT);
Damien429d7192013-10-04 19:53:11 +01002128 }
2129 }
2130}
2131
Damien George969a6b32014-12-10 22:07:04 +00002132STATIC void compile_arith_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002133 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01002134 compile_node(comp, pns->nodes[0]);
2135 for (int i = 1; i + 1 < num_nodes; i += 2) {
2136 compile_node(comp, pns->nodes[i + 1]);
Damiend99b0522013-12-21 18:17:45 +00002137 if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PLUS)) {
Damien Georged17926d2014-03-30 13:35:08 +01002138 EMIT_ARG(binary_op, MP_BINARY_OP_ADD);
Damien429d7192013-10-04 19:53:11 +01002139 } else {
Damien George0bb97132015-02-27 14:25:47 +00002140 assert(MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MINUS)); // should be
2141 EMIT_ARG(binary_op, MP_BINARY_OP_SUBTRACT);
Damien429d7192013-10-04 19:53:11 +01002142 }
2143 }
2144}
2145
Damien George969a6b32014-12-10 22:07:04 +00002146STATIC void compile_term(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002147 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01002148 compile_node(comp, pns->nodes[0]);
2149 for (int i = 1; i + 1 < num_nodes; i += 2) {
2150 compile_node(comp, pns->nodes[i + 1]);
Damiend99b0522013-12-21 18:17:45 +00002151 if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_STAR)) {
Damien Georged17926d2014-03-30 13:35:08 +01002152 EMIT_ARG(binary_op, MP_BINARY_OP_MULTIPLY);
Damiend99b0522013-12-21 18:17:45 +00002153 } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_SLASH)) {
Damien Georged17926d2014-03-30 13:35:08 +01002154 EMIT_ARG(binary_op, MP_BINARY_OP_FLOOR_DIVIDE);
Damiend99b0522013-12-21 18:17:45 +00002155 } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_SLASH)) {
Damien Georged17926d2014-03-30 13:35:08 +01002156 EMIT_ARG(binary_op, MP_BINARY_OP_TRUE_DIVIDE);
Damien429d7192013-10-04 19:53:11 +01002157 } else {
Damien George0bb97132015-02-27 14:25:47 +00002158 assert(MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PERCENT)); // should be
2159 EMIT_ARG(binary_op, MP_BINARY_OP_MODULO);
Damien429d7192013-10-04 19:53:11 +01002160 }
2161 }
2162}
2163
Damien George969a6b32014-12-10 22:07:04 +00002164STATIC void compile_factor_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01002165 compile_node(comp, pns->nodes[1]);
Damiend99b0522013-12-21 18:17:45 +00002166 if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_PLUS)) {
Damien Georged17926d2014-03-30 13:35:08 +01002167 EMIT_ARG(unary_op, MP_UNARY_OP_POSITIVE);
Damiend99b0522013-12-21 18:17:45 +00002168 } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_MINUS)) {
Damien Georged17926d2014-03-30 13:35:08 +01002169 EMIT_ARG(unary_op, MP_UNARY_OP_NEGATIVE);
Damien429d7192013-10-04 19:53:11 +01002170 } else {
Damien George0bb97132015-02-27 14:25:47 +00002171 assert(MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_TILDE)); // should be
2172 EMIT_ARG(unary_op, MP_UNARY_OP_INVERT);
Damien429d7192013-10-04 19:53:11 +01002173 }
2174}
2175
pohmelie81ebba72016-01-27 23:23:11 +03002176STATIC void compile_atom_expr_normal(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George35e2a4e2014-02-05 00:51:47 +00002177 // this is to handle special super() call
2178 comp->func_arg_is_super = MP_PARSE_NODE_IS_ID(pns->nodes[0]) && MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]) == MP_QSTR_super;
2179
2180 compile_generic_all_nodes(comp, pns);
pohmelie81ebba72016-01-27 23:23:11 +03002181}
Damien George3acaa282016-03-16 13:04:51 +00002182
pohmelie81ebba72016-01-27 23:23:11 +03002183STATIC void compile_power(compiler_t *comp, mp_parse_node_struct_t *pns) {
2184 compile_generic_all_nodes(comp, pns); // 2 nodes, arguments of power
2185 EMIT_ARG(binary_op, MP_BINARY_OP_POWER);
Damien George35e2a4e2014-02-05 00:51:47 +00002186}
2187
Paul Sokolovsky520e2f52014-02-12 18:31:30 +02002188STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_arglist, bool is_method_call, int n_positional_extra) {
Damien429d7192013-10-04 19:53:11 +01002189 // function to call is on top of stack
2190
Damien George35e2a4e2014-02-05 00:51:47 +00002191 // this is to handle special super() call
Damien Georgebbcd49a2014-02-06 20:30:16 +00002192 if (MP_PARSE_NODE_IS_NULL(pn_arglist) && comp->func_arg_is_super && comp->scope_cur->kind == SCOPE_FUNCTION) {
Damien George542bd6b2015-03-26 14:42:40 +00002193 compile_load_id(comp, MP_QSTR___class__);
Damien George01039b52014-12-21 17:44:27 +00002194 // look for first argument to function (assumes it's "self")
Damien George35e2a4e2014-02-05 00:51:47 +00002195 for (int i = 0; i < comp->scope_cur->id_info_len; i++) {
Damien George40c12722017-03-27 11:27:08 +11002196 id_info_t *id = &comp->scope_cur->id_info[i];
2197 if (id->flags & ID_FLAG_IS_PARAM) {
Damien George01039b52014-12-21 17:44:27 +00002198 // first argument found; load it and call super
Damien George40c12722017-03-27 11:27:08 +11002199 compile_load_id(comp, id->qst);
Damien George01039b52014-12-21 17:44:27 +00002200 EMIT_ARG(call_function, 2, 0, 0);
2201 return;
Damien George35e2a4e2014-02-05 00:51:47 +00002202 }
2203 }
Damien George01039b52014-12-21 17:44:27 +00002204 compile_syntax_error(comp, MP_PARSE_NODE_NULL, "super() call cannot find self"); // really a TypeError
Damien George35e2a4e2014-02-05 00:51:47 +00002205 return;
2206 }
Damien George35e2a4e2014-02-05 00:51:47 +00002207
Damien George2c0842b2014-04-27 16:46:51 +01002208 // get the list of arguments
2209 mp_parse_node_t *args;
Damien Georgedfe944c2015-02-13 02:29:46 +00002210 int n_args = mp_parse_node_extract_list(&pn_arglist, PN_arglist, &args);
Damien429d7192013-10-04 19:53:11 +01002211
Damien George2c0842b2014-04-27 16:46:51 +01002212 // compile the arguments
2213 // Rather than calling compile_node on the list, we go through the list of args
2214 // explicitly here so that we can count the number of arguments and give sensible
2215 // error messages.
2216 int n_positional = n_positional_extra;
2217 uint n_keyword = 0;
2218 uint star_flags = 0;
Delio Brignolie6978a42015-09-17 12:07:06 +02002219 mp_parse_node_struct_t *star_args_node = NULL, *dblstar_args_node = NULL;
Damien George2c0842b2014-04-27 16:46:51 +01002220 for (int i = 0; i < n_args; i++) {
2221 if (MP_PARSE_NODE_IS_STRUCT(args[i])) {
2222 mp_parse_node_struct_t *pns_arg = (mp_parse_node_struct_t*)args[i];
2223 if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_star) {
2224 if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) {
2225 compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "can't have multiple *x");
2226 return;
2227 }
2228 star_flags |= MP_EMIT_STAR_FLAG_SINGLE;
Delio Brignolie6978a42015-09-17 12:07:06 +02002229 star_args_node = pns_arg;
Damien George2c0842b2014-04-27 16:46:51 +01002230 } else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_dbl_star) {
2231 if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) {
2232 compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "can't have multiple **x");
2233 return;
2234 }
2235 star_flags |= MP_EMIT_STAR_FLAG_DOUBLE;
Delio Brignolie6978a42015-09-17 12:07:06 +02002236 dblstar_args_node = pns_arg;
Damien George2c0842b2014-04-27 16:46:51 +01002237 } else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_argument) {
Damien Georgeb948de32015-10-08 14:26:01 +01002238 if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns_arg->nodes[1], PN_comp_for)) {
Damien George2c0842b2014-04-27 16:46:51 +01002239 if (!MP_PARSE_NODE_IS_ID(pns_arg->nodes[0])) {
2240 compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "LHS of keyword arg must be an id");
2241 return;
2242 }
Damien George59fba2d2015-06-25 14:42:13 +00002243 EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns_arg->nodes[0]));
Damien Georgeb948de32015-10-08 14:26:01 +01002244 compile_node(comp, pns_arg->nodes[1]);
Damien George2c0842b2014-04-27 16:46:51 +01002245 n_keyword += 1;
2246 } else {
Damien George2c0842b2014-04-27 16:46:51 +01002247 compile_comprehension(comp, pns_arg, SCOPE_GEN_EXPR);
2248 n_positional++;
2249 }
2250 } else {
2251 goto normal_argument;
2252 }
2253 } else {
2254 normal_argument:
2255 if (n_keyword > 0) {
2256 compile_syntax_error(comp, args[i], "non-keyword arg after keyword arg");
2257 return;
2258 }
2259 compile_node(comp, args[i]);
2260 n_positional++;
2261 }
Damien429d7192013-10-04 19:53:11 +01002262 }
2263
Delio Brignolie6978a42015-09-17 12:07:06 +02002264 // compile the star/double-star arguments if we had them
Damien Georgefbcaf0e2015-09-23 11:47:01 +01002265 // if we had one but not the other then we load "null" as a place holder
2266 if (star_flags != 0) {
2267 if (star_args_node == NULL) {
2268 EMIT(load_null);
2269 } else {
2270 compile_node(comp, star_args_node->nodes[0]);
2271 }
2272 if (dblstar_args_node == NULL) {
2273 EMIT(load_null);
2274 } else {
2275 compile_node(comp, dblstar_args_node->nodes[0]);
2276 }
Delio Brignolie6978a42015-09-17 12:07:06 +02002277 }
2278
Damien George2c0842b2014-04-27 16:46:51 +01002279 // emit the function/method call
Damien429d7192013-10-04 19:53:11 +01002280 if (is_method_call) {
Damien George2c0842b2014-04-27 16:46:51 +01002281 EMIT_ARG(call_method, n_positional, n_keyword, star_flags);
Damien429d7192013-10-04 19:53:11 +01002282 } else {
Damien George2c0842b2014-04-27 16:46:51 +01002283 EMIT_ARG(call_function, n_positional, n_keyword, star_flags);
Damien429d7192013-10-04 19:53:11 +01002284 }
Damien429d7192013-10-04 19:53:11 +01002285}
2286
pohmelie81ebba72016-01-27 23:23:11 +03002287STATIC void compile_atom_expr_trailers(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002288 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien429d7192013-10-04 19:53:11 +01002289 for (int i = 0; i < num_nodes; i++) {
Damiend99b0522013-12-21 18:17:45 +00002290 if (i + 1 < num_nodes && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i], PN_trailer_period) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i + 1], PN_trailer_paren)) {
Damien429d7192013-10-04 19:53:11 +01002291 // optimisation for method calls a.f(...), following PyPy
Damiend99b0522013-12-21 18:17:45 +00002292 mp_parse_node_struct_t *pns_period = (mp_parse_node_struct_t*)pns->nodes[i];
2293 mp_parse_node_struct_t *pns_paren = (mp_parse_node_struct_t*)pns->nodes[i + 1];
Damien Georgeb9791222014-01-23 00:34:21 +00002294 EMIT_ARG(load_method, MP_PARSE_NODE_LEAF_ARG(pns_period->nodes[0])); // get the method
Damien Georgebbcd49a2014-02-06 20:30:16 +00002295 compile_trailer_paren_helper(comp, pns_paren->nodes[0], true, 0);
Damien429d7192013-10-04 19:53:11 +01002296 i += 1;
2297 } else {
2298 compile_node(comp, pns->nodes[i]);
2299 }
Damien George35e2a4e2014-02-05 00:51:47 +00002300 comp->func_arg_is_super = false;
Damien429d7192013-10-04 19:53:11 +01002301 }
2302}
2303
Damien429d7192013-10-04 19:53:11 +01002304// pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node
Damien George6be0b0a2014-08-15 14:30:52 +01002305STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind) {
Damiend99b0522013-12-21 18:17:45 +00002306 assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
2307 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
2308 mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
Damien429d7192013-10-04 19:53:11 +01002309
Damien George36db6bc2014-05-07 17:24:22 +01002310 if (comp->pass == MP_PASS_SCOPE) {
Damien429d7192013-10-04 19:53:11 +01002311 // create a new scope for this comprehension
Damiend99b0522013-12-21 18:17:45 +00002312 scope_t *s = scope_new_and_link(comp, kind, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
Damien429d7192013-10-04 19:53:11 +01002313 // store the comprehension scope so the compiling function (this one) can use it at each pass
Damiend99b0522013-12-21 18:17:45 +00002314 pns_comp_for->nodes[3] = (mp_parse_node_t)s;
Damien429d7192013-10-04 19:53:11 +01002315 }
2316
2317 // get the scope for this comprehension
2318 scope_t *this_scope = (scope_t*)pns_comp_for->nodes[3];
2319
2320 // compile the comprehension
2321 close_over_variables_etc(comp, this_scope, 0, 0);
2322
2323 compile_node(comp, pns_comp_for->nodes[1]); // source of the iterator
Damien George4d2bab12017-02-10 15:39:33 +11002324 if (kind == SCOPE_GEN_EXPR) {
2325 EMIT_ARG(get_iter, false);
2326 }
Damien George922ddd62014-04-09 12:43:17 +01002327 EMIT_ARG(call_function, 1, 0, 0);
Damien429d7192013-10-04 19:53:11 +01002328}
2329
Damien George969a6b32014-12-10 22:07:04 +00002330STATIC void compile_atom_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002331 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +01002332 // an empty tuple
Damiend99b0522013-12-21 18:17:45 +00002333 c_tuple(comp, MP_PARSE_NODE_NULL, NULL);
Damien George93b37262016-01-07 13:07:52 +00002334 } else {
2335 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
Damiend99b0522013-12-21 18:17:45 +00002336 pns = (mp_parse_node_struct_t*)pns->nodes[0];
2337 assert(!MP_PARSE_NODE_IS_NULL(pns->nodes[1]));
2338 if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
2339 mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
2340 if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
Damien429d7192013-10-04 19:53:11 +01002341 // tuple of one item, with trailing comma
Damiend99b0522013-12-21 18:17:45 +00002342 assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
Damien429d7192013-10-04 19:53:11 +01002343 c_tuple(comp, pns->nodes[0], NULL);
Damiend99b0522013-12-21 18:17:45 +00002344 } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
Damien429d7192013-10-04 19:53:11 +01002345 // tuple of many items
Damien429d7192013-10-04 19:53:11 +01002346 c_tuple(comp, pns->nodes[0], pns2);
Damiend99b0522013-12-21 18:17:45 +00002347 } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
Damien429d7192013-10-04 19:53:11 +01002348 // generator expression
2349 compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
2350 } else {
2351 // tuple with 2 items
2352 goto tuple_with_2_items;
2353 }
2354 } else {
2355 // tuple with 2 items
2356 tuple_with_2_items:
Damiend99b0522013-12-21 18:17:45 +00002357 c_tuple(comp, MP_PARSE_NODE_NULL, pns);
Damien429d7192013-10-04 19:53:11 +01002358 }
Damien429d7192013-10-04 19:53:11 +01002359 }
2360}
2361
Damien George969a6b32014-12-10 22:07:04 +00002362STATIC void compile_atom_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002363 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +01002364 // empty list
Damien Georgeb9791222014-01-23 00:34:21 +00002365 EMIT_ARG(build_list, 0);
Damiend99b0522013-12-21 18:17:45 +00002366 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
2367 mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[0];
2368 if (MP_PARSE_NODE_IS_STRUCT(pns2->nodes[1])) {
2369 mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns2->nodes[1];
2370 if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3b) {
Damien429d7192013-10-04 19:53:11 +01002371 // list of one item, with trailing comma
Damiend99b0522013-12-21 18:17:45 +00002372 assert(MP_PARSE_NODE_IS_NULL(pns3->nodes[0]));
Damien429d7192013-10-04 19:53:11 +01002373 compile_node(comp, pns2->nodes[0]);
Damien Georgeb9791222014-01-23 00:34:21 +00002374 EMIT_ARG(build_list, 1);
Damiend99b0522013-12-21 18:17:45 +00002375 } else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3c) {
Damien429d7192013-10-04 19:53:11 +01002376 // list of many items
2377 compile_node(comp, pns2->nodes[0]);
2378 compile_generic_all_nodes(comp, pns3);
Damien Georgeb9791222014-01-23 00:34:21 +00002379 EMIT_ARG(build_list, 1 + MP_PARSE_NODE_STRUCT_NUM_NODES(pns3));
Damiend99b0522013-12-21 18:17:45 +00002380 } else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_comp_for) {
Damien429d7192013-10-04 19:53:11 +01002381 // list comprehension
2382 compile_comprehension(comp, pns2, SCOPE_LIST_COMP);
2383 } else {
2384 // list with 2 items
2385 goto list_with_2_items;
2386 }
2387 } else {
2388 // list with 2 items
2389 list_with_2_items:
2390 compile_node(comp, pns2->nodes[0]);
2391 compile_node(comp, pns2->nodes[1]);
Damien Georgeb9791222014-01-23 00:34:21 +00002392 EMIT_ARG(build_list, 2);
Damien429d7192013-10-04 19:53:11 +01002393 }
2394 } else {
2395 // list with 1 item
2396 compile_node(comp, pns->nodes[0]);
Damien Georgeb9791222014-01-23 00:34:21 +00002397 EMIT_ARG(build_list, 1);
Damien429d7192013-10-04 19:53:11 +01002398 }
2399}
2400
Damien George969a6b32014-12-10 22:07:04 +00002401STATIC void compile_atom_brace(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002402 mp_parse_node_t pn = pns->nodes[0];
2403 if (MP_PARSE_NODE_IS_NULL(pn)) {
Damien429d7192013-10-04 19:53:11 +01002404 // empty dict
Damien Georgeb9791222014-01-23 00:34:21 +00002405 EMIT_ARG(build_map, 0);
Damiend99b0522013-12-21 18:17:45 +00002406 } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
2407 pns = (mp_parse_node_struct_t*)pn;
2408 if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
Damien429d7192013-10-04 19:53:11 +01002409 // dict with one element
Damien Georgeb9791222014-01-23 00:34:21 +00002410 EMIT_ARG(build_map, 1);
Damien429d7192013-10-04 19:53:11 +01002411 compile_node(comp, pn);
2412 EMIT(store_map);
Damiend99b0522013-12-21 18:17:45 +00002413 } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
2414 assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
2415 mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
2416 if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
Damien429d7192013-10-04 19:53:11 +01002417 // dict/set with multiple elements
2418
2419 // get tail elements (2nd, 3rd, ...)
Damiend99b0522013-12-21 18:17:45 +00002420 mp_parse_node_t *nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +00002421 int n = mp_parse_node_extract_list(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
Damien429d7192013-10-04 19:53:11 +01002422
2423 // first element sets whether it's a dict or set
2424 bool is_dict;
Damien Georgee37dcaa2014-12-27 17:07:16 +00002425 if (!MICROPY_PY_BUILTINS_SET || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
Damien429d7192013-10-04 19:53:11 +01002426 // a dictionary
Damien Georgeb9791222014-01-23 00:34:21 +00002427 EMIT_ARG(build_map, 1 + n);
Damien429d7192013-10-04 19:53:11 +01002428 compile_node(comp, pns->nodes[0]);
2429 EMIT(store_map);
2430 is_dict = true;
2431 } else {
2432 // a set
2433 compile_node(comp, pns->nodes[0]); // 1st value of set
2434 is_dict = false;
2435 }
2436
2437 // process rest of elements
2438 for (int i = 0; i < n; i++) {
Damien George50912e72015-01-20 11:55:10 +00002439 mp_parse_node_t pn_i = nodes[i];
2440 bool is_key_value = MP_PARSE_NODE_IS_STRUCT_KIND(pn_i, PN_dictorsetmaker_item);
2441 compile_node(comp, pn_i);
Damien429d7192013-10-04 19:53:11 +01002442 if (is_dict) {
2443 if (!is_key_value) {
Damien Georgef9b0e642017-03-29 12:44:27 +11002444 if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
2445 compile_syntax_error(comp, (mp_parse_node_t)pns, "invalid syntax");
2446 } else {
2447 compile_syntax_error(comp, (mp_parse_node_t)pns, "expecting key:value for dict");
2448 }
Damien429d7192013-10-04 19:53:11 +01002449 return;
2450 }
2451 EMIT(store_map);
2452 } else {
2453 if (is_key_value) {
Damien Georgef9b0e642017-03-29 12:44:27 +11002454 if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
2455 compile_syntax_error(comp, (mp_parse_node_t)pns, "invalid syntax");
2456 } else {
2457 compile_syntax_error(comp, (mp_parse_node_t)pns, "expecting just a value for set");
2458 }
Damien429d7192013-10-04 19:53:11 +01002459 return;
2460 }
2461 }
2462 }
2463
Damien Georgee37dcaa2014-12-27 17:07:16 +00002464 #if MICROPY_PY_BUILTINS_SET
Damien429d7192013-10-04 19:53:11 +01002465 // if it's a set, build it
2466 if (!is_dict) {
Damien Georgeb9791222014-01-23 00:34:21 +00002467 EMIT_ARG(build_set, 1 + n);
Damien429d7192013-10-04 19:53:11 +01002468 }
Damien Georgee37dcaa2014-12-27 17:07:16 +00002469 #endif
Damien George0bb97132015-02-27 14:25:47 +00002470 } else {
2471 assert(MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for); // should be
Damien429d7192013-10-04 19:53:11 +01002472 // dict/set comprehension
Damien Georgee37dcaa2014-12-27 17:07:16 +00002473 if (!MICROPY_PY_BUILTINS_SET || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
Damien429d7192013-10-04 19:53:11 +01002474 // a dictionary comprehension
2475 compile_comprehension(comp, pns, SCOPE_DICT_COMP);
2476 } else {
2477 // a set comprehension
2478 compile_comprehension(comp, pns, SCOPE_SET_COMP);
2479 }
Damien429d7192013-10-04 19:53:11 +01002480 }
2481 } else {
2482 // set with one element
2483 goto set_with_one_element;
2484 }
2485 } else {
2486 // set with one element
2487 set_with_one_element:
Damien Georgee37dcaa2014-12-27 17:07:16 +00002488 #if MICROPY_PY_BUILTINS_SET
Damien429d7192013-10-04 19:53:11 +01002489 compile_node(comp, pn);
Damien Georgeb9791222014-01-23 00:34:21 +00002490 EMIT_ARG(build_set, 1);
Damien Georgee37dcaa2014-12-27 17:07:16 +00002491 #else
2492 assert(0);
2493 #endif
Damien429d7192013-10-04 19:53:11 +01002494 }
2495}
2496
Damien George969a6b32014-12-10 22:07:04 +00002497STATIC void compile_trailer_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien Georgebbcd49a2014-02-06 20:30:16 +00002498 compile_trailer_paren_helper(comp, pns->nodes[0], false, 0);
Damien429d7192013-10-04 19:53:11 +01002499}
2500
Damien George969a6b32014-12-10 22:07:04 +00002501STATIC void compile_trailer_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01002502 // object who's index we want is on top of stack
2503 compile_node(comp, pns->nodes[0]); // the index
Damien George729f7b42014-04-17 22:10:53 +01002504 EMIT(load_subscr);
Damien429d7192013-10-04 19:53:11 +01002505}
2506
Damien George969a6b32014-12-10 22:07:04 +00002507STATIC void compile_trailer_period(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01002508 // object who's attribute we want is on top of stack
Damien Georgeb9791222014-01-23 00:34:21 +00002509 EMIT_ARG(load_attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // attribute to get
Damien429d7192013-10-04 19:53:11 +01002510}
2511
Damien George83204f32014-12-27 17:20:41 +00002512#if MICROPY_PY_BUILTINS_SLICE
Damien George969a6b32014-12-10 22:07:04 +00002513STATIC void compile_subscript_3_helper(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damiend99b0522013-12-21 18:17:45 +00002514 assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3); // should always be
2515 mp_parse_node_t pn = pns->nodes[0];
2516 if (MP_PARSE_NODE_IS_NULL(pn)) {
Damien429d7192013-10-04 19:53:11 +01002517 // [?:]
Damien Georgeb9791222014-01-23 00:34:21 +00002518 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
2519 EMIT_ARG(build_slice, 2);
Damiend99b0522013-12-21 18:17:45 +00002520 } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
2521 pns = (mp_parse_node_struct_t*)pn;
2522 if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
Damien Georgeb9791222014-01-23 00:34:21 +00002523 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien429d7192013-10-04 19:53:11 +01002524 pn = pns->nodes[0];
Damiend99b0522013-12-21 18:17:45 +00002525 if (MP_PARSE_NODE_IS_NULL(pn)) {
Damien429d7192013-10-04 19:53:11 +01002526 // [?::]
Damien Georgeb9791222014-01-23 00:34:21 +00002527 EMIT_ARG(build_slice, 2);
Damien429d7192013-10-04 19:53:11 +01002528 } else {
2529 // [?::x]
2530 compile_node(comp, pn);
Damien Georgeb9791222014-01-23 00:34:21 +00002531 EMIT_ARG(build_slice, 3);
Damien429d7192013-10-04 19:53:11 +01002532 }
Damiend99b0522013-12-21 18:17:45 +00002533 } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
Damien429d7192013-10-04 19:53:11 +01002534 compile_node(comp, pns->nodes[0]);
Damiend99b0522013-12-21 18:17:45 +00002535 assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
2536 pns = (mp_parse_node_struct_t*)pns->nodes[1];
2537 assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
2538 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien429d7192013-10-04 19:53:11 +01002539 // [?:x:]
Damien Georgeb9791222014-01-23 00:34:21 +00002540 EMIT_ARG(build_slice, 2);
Damien429d7192013-10-04 19:53:11 +01002541 } else {
2542 // [?:x:x]
2543 compile_node(comp, pns->nodes[0]);
Damien Georgeb9791222014-01-23 00:34:21 +00002544 EMIT_ARG(build_slice, 3);
Damien429d7192013-10-04 19:53:11 +01002545 }
2546 } else {
2547 // [?:x]
2548 compile_node(comp, pn);
Damien Georgeb9791222014-01-23 00:34:21 +00002549 EMIT_ARG(build_slice, 2);
Damien429d7192013-10-04 19:53:11 +01002550 }
2551 } else {
2552 // [?:x]
2553 compile_node(comp, pn);
Damien Georgeb9791222014-01-23 00:34:21 +00002554 EMIT_ARG(build_slice, 2);
Damien429d7192013-10-04 19:53:11 +01002555 }
2556}
2557
Damien George969a6b32014-12-10 22:07:04 +00002558STATIC void compile_subscript_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01002559 compile_node(comp, pns->nodes[0]); // start of slice
Damiend99b0522013-12-21 18:17:45 +00002560 assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
2561 compile_subscript_3_helper(comp, (mp_parse_node_struct_t*)pns->nodes[1]);
Damien429d7192013-10-04 19:53:11 +01002562}
2563
Damien George969a6b32014-12-10 22:07:04 +00002564STATIC void compile_subscript_3(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien Georgeb9791222014-01-23 00:34:21 +00002565 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien429d7192013-10-04 19:53:11 +01002566 compile_subscript_3_helper(comp, pns);
2567}
Damien George83204f32014-12-27 17:20:41 +00002568#endif // MICROPY_PY_BUILTINS_SLICE
Damien429d7192013-10-04 19:53:11 +01002569
Damien George969a6b32014-12-10 22:07:04 +00002570STATIC void compile_dictorsetmaker_item(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien429d7192013-10-04 19:53:11 +01002571 // if this is called then we are compiling a dict key:value pair
2572 compile_node(comp, pns->nodes[1]); // value
2573 compile_node(comp, pns->nodes[0]); // key
2574}
2575
Damien George969a6b32014-12-10 22:07:04 +00002576STATIC void compile_classdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien6cdd3af2013-10-05 18:08:26 +01002577 qstr cname = compile_classdef_helper(comp, pns, comp->scope_cur->emit_options);
Damien429d7192013-10-04 19:53:11 +01002578 // store class object into class name
Damien George542bd6b2015-03-26 14:42:40 +00002579 compile_store_id(comp, cname);
Damien429d7192013-10-04 19:53:11 +01002580}
2581
Damien George969a6b32014-12-10 22:07:04 +00002582STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George0e3329a2014-04-11 13:10:21 +00002583 if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) {
Damien Georgeb7ffdcc2014-04-08 16:41:02 +01002584 compile_syntax_error(comp, (mp_parse_node_t)pns, "'yield' outside function");
Damien429d7192013-10-04 19:53:11 +01002585 return;
2586 }
Damiend99b0522013-12-21 18:17:45 +00002587 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damien Georgeb9791222014-01-23 00:34:21 +00002588 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien429d7192013-10-04 19:53:11 +01002589 EMIT(yield_value);
Damiend99b0522013-12-21 18:17:45 +00002590 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
2591 pns = (mp_parse_node_struct_t*)pns->nodes[0];
Damien429d7192013-10-04 19:53:11 +01002592 compile_node(comp, pns->nodes[0]);
pohmelie81ebba72016-01-27 23:23:11 +03002593 compile_yield_from(comp);
Damien429d7192013-10-04 19:53:11 +01002594 } else {
2595 compile_node(comp, pns->nodes[0]);
2596 EMIT(yield_value);
2597 }
2598}
2599
pohmelie81ebba72016-01-27 23:23:11 +03002600#if MICROPY_PY_ASYNC_AWAIT
2601STATIC void compile_atom_expr_await(compiler_t *comp, mp_parse_node_struct_t *pns) {
2602 if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) {
2603 compile_syntax_error(comp, (mp_parse_node_t)pns, "'await' outside function");
2604 return;
2605 }
2606 compile_atom_expr_normal(comp, pns);
2607 compile_yield_from(comp);
2608}
2609#endif
2610
Damien George52552552017-02-24 13:43:43 +11002611STATIC mp_obj_t get_const_object(mp_parse_node_struct_t *pns) {
2612 #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
2613 // nodes are 32-bit pointers, but need to extract 64-bit object
2614 return (uint64_t)pns->nodes[0] | ((uint64_t)pns->nodes[1] << 32);
2615 #else
2616 return (mp_obj_t)pns->nodes[0];
2617 #endif
Damien George65ef6b72015-01-14 21:17:27 +00002618}
2619
Damien George7d414a12015-02-08 01:57:40 +00002620STATIC void compile_const_object(compiler_t *comp, mp_parse_node_struct_t *pns) {
Damien George52552552017-02-24 13:43:43 +11002621 EMIT_ARG(load_const_obj, get_const_object(pns));
Damien George7d414a12015-02-08 01:57:40 +00002622}
2623
Damiend99b0522013-12-21 18:17:45 +00002624typedef void (*compile_function_t)(compiler_t*, mp_parse_node_struct_t*);
Damien George3ff16ff2016-05-20 12:38:15 +01002625STATIC const compile_function_t compile_function[] = {
Damien George71019ae2017-02-15 10:58:05 +11002626// only define rules with a compile function
Damien429d7192013-10-04 19:53:11 +01002627#define c(f) compile_##f
Damien George1dc76af2014-02-26 16:57:08 +00002628#define DEF_RULE(rule, comp, kind, ...) comp,
Damien George71019ae2017-02-15 10:58:05 +11002629#define DEF_RULE_NC(rule, kind, ...)
Damien George51dfcb42015-01-01 20:27:54 +00002630#include "py/grammar.h"
Damien429d7192013-10-04 19:53:11 +01002631#undef c
2632#undef DEF_RULE
Damien George71019ae2017-02-15 10:58:05 +11002633#undef DEF_RULE_NC
Damien George7d414a12015-02-08 01:57:40 +00002634 compile_const_object,
Damien429d7192013-10-04 19:53:11 +01002635};
2636
Damien George6be0b0a2014-08-15 14:30:52 +01002637STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn) {
Damiend99b0522013-12-21 18:17:45 +00002638 if (MP_PARSE_NODE_IS_NULL(pn)) {
Damien429d7192013-10-04 19:53:11 +01002639 // pass
Paul Sokolovsky56e5ef22014-02-22 16:39:45 +02002640 } else if (MP_PARSE_NODE_IS_SMALL_INT(pn)) {
Damien George40f3c022014-07-03 13:25:24 +01002641 mp_int_t arg = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
Damien Georgeea235202016-02-11 22:30:53 +00002642 #if MICROPY_DYNAMIC_COMPILER
2643 mp_uint_t sign_mask = -(1 << (mp_dynamic_compiler.small_int_bits - 1));
2644 if ((arg & sign_mask) == 0 || (arg & sign_mask) == sign_mask) {
2645 // integer fits in target runtime's small-int
2646 EMIT_ARG(load_const_small_int, arg);
2647 } else {
2648 // integer doesn't fit, so create a multi-precision int object
2649 // (but only create the actual object on the last pass)
2650 if (comp->pass != MP_PASS_EMIT) {
2651 EMIT_ARG(load_const_obj, mp_const_none);
2652 } else {
2653 EMIT_ARG(load_const_obj, mp_obj_new_int_from_ll(arg));
2654 }
2655 }
2656 #else
Paul Sokolovsky56e5ef22014-02-22 16:39:45 +02002657 EMIT_ARG(load_const_small_int, arg);
Damien Georgeea235202016-02-11 22:30:53 +00002658 #endif
Damiend99b0522013-12-21 18:17:45 +00002659 } else if (MP_PARSE_NODE_IS_LEAF(pn)) {
Damien George831137b2015-12-17 13:13:18 +00002660 uintptr_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
Damiend99b0522013-12-21 18:17:45 +00002661 switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
Damien George542bd6b2015-03-26 14:42:40 +00002662 case MP_PARSE_NODE_ID: compile_load_id(comp, arg); break;
Damien George59fba2d2015-06-25 14:42:13 +00002663 case MP_PARSE_NODE_STRING: EMIT_ARG(load_const_str, arg); break;
2664 case MP_PARSE_NODE_BYTES:
2665 // only create and load the actual bytes object on the last pass
2666 if (comp->pass != MP_PASS_EMIT) {
2667 EMIT_ARG(load_const_obj, mp_const_none);
2668 } else {
Damien Georgec3f64d92015-11-27 12:23:18 +00002669 size_t len;
Damien George59fba2d2015-06-25 14:42:13 +00002670 const byte *data = qstr_data(arg, &len);
2671 EMIT_ARG(load_const_obj, mp_obj_new_bytes(data, len));
2672 }
2673 break;
Damien Georged2d64f02015-01-14 21:32:42 +00002674 case MP_PARSE_NODE_TOKEN: default:
Damiend99b0522013-12-21 18:17:45 +00002675 if (arg == MP_TOKEN_NEWLINE) {
Damien91d387d2013-10-09 15:09:52 +01002676 // this can occur when file_input lets through a NEWLINE (eg if file starts with a newline)
Damien5ac1b2e2013-10-18 19:58:12 +01002677 // or when single_input lets through a NEWLINE (user enters a blank line)
Damien91d387d2013-10-09 15:09:52 +01002678 // do nothing
2679 } else {
Damien Georgeb9791222014-01-23 00:34:21 +00002680 EMIT_ARG(load_const_tok, arg);
Damien91d387d2013-10-09 15:09:52 +01002681 }
2682 break;
Damien429d7192013-10-04 19:53:11 +01002683 }
2684 } else {
Damiend99b0522013-12-21 18:17:45 +00002685 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Damien George41125902015-03-26 16:44:14 +00002686 EMIT_ARG(set_source_line, pns->source_line);
Damien George71019ae2017-02-15 10:58:05 +11002687 assert(MP_PARSE_NODE_STRUCT_KIND(pns) <= PN_const_object);
Damien George65ef6b72015-01-14 21:17:27 +00002688 compile_function_t f = compile_function[MP_PARSE_NODE_STRUCT_KIND(pns)];
Damien Georgedeaa57a2016-10-12 10:20:48 +11002689 f(comp, pns);
Damien429d7192013-10-04 19:53:11 +01002690 }
2691}
2692
Damien George2ac4af62014-08-15 16:45:41 +01002693STATIC 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) {
Damien George9a569122015-11-23 16:50:42 +00002694 // check that **kw is last
2695 if ((comp->scope_cur->scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) {
2696 compile_syntax_error(comp, pn, "invalid syntax");
2697 return;
2698 }
2699
Damien George2827d622014-04-27 15:50:52 +01002700 qstr param_name = MP_QSTR_NULL;
2701 uint param_flag = ID_FLAG_IS_PARAM;
Damiend99b0522013-12-21 18:17:45 +00002702 if (MP_PARSE_NODE_IS_ID(pn)) {
2703 param_name = MP_PARSE_NODE_LEAF_ARG(pn);
Damien George8b19db02014-04-11 23:25:34 +01002704 if (comp->have_star) {
Damien George2827d622014-04-27 15:50:52 +01002705 // comes after a star, so counts as a keyword-only parameter
2706 comp->scope_cur->num_kwonly_args += 1;
Damien429d7192013-10-04 19:53:11 +01002707 } else {
Damien George2827d622014-04-27 15:50:52 +01002708 // comes before a star, so counts as a positional parameter
2709 comp->scope_cur->num_pos_args += 1;
Damien429d7192013-10-04 19:53:11 +01002710 }
Damienb14de212013-10-06 00:28:28 +01002711 } else {
Damiend99b0522013-12-21 18:17:45 +00002712 assert(MP_PARSE_NODE_IS_STRUCT(pn));
2713 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
2714 if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
2715 param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Damien George8b19db02014-04-11 23:25:34 +01002716 if (comp->have_star) {
Damien George2827d622014-04-27 15:50:52 +01002717 // comes after a star, so counts as a keyword-only parameter
2718 comp->scope_cur->num_kwonly_args += 1;
Damienb14de212013-10-06 00:28:28 +01002719 } else {
Damien George2827d622014-04-27 15:50:52 +01002720 // comes before a star, so counts as a positional parameter
2721 comp->scope_cur->num_pos_args += 1;
Damienb14de212013-10-06 00:28:28 +01002722 }
Damiend99b0522013-12-21 18:17:45 +00002723 } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
Damien George9a569122015-11-23 16:50:42 +00002724 if (comp->have_star) {
2725 // more than one star
2726 compile_syntax_error(comp, pn, "invalid syntax");
2727 return;
2728 }
Damien George8b19db02014-04-11 23:25:34 +01002729 comp->have_star = true;
Damien George2827d622014-04-27 15:50:52 +01002730 param_flag = ID_FLAG_IS_PARAM | ID_FLAG_IS_STAR_PARAM;
Damiend99b0522013-12-21 18:17:45 +00002731 if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
Damienb14de212013-10-06 00:28:28 +01002732 // bare star
2733 // TODO see http://www.python.org/dev/peps/pep-3102/
Damienb14de212013-10-06 00:28:28 +01002734 //assert(comp->scope_cur->num_dict_params == 0);
Damiend99b0522013-12-21 18:17:45 +00002735 } else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
Damienb14de212013-10-06 00:28:28 +01002736 // named star
Damien George8725f8f2014-02-15 19:33:11 +00002737 comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARARGS;
Damiend99b0522013-12-21 18:17:45 +00002738 param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Damien George0bb97132015-02-27 14:25:47 +00002739 } else {
2740 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)); // should be
Damien George8b19db02014-04-11 23:25:34 +01002741 // named star with possible annotation
Damien George8725f8f2014-02-15 19:33:11 +00002742 comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARARGS;
Damiend99b0522013-12-21 18:17:45 +00002743 pns = (mp_parse_node_struct_t*)pns->nodes[0];
2744 param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Damienb14de212013-10-06 00:28:28 +01002745 }
Damien George0bb97132015-02-27 14:25:47 +00002746 } else {
2747 assert(MP_PARSE_NODE_STRUCT_KIND(pns) == pn_dbl_star); // should be
Damiend99b0522013-12-21 18:17:45 +00002748 param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
Damien George2827d622014-04-27 15:50:52 +01002749 param_flag = ID_FLAG_IS_PARAM | ID_FLAG_IS_DBL_STAR_PARAM;
Damien George8725f8f2014-02-15 19:33:11 +00002750 comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARKEYWORDS;
Damien429d7192013-10-04 19:53:11 +01002751 }
Damien429d7192013-10-04 19:53:11 +01002752 }
2753
Damien George2827d622014-04-27 15:50:52 +01002754 if (param_name != MP_QSTR_NULL) {
Damien429d7192013-10-04 19:53:11 +01002755 bool added;
2756 id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, param_name, &added);
2757 if (!added) {
Damien George9d181f62014-04-27 16:55:27 +01002758 compile_syntax_error(comp, pn, "name reused for argument");
Damien429d7192013-10-04 19:53:11 +01002759 return;
2760 }
Damien429d7192013-10-04 19:53:11 +01002761 id_info->kind = ID_INFO_KIND_LOCAL;
Damien George2827d622014-04-27 15:50:52 +01002762 id_info->flags = param_flag;
Damien429d7192013-10-04 19:53:11 +01002763 }
2764}
2765
Damien George2827d622014-04-27 15:50:52 +01002766STATIC void compile_scope_func_param(compiler_t *comp, mp_parse_node_t pn) {
Damien George2ac4af62014-08-15 16:45:41 +01002767 compile_scope_func_lambda_param(comp, pn, PN_typedargslist_name, PN_typedargslist_star, PN_typedargslist_dbl_star);
Damien429d7192013-10-04 19:53:11 +01002768}
2769
Damien George2827d622014-04-27 15:50:52 +01002770STATIC void compile_scope_lambda_param(compiler_t *comp, mp_parse_node_t pn) {
Damien George2ac4af62014-08-15 16:45:41 +01002771 compile_scope_func_lambda_param(comp, pn, PN_varargslist_name, PN_varargslist_star, PN_varargslist_dbl_star);
2772}
2773
Damien Georgeea5b59b2015-09-04 16:44:14 +01002774#if MICROPY_EMIT_NATIVE
Damien George2ac4af62014-08-15 16:45:41 +01002775STATIC void compile_scope_func_annotations(compiler_t *comp, mp_parse_node_t pn) {
2776 if (!MP_PARSE_NODE_IS_STRUCT(pn)) {
2777 // no annotation
2778 return;
2779 }
2780
2781 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
2782 if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_typedargslist_name) {
2783 // named parameter with possible annotation
2784 // fallthrough
2785 } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_typedargslist_star) {
2786 if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)) {
2787 // named star with possible annotation
2788 pns = (mp_parse_node_struct_t*)pns->nodes[0];
2789 // fallthrough
2790 } else {
2791 // no annotation
2792 return;
2793 }
Damien Georgee49153f2016-10-11 12:29:54 +11002794 } else {
2795 assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_typedargslist_dbl_star);
Damien George2ac4af62014-08-15 16:45:41 +01002796 // double star with possible annotation
2797 // fallthrough
Damien George2ac4af62014-08-15 16:45:41 +01002798 }
2799
2800 mp_parse_node_t pn_annotation = pns->nodes[1];
2801
2802 if (!MP_PARSE_NODE_IS_NULL(pn_annotation)) {
Damien George2ac4af62014-08-15 16:45:41 +01002803 qstr param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
2804 id_info_t *id_info = scope_find(comp->scope_cur, param_name);
2805 assert(id_info != NULL);
2806
Damien Georgeea5b59b2015-09-04 16:44:14 +01002807 if (MP_PARSE_NODE_IS_ID(pn_annotation)) {
2808 qstr arg_type = MP_PARSE_NODE_LEAF_ARG(pn_annotation);
2809 EMIT_ARG(set_native_type, MP_EMIT_NATIVE_TYPE_ARG, id_info->local_num, arg_type);
2810 } else {
2811 compile_syntax_error(comp, pn_annotation, "parameter annotation must be an identifier");
Damien George2ac4af62014-08-15 16:45:41 +01002812 }
Damien George2ac4af62014-08-15 16:45:41 +01002813 }
Damien429d7192013-10-04 19:53:11 +01002814}
Damien Georgeea5b59b2015-09-04 16:44:14 +01002815#endif // MICROPY_EMIT_NATIVE
Damien429d7192013-10-04 19:53:11 +01002816
Damien Georgea8312432015-12-18 01:37:55 +00002817STATIC 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) {
2818 uint l_top = comp_next_label(comp);
2819 uint l_end = comp_next_label(comp);
2820 EMIT_ARG(label_assign, l_top);
2821 EMIT_ARG(for_iter, l_end);
2822 c_assign(comp, pns_comp_for->nodes[0], ASSIGN_STORE);
2823 mp_parse_node_t pn_iter = pns_comp_for->nodes[2];
2824
Damien429d7192013-10-04 19:53:11 +01002825 tail_recursion:
Damiend99b0522013-12-21 18:17:45 +00002826 if (MP_PARSE_NODE_IS_NULL(pn_iter)) {
Damien429d7192013-10-04 19:53:11 +01002827 // no more nested if/for; compile inner expression
2828 compile_node(comp, pn_inner_expr);
Damien Georgea5624bf2016-09-18 23:59:47 +10002829 if (comp->scope_cur->kind == SCOPE_GEN_EXPR) {
Damien429d7192013-10-04 19:53:11 +01002830 EMIT(yield_value);
2831 EMIT(pop_top);
Damien Georgea5624bf2016-09-18 23:59:47 +10002832 } else {
Damien George088740e2017-01-17 15:27:37 +11002833 EMIT_ARG(store_comp, comp->scope_cur->kind, 4 * for_depth + 5);
Damien429d7192013-10-04 19:53:11 +01002834 }
Damiend99b0522013-12-21 18:17:45 +00002835 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_if)) {
Damien429d7192013-10-04 19:53:11 +01002836 // if condition
Damiend99b0522013-12-21 18:17:45 +00002837 mp_parse_node_struct_t *pns_comp_if = (mp_parse_node_struct_t*)pn_iter;
Damien429d7192013-10-04 19:53:11 +01002838 c_if_cond(comp, pns_comp_if->nodes[0], false, l_top);
2839 pn_iter = pns_comp_if->nodes[1];
2840 goto tail_recursion;
Damien George0bb97132015-02-27 14:25:47 +00002841 } else {
2842 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_for)); // should be
Damien429d7192013-10-04 19:53:11 +01002843 // for loop
Damiend99b0522013-12-21 18:17:45 +00002844 mp_parse_node_struct_t *pns_comp_for2 = (mp_parse_node_struct_t*)pn_iter;
Damien429d7192013-10-04 19:53:11 +01002845 compile_node(comp, pns_comp_for2->nodes[1]);
Damien George6e769da2017-01-17 14:32:50 +11002846 EMIT_ARG(get_iter, true);
Damien Georgea8312432015-12-18 01:37:55 +00002847 compile_scope_comp_iter(comp, pns_comp_for2, pn_inner_expr, for_depth + 1);
Damien429d7192013-10-04 19:53:11 +01002848 }
Damien Georgea8312432015-12-18 01:37:55 +00002849
2850 EMIT_ARG(jump, l_top);
2851 EMIT_ARG(label_assign, l_end);
Damien George30b42dd2017-01-17 15:30:18 +11002852 EMIT(for_iter_end);
Damien429d7192013-10-04 19:53:11 +01002853}
2854
Damien George1463c1f2014-04-25 23:52:57 +01002855STATIC void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
Damien George65dc9602015-08-14 12:24:11 +01002856#if MICROPY_ENABLE_DOC_STRING
Damien429d7192013-10-04 19:53:11 +01002857 // see http://www.python.org/dev/peps/pep-0257/
2858
2859 // look for the first statement
Damiend99b0522013-12-21 18:17:45 +00002860 if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
Damiene388f102013-12-12 15:24:38 +00002861 // a statement; fall through
Damiend99b0522013-12-21 18:17:45 +00002862 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
Damiene388f102013-12-12 15:24:38 +00002863 // file input; find the first non-newline node
Damiend99b0522013-12-21 18:17:45 +00002864 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
2865 int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damiene388f102013-12-12 15:24:38 +00002866 for (int i = 0; i < num_nodes; i++) {
2867 pn = pns->nodes[i];
Damiend99b0522013-12-21 18:17:45 +00002868 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)) {
Damiene388f102013-12-12 15:24:38 +00002869 // not a newline, so this is the first statement; finish search
2870 break;
2871 }
2872 }
2873 // 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
Damiend99b0522013-12-21 18:17:45 +00002874 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
Damiene388f102013-12-12 15:24:38 +00002875 // a list of statements; get the first one
Damiend99b0522013-12-21 18:17:45 +00002876 pn = ((mp_parse_node_struct_t*)pn)->nodes[0];
Damien429d7192013-10-04 19:53:11 +01002877 } else {
2878 return;
2879 }
2880
2881 // check the first statement for a doc string
Damiend99b0522013-12-21 18:17:45 +00002882 if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
Damien George4dea9222015-04-09 15:29:54 +00002883 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
Damien George5042bce2014-05-25 22:06:06 +01002884 if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0])
2885 && MP_PARSE_NODE_LEAF_KIND(pns->nodes[0]) == MP_PARSE_NODE_STRING)
Damien George52552552017-02-24 13:43:43 +11002886 || (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)
2887 && MP_OBJ_IS_STR(get_const_object((mp_parse_node_struct_t*)pns->nodes[0])))) {
Damien George5042bce2014-05-25 22:06:06 +01002888 // compile the doc string
2889 compile_node(comp, pns->nodes[0]);
2890 // store the doc string
Damien George542bd6b2015-03-26 14:42:40 +00002891 compile_store_id(comp, MP_QSTR___doc__);
Damien429d7192013-10-04 19:53:11 +01002892 }
2893 }
Damien Georgeff8dd3f2015-01-20 12:47:20 +00002894#else
2895 (void)comp;
2896 (void)pn;
Damien George1463c1f2014-04-25 23:52:57 +01002897#endif
Damien429d7192013-10-04 19:53:11 +01002898}
2899
Damien George1463c1f2014-04-25 23:52:57 +01002900STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
Damien429d7192013-10-04 19:53:11 +01002901 comp->pass = pass;
2902 comp->scope_cur = scope;
Damienb05d7072013-10-05 13:37:10 +01002903 comp->next_label = 1;
Damien Georgeb9791222014-01-23 00:34:21 +00002904 EMIT_ARG(start_pass, pass, scope);
Damien429d7192013-10-04 19:53:11 +01002905
Damien George36db6bc2014-05-07 17:24:22 +01002906 if (comp->pass == MP_PASS_SCOPE) {
Damien George8dcc0c72014-03-27 10:55:21 +00002907 // reset maximum stack sizes in scope
2908 // they will be computed in this first pass
Damien429d7192013-10-04 19:53:11 +01002909 scope->stack_size = 0;
Damien George8dcc0c72014-03-27 10:55:21 +00002910 scope->exc_stack_size = 0;
Damien429d7192013-10-04 19:53:11 +01002911 }
2912
Damien429d7192013-10-04 19:53:11 +01002913 // compile
Damien Georged02c6d82014-01-15 22:14:03 +00002914 if (MP_PARSE_NODE_IS_STRUCT_KIND(scope->pn, PN_eval_input)) {
2915 assert(scope->kind == SCOPE_MODULE);
2916 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
2917 compile_node(comp, pns->nodes[0]); // compile the expression
2918 EMIT(return_value);
2919 } else if (scope->kind == SCOPE_MODULE) {
Damien5ac1b2e2013-10-18 19:58:12 +01002920 if (!comp->is_repl) {
2921 check_for_doc_string(comp, scope->pn);
2922 }
Damien429d7192013-10-04 19:53:11 +01002923 compile_node(comp, scope->pn);
Damien Georgeb9791222014-01-23 00:34:21 +00002924 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien429d7192013-10-04 19:53:11 +01002925 EMIT(return_value);
2926 } else if (scope->kind == SCOPE_FUNCTION) {
Damiend99b0522013-12-21 18:17:45 +00002927 assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
2928 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
2929 assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
Damien429d7192013-10-04 19:53:11 +01002930
2931 // work out number of parameters, keywords and default parameters, and add them to the id_info array
Damien6cdd3af2013-10-05 18:08:26 +01002932 // must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
Damien George36db6bc2014-05-07 17:24:22 +01002933 if (comp->pass == MP_PASS_SCOPE) {
Damien George8b19db02014-04-11 23:25:34 +01002934 comp->have_star = false;
Damien429d7192013-10-04 19:53:11 +01002935 apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_scope_func_param);
Damien Georgeea5b59b2015-09-04 16:44:14 +01002936 }
2937 #if MICROPY_EMIT_NATIVE
2938 else if (scope->emit_options == MP_EMIT_OPT_VIPER) {
Damien George2ac4af62014-08-15 16:45:41 +01002939 // compile annotations; only needed on latter compiler passes
Damien Georgeea5b59b2015-09-04 16:44:14 +01002940 // only needed for viper emitter
Damien429d7192013-10-04 19:53:11 +01002941
Damien George2ac4af62014-08-15 16:45:41 +01002942 // argument annotations
2943 apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_scope_func_annotations);
2944
2945 // pns->nodes[2] is return/whole function annotation
Damien Georgea5190a72014-08-15 22:39:08 +01002946 mp_parse_node_t pn_annotation = pns->nodes[2];
2947 if (!MP_PARSE_NODE_IS_NULL(pn_annotation)) {
Damien Georgeea5b59b2015-09-04 16:44:14 +01002948 // nodes[2] can be null or a test-expr
2949 if (MP_PARSE_NODE_IS_ID(pn_annotation)) {
2950 qstr ret_type = MP_PARSE_NODE_LEAF_ARG(pn_annotation);
2951 EMIT_ARG(set_native_type, MP_EMIT_NATIVE_TYPE_RETURN, 0, ret_type);
2952 } else {
2953 compile_syntax_error(comp, pn_annotation, "return annotation must be an identifier");
Damien George2ac4af62014-08-15 16:45:41 +01002954 }
2955 }
Damien George2ac4af62014-08-15 16:45:41 +01002956 }
Damien Georgeea5b59b2015-09-04 16:44:14 +01002957 #endif // MICROPY_EMIT_NATIVE
Damien429d7192013-10-04 19:53:11 +01002958
2959 compile_node(comp, pns->nodes[3]); // 3 is function body
2960 // emit return if it wasn't the last opcode
Damien415eb6f2013-10-05 12:19:06 +01002961 if (!EMIT(last_emit_was_return_value)) {
Damien Georgeb9791222014-01-23 00:34:21 +00002962 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien429d7192013-10-04 19:53:11 +01002963 EMIT(return_value);
2964 }
2965 } else if (scope->kind == SCOPE_LAMBDA) {
Damiend99b0522013-12-21 18:17:45 +00002966 assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
2967 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
2968 assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
Damien429d7192013-10-04 19:53:11 +01002969
2970 // work out number of parameters, keywords and default parameters, and add them to the id_info array
Damien6cdd3af2013-10-05 18:08:26 +01002971 // must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
Damien George36db6bc2014-05-07 17:24:22 +01002972 if (comp->pass == MP_PASS_SCOPE) {
Damien George8b19db02014-04-11 23:25:34 +01002973 comp->have_star = false;
Damien429d7192013-10-04 19:53:11 +01002974 apply_to_single_or_list(comp, pns->nodes[0], PN_varargslist, compile_scope_lambda_param);
2975 }
2976
2977 compile_node(comp, pns->nodes[1]); // 1 is lambda body
Damien George0e3329a2014-04-11 13:10:21 +00002978
2979 // if the lambda is a generator, then we return None, not the result of the expression of the lambda
2980 if (scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {
2981 EMIT(pop_top);
2982 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
2983 }
Damien429d7192013-10-04 19:53:11 +01002984 EMIT(return_value);
2985 } else if (scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
2986 // a bit of a hack at the moment
2987
Damiend99b0522013-12-21 18:17:45 +00002988 assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
2989 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
2990 assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
2991 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
2992 mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
Damien429d7192013-10-04 19:53:11 +01002993
Damien George708c0732014-04-27 19:23:46 +01002994 // We need a unique name for the comprehension argument (the iterator).
2995 // CPython uses .0, but we should be able to use anything that won't
2996 // clash with a user defined variable. Best to use an existing qstr,
2997 // so we use the blank qstr.
Damien George708c0732014-04-27 19:23:46 +01002998 qstr qstr_arg = MP_QSTR_;
Damien George36db6bc2014-05-07 17:24:22 +01002999 if (comp->pass == MP_PASS_SCOPE) {
Damien429d7192013-10-04 19:53:11 +01003000 bool added;
3001 id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qstr_arg, &added);
3002 assert(added);
3003 id_info->kind = ID_INFO_KIND_LOCAL;
Damien George2827d622014-04-27 15:50:52 +01003004 scope->num_pos_args = 1;
Damien429d7192013-10-04 19:53:11 +01003005 }
3006
3007 if (scope->kind == SCOPE_LIST_COMP) {
Damien Georgeb9791222014-01-23 00:34:21 +00003008 EMIT_ARG(build_list, 0);
Damien429d7192013-10-04 19:53:11 +01003009 } else if (scope->kind == SCOPE_DICT_COMP) {
Damien Georgeb9791222014-01-23 00:34:21 +00003010 EMIT_ARG(build_map, 0);
Damien Georgee37dcaa2014-12-27 17:07:16 +00003011 #if MICROPY_PY_BUILTINS_SET
Damien429d7192013-10-04 19:53:11 +01003012 } else if (scope->kind == SCOPE_SET_COMP) {
Damien Georgeb9791222014-01-23 00:34:21 +00003013 EMIT_ARG(build_set, 0);
Damien Georgee37dcaa2014-12-27 17:07:16 +00003014 #endif
Damien429d7192013-10-04 19:53:11 +01003015 }
3016
Damien George088740e2017-01-17 15:27:37 +11003017 // There are 4 slots on the stack for the iterator, and the first one is
3018 // NULL to indicate that the second one points to the iterator object.
Damien George4d2bab12017-02-10 15:39:33 +11003019 if (scope->kind == SCOPE_GEN_EXPR) {
Damien George60656ea2017-03-23 16:36:08 +11003020 // TODO static assert that MP_OBJ_ITER_BUF_NSLOTS == 4
Damien George4d2bab12017-02-10 15:39:33 +11003021 EMIT(load_null);
3022 compile_load_id(comp, qstr_arg);
3023 EMIT(load_null);
3024 EMIT(load_null);
3025 } else {
3026 compile_load_id(comp, qstr_arg);
3027 EMIT_ARG(get_iter, true);
3028 }
Damien George6e769da2017-01-17 14:32:50 +11003029
Damien Georgea8312432015-12-18 01:37:55 +00003030 compile_scope_comp_iter(comp, pns_comp_for, pns->nodes[0], 0);
Damien429d7192013-10-04 19:53:11 +01003031
3032 if (scope->kind == SCOPE_GEN_EXPR) {
Damien Georgeb9791222014-01-23 00:34:21 +00003033 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien429d7192013-10-04 19:53:11 +01003034 }
3035 EMIT(return_value);
3036 } else {
3037 assert(scope->kind == SCOPE_CLASS);
Damiend99b0522013-12-21 18:17:45 +00003038 assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
3039 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
3040 assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
Damien429d7192013-10-04 19:53:11 +01003041
Damien George36db6bc2014-05-07 17:24:22 +01003042 if (comp->pass == MP_PASS_SCOPE) {
Damien429d7192013-10-04 19:53:11 +01003043 bool added;
Damien Georgeeb7bfcb2014-01-04 15:57:35 +00003044 id_info_t *id_info = scope_find_or_add_id(scope, MP_QSTR___class__, &added);
Damien429d7192013-10-04 19:53:11 +01003045 assert(added);
3046 id_info->kind = ID_INFO_KIND_LOCAL;
Damien429d7192013-10-04 19:53:11 +01003047 }
3048
Damien George542bd6b2015-03-26 14:42:40 +00003049 compile_load_id(comp, MP_QSTR___name__);
3050 compile_store_id(comp, MP_QSTR___module__);
Damien George59fba2d2015-06-25 14:42:13 +00003051 EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
Damien George542bd6b2015-03-26 14:42:40 +00003052 compile_store_id(comp, MP_QSTR___qualname__);
Damien429d7192013-10-04 19:53:11 +01003053
3054 check_for_doc_string(comp, pns->nodes[2]);
3055 compile_node(comp, pns->nodes[2]); // 2 is class body
3056
Damien Georgeeb7bfcb2014-01-04 15:57:35 +00003057 id_info_t *id = scope_find(scope, MP_QSTR___class__);
Damien429d7192013-10-04 19:53:11 +01003058 assert(id != NULL);
3059 if (id->kind == ID_INFO_KIND_LOCAL) {
Damien Georgeb9791222014-01-23 00:34:21 +00003060 EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
Damien429d7192013-10-04 19:53:11 +01003061 } else {
Damien George542bd6b2015-03-26 14:42:40 +00003062 EMIT_LOAD_FAST(MP_QSTR___class__, id->local_num);
Damien429d7192013-10-04 19:53:11 +01003063 }
3064 EMIT(return_value);
3065 }
3066
Damien415eb6f2013-10-05 12:19:06 +01003067 EMIT(end_pass);
Damien George8dcc0c72014-03-27 10:55:21 +00003068
3069 // make sure we match all the exception levels
3070 assert(comp->cur_except_level == 0);
Damien826005c2013-10-05 23:17:28 +01003071}
3072
Damien Georgead297a12016-12-09 13:17:49 +11003073#if MICROPY_EMIT_INLINE_ASM
Damien George36db6bc2014-05-07 17:24:22 +01003074// requires 3 passes: SCOPE, CODE_SIZE, EMIT
Damien George1463c1f2014-04-25 23:52:57 +01003075STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
Damien826005c2013-10-05 23:17:28 +01003076 comp->pass = pass;
3077 comp->scope_cur = scope;
3078 comp->next_label = 1;
3079
3080 if (scope->kind != SCOPE_FUNCTION) {
Damien George01039b52014-12-21 17:44:27 +00003081 compile_syntax_error(comp, MP_PARSE_NODE_NULL, "inline assembler must be a function");
Damien826005c2013-10-05 23:17:28 +01003082 return;
3083 }
3084
Damien George36db6bc2014-05-07 17:24:22 +01003085 if (comp->pass > MP_PASS_SCOPE) {
Damien Georgee920bab2016-12-09 21:23:17 +11003086 EMIT_INLINE_ASM_ARG(start_pass, comp->pass, &comp->compile_error);
Damiena2f2f7d2013-10-06 00:14:13 +01003087 }
3088
Damien826005c2013-10-05 23:17:28 +01003089 // get the function definition parse node
Damiend99b0522013-12-21 18:17:45 +00003090 assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
3091 mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
3092 assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
Damien826005c2013-10-05 23:17:28 +01003093
Damiend99b0522013-12-21 18:17:45 +00003094 //qstr f_id = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
Damien826005c2013-10-05 23:17:28 +01003095
Damiena2f2f7d2013-10-06 00:14:13 +01003096 // parameters are in pns->nodes[1]
Damien George36db6bc2014-05-07 17:24:22 +01003097 if (comp->pass == MP_PASS_CODE_SIZE) {
Damiend99b0522013-12-21 18:17:45 +00003098 mp_parse_node_t *pn_params;
Damien Georgedfe944c2015-02-13 02:29:46 +00003099 int n_params = mp_parse_node_extract_list(&pns->nodes[1], PN_typedargslist, &pn_params);
Damien George2827d622014-04-27 15:50:52 +01003100 scope->num_pos_args = EMIT_INLINE_ASM_ARG(count_params, n_params, pn_params);
Damien George8dfbd2d2015-02-13 01:00:51 +00003101 if (comp->compile_error != MP_OBJ_NULL) {
3102 goto inline_asm_error;
3103 }
Damiena2f2f7d2013-10-06 00:14:13 +01003104 }
3105
Damien George8f54c082016-01-15 15:20:43 +00003106 // pns->nodes[2] is function return annotation
3107 mp_uint_t type_sig = MP_NATIVE_TYPE_INT;
3108 mp_parse_node_t pn_annotation = pns->nodes[2];
3109 if (!MP_PARSE_NODE_IS_NULL(pn_annotation)) {
3110 // nodes[2] can be null or a test-expr
3111 if (MP_PARSE_NODE_IS_ID(pn_annotation)) {
3112 qstr ret_type = MP_PARSE_NODE_LEAF_ARG(pn_annotation);
3113 switch (ret_type) {
3114 case MP_QSTR_object: type_sig = MP_NATIVE_TYPE_OBJ; break;
3115 case MP_QSTR_bool: type_sig = MP_NATIVE_TYPE_BOOL; break;
3116 case MP_QSTR_int: type_sig = MP_NATIVE_TYPE_INT; break;
3117 case MP_QSTR_uint: type_sig = MP_NATIVE_TYPE_UINT; break;
3118 default: compile_syntax_error(comp, pn_annotation, "unknown type"); return;
3119 }
3120 } else {
3121 compile_syntax_error(comp, pn_annotation, "return annotation must be an identifier");
3122 }
3123 }
Damien826005c2013-10-05 23:17:28 +01003124
Damiend99b0522013-12-21 18:17:45 +00003125 mp_parse_node_t pn_body = pns->nodes[3]; // body
3126 mp_parse_node_t *nodes;
Damien Georgedfe944c2015-02-13 02:29:46 +00003127 int num = mp_parse_node_extract_list(&pn_body, PN_suite_block_stmts, &nodes);
Damien826005c2013-10-05 23:17:28 +01003128
Damien826005c2013-10-05 23:17:28 +01003129 for (int i = 0; i < num; i++) {
Damiend99b0522013-12-21 18:17:45 +00003130 assert(MP_PARSE_NODE_IS_STRUCT(nodes[i]));
3131 mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)nodes[i];
Damien Georgea26dc502014-04-12 17:54:52 +01003132 if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_pass_stmt) {
3133 // no instructions
3134 continue;
Damien George3d7bf5d2015-02-16 17:46:28 +00003135 } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_expr_stmt) {
Damien Georgea26dc502014-04-12 17:54:52 +01003136 // not an instruction; error
Damien George3d7bf5d2015-02-16 17:46:28 +00003137 not_an_instruction:
Damien George3665d0b2015-03-03 17:11:18 +00003138 compile_syntax_error(comp, nodes[i], "expecting an assembler instruction");
Damien Georgea26dc502014-04-12 17:54:52 +01003139 return;
3140 }
Damien George3d7bf5d2015-02-16 17:46:28 +00003141
3142 // check structure of parse node
Damiend99b0522013-12-21 18:17:45 +00003143 assert(MP_PARSE_NODE_IS_STRUCT(pns2->nodes[0]));
Damien George3d7bf5d2015-02-16 17:46:28 +00003144 if (!MP_PARSE_NODE_IS_NULL(pns2->nodes[1])) {
3145 goto not_an_instruction;
3146 }
Damiend99b0522013-12-21 18:17:45 +00003147 pns2 = (mp_parse_node_struct_t*)pns2->nodes[0];
pohmelie81ebba72016-01-27 23:23:11 +03003148 if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_atom_expr_normal) {
Damien George3d7bf5d2015-02-16 17:46:28 +00003149 goto not_an_instruction;
3150 }
3151 if (!MP_PARSE_NODE_IS_ID(pns2->nodes[0])) {
3152 goto not_an_instruction;
3153 }
3154 if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns2->nodes[1], PN_trailer_paren)) {
3155 goto not_an_instruction;
3156 }
Damien George3d7bf5d2015-02-16 17:46:28 +00003157
3158 // parse node looks like an instruction
3159 // get instruction name and args
Damiend99b0522013-12-21 18:17:45 +00003160 qstr op = MP_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
3161 pns2 = (mp_parse_node_struct_t*)pns2->nodes[1]; // PN_trailer_paren
3162 mp_parse_node_t *pn_arg;
Damien Georgedfe944c2015-02-13 02:29:46 +00003163 int n_args = mp_parse_node_extract_list(&pns2->nodes[0], PN_arglist, &pn_arg);
Damien826005c2013-10-05 23:17:28 +01003164
3165 // emit instructions
Damien Georgee5f8a772014-04-21 13:33:15 +01003166 if (op == MP_QSTR_label) {
Damiend99b0522013-12-21 18:17:45 +00003167 if (!(n_args == 1 && MP_PARSE_NODE_IS_ID(pn_arg[0]))) {
Damien George3665d0b2015-03-03 17:11:18 +00003168 compile_syntax_error(comp, nodes[i], "'label' requires 1 argument");
Damien826005c2013-10-05 23:17:28 +01003169 return;
3170 }
Damien George6f355fd2014-04-10 14:11:31 +01003171 uint lab = comp_next_label(comp);
Damien George36db6bc2014-05-07 17:24:22 +01003172 if (pass > MP_PASS_SCOPE) {
Damien George9c5cabb2015-03-03 17:08:02 +00003173 if (!EMIT_INLINE_ASM_ARG(label, lab, MP_PARSE_NODE_LEAF_ARG(pn_arg[0]))) {
3174 compile_syntax_error(comp, nodes[i], "label redefined");
3175 return;
3176 }
Damien826005c2013-10-05 23:17:28 +01003177 }
Damien Georgee5f8a772014-04-21 13:33:15 +01003178 } else if (op == MP_QSTR_align) {
3179 if (!(n_args == 1 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
Damien George3665d0b2015-03-03 17:11:18 +00003180 compile_syntax_error(comp, nodes[i], "'align' requires 1 argument");
Damien Georgee5f8a772014-04-21 13:33:15 +01003181 return;
3182 }
Damien George36db6bc2014-05-07 17:24:22 +01003183 if (pass > MP_PASS_SCOPE) {
Damien Georgedd53b122016-12-09 20:54:54 +11003184 mp_asm_base_align((mp_asm_base_t*)comp->emit_inline_asm,
3185 MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]));
Damien Georgee5f8a772014-04-21 13:33:15 +01003186 }
3187 } else if (op == MP_QSTR_data) {
3188 if (!(n_args >= 2 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
Damien George3665d0b2015-03-03 17:11:18 +00003189 compile_syntax_error(comp, nodes[i], "'data' requires at least 2 arguments");
Damien Georgee5f8a772014-04-21 13:33:15 +01003190 return;
3191 }
Damien George36db6bc2014-05-07 17:24:22 +01003192 if (pass > MP_PASS_SCOPE) {
Damien George40f3c022014-07-03 13:25:24 +01003193 mp_int_t bytesize = MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]);
Damien George50912e72015-01-20 11:55:10 +00003194 for (uint j = 1; j < n_args; j++) {
3195 if (!MP_PARSE_NODE_IS_SMALL_INT(pn_arg[j])) {
Damien George3665d0b2015-03-03 17:11:18 +00003196 compile_syntax_error(comp, nodes[i], "'data' requires integer arguments");
Damien Georgee5f8a772014-04-21 13:33:15 +01003197 return;
3198 }
Damien Georgedd53b122016-12-09 20:54:54 +11003199 mp_asm_base_data((mp_asm_base_t*)comp->emit_inline_asm,
3200 bytesize, MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[j]));
Damien Georgee5f8a772014-04-21 13:33:15 +01003201 }
3202 }
Damien826005c2013-10-05 23:17:28 +01003203 } else {
Damien George36db6bc2014-05-07 17:24:22 +01003204 if (pass > MP_PASS_SCOPE) {
Damien Georgeb9791222014-01-23 00:34:21 +00003205 EMIT_INLINE_ASM_ARG(op, op, n_args, pn_arg);
Damien826005c2013-10-05 23:17:28 +01003206 }
3207 }
Damien George8dfbd2d2015-02-13 01:00:51 +00003208
3209 if (comp->compile_error != MP_OBJ_NULL) {
3210 pns = pns2; // this is the parse node that had the error
3211 goto inline_asm_error;
3212 }
Damien826005c2013-10-05 23:17:28 +01003213 }
3214
Damien George36db6bc2014-05-07 17:24:22 +01003215 if (comp->pass > MP_PASS_SCOPE) {
Damien George8f54c082016-01-15 15:20:43 +00003216 EMIT_INLINE_ASM_ARG(end_pass, type_sig);
Damien Georgee920bab2016-12-09 21:23:17 +11003217
3218 if (comp->pass == MP_PASS_EMIT) {
3219 void *f = mp_asm_base_get_code((mp_asm_base_t*)comp->emit_inline_asm);
3220 mp_emit_glue_assign_native(comp->scope_cur->raw_code, MP_CODE_NATIVE_ASM,
3221 f, mp_asm_base_get_code_size((mp_asm_base_t*)comp->emit_inline_asm),
3222 NULL, comp->scope_cur->num_pos_args, 0, type_sig);
3223 }
Damien George8dfbd2d2015-02-13 01:00:51 +00003224 }
3225
3226 if (comp->compile_error != MP_OBJ_NULL) {
Damien Georgecfc4c332015-07-29 22:16:01 +00003227 // inline assembler had an error; set line for its exception
Damien George8dfbd2d2015-02-13 01:00:51 +00003228 inline_asm_error:
Damien Georgecfc4c332015-07-29 22:16:01 +00003229 comp->compile_error_line = pns->source_line;
Damienb05d7072013-10-05 13:37:10 +01003230 }
Damien429d7192013-10-04 19:53:11 +01003231}
Damien George094d4502014-04-02 17:31:27 +01003232#endif
Damien429d7192013-10-04 19:53:11 +01003233
Damien Georgeff8dd3f2015-01-20 12:47:20 +00003234STATIC void scope_compute_things(scope_t *scope) {
Damien George2827d622014-04-27 15:50:52 +01003235 // in Micro Python we put the *x parameter after all other parameters (except **y)
3236 if (scope->scope_flags & MP_SCOPE_FLAG_VARARGS) {
3237 id_info_t *id_param = NULL;
3238 for (int i = scope->id_info_len - 1; i >= 0; i--) {
3239 id_info_t *id = &scope->id_info[i];
3240 if (id->flags & ID_FLAG_IS_STAR_PARAM) {
3241 if (id_param != NULL) {
3242 // swap star param with last param
3243 id_info_t temp = *id_param; *id_param = *id; *id = temp;
3244 }
3245 break;
3246 } else if (id_param == NULL && id->flags == ID_FLAG_IS_PARAM) {
3247 id_param = id;
3248 }
3249 }
3250 }
Damien George2827d622014-04-27 15:50:52 +01003251
Damien429d7192013-10-04 19:53:11 +01003252 // in functions, turn implicit globals into explicit globals
Damien George6baf76e2013-12-30 22:32:17 +00003253 // compute the index of each local
Damien429d7192013-10-04 19:53:11 +01003254 scope->num_locals = 0;
3255 for (int i = 0; i < scope->id_info_len; i++) {
3256 id_info_t *id = &scope->id_info[i];
Damien George7ff996c2014-09-08 23:05:16 +01003257 if (scope->kind == SCOPE_CLASS && id->qst == MP_QSTR___class__) {
Damien429d7192013-10-04 19:53:11 +01003258 // __class__ is not counted as a local; if it's used then it becomes a ID_INFO_KIND_CELL
3259 continue;
3260 }
Damien George3dea8c92016-09-30 12:34:05 +10003261 if (SCOPE_IS_FUNC_LIKE(scope->kind) && id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
Damien429d7192013-10-04 19:53:11 +01003262 id->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
3263 }
Damien George2827d622014-04-27 15:50:52 +01003264 // params always count for 1 local, even if they are a cell
Damien George11d8cd52014-04-09 14:42:51 +01003265 if (id->kind == ID_INFO_KIND_LOCAL || (id->flags & ID_FLAG_IS_PARAM)) {
Damien George2827d622014-04-27 15:50:52 +01003266 id->local_num = scope->num_locals++;
Damien9ecbcff2013-12-11 00:41:43 +00003267 }
3268 }
3269
Damien George65dc9602015-08-14 12:24:11 +01003270 // compute the index of cell vars
Damien9ecbcff2013-12-11 00:41:43 +00003271 for (int i = 0; i < scope->id_info_len; i++) {
3272 id_info_t *id = &scope->id_info[i];
Damien George6baf76e2013-12-30 22:32:17 +00003273 // in Micro Python the cells come right after the fast locals
3274 // parameters are not counted here, since they remain at the start
3275 // of the locals, even if they are cell vars
Damien George11d8cd52014-04-09 14:42:51 +01003276 if (id->kind == ID_INFO_KIND_CELL && !(id->flags & ID_FLAG_IS_PARAM)) {
Damien George6baf76e2013-12-30 22:32:17 +00003277 id->local_num = scope->num_locals;
3278 scope->num_locals += 1;
3279 }
Damien9ecbcff2013-12-11 00:41:43 +00003280 }
Damien9ecbcff2013-12-11 00:41:43 +00003281
Damien George65dc9602015-08-14 12:24:11 +01003282 // compute the index of free vars
Damien9ecbcff2013-12-11 00:41:43 +00003283 // make sure they are in the order of the parent scope
3284 if (scope->parent != NULL) {
3285 int num_free = 0;
3286 for (int i = 0; i < scope->parent->id_info_len; i++) {
3287 id_info_t *id = &scope->parent->id_info[i];
3288 if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {
3289 for (int j = 0; j < scope->id_info_len; j++) {
3290 id_info_t *id2 = &scope->id_info[j];
Damien George7ff996c2014-09-08 23:05:16 +01003291 if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {
Damien George11d8cd52014-04-09 14:42:51 +01003292 assert(!(id2->flags & ID_FLAG_IS_PARAM)); // free vars should not be params
Damien George6baf76e2013-12-30 22:32:17 +00003293 // in Micro Python the frees come first, before the params
3294 id2->local_num = num_free;
Damien9ecbcff2013-12-11 00:41:43 +00003295 num_free += 1;
3296 }
3297 }
3298 }
Damien429d7192013-10-04 19:53:11 +01003299 }
Damien George6baf76e2013-12-30 22:32:17 +00003300 // in Micro Python shift all other locals after the free locals
3301 if (num_free > 0) {
3302 for (int i = 0; i < scope->id_info_len; i++) {
3303 id_info_t *id = &scope->id_info[i];
Damien George2bf7c092014-04-09 15:26:46 +01003304 if (id->kind != ID_INFO_KIND_FREE || (id->flags & ID_FLAG_IS_PARAM)) {
Damien George6baf76e2013-12-30 22:32:17 +00003305 id->local_num += num_free;
3306 }
3307 }
Damien George2827d622014-04-27 15:50:52 +01003308 scope->num_pos_args += num_free; // free vars are counted as params for passing them into the function
Damien George6baf76e2013-12-30 22:32:17 +00003309 scope->num_locals += num_free;
3310 }
Damien429d7192013-10-04 19:53:11 +01003311 }
Damien429d7192013-10-04 19:53:11 +01003312}
3313
Damien Georged4dba882015-11-13 13:38:28 +00003314#if !MICROPY_PERSISTENT_CODE_SAVE
3315STATIC
3316#endif
3317mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_file, uint emit_opt, bool is_repl) {
Damien George9d5e5c02015-09-24 13:15:57 +01003318 // put compiler state on the stack, it's relatively small
3319 compiler_t comp_state = {0};
3320 compiler_t *comp = &comp_state;
3321
Damien Georgecbd2f742014-01-19 11:48:48 +00003322 comp->source_file = source_file;
Damien5ac1b2e2013-10-18 19:58:12 +01003323 comp->is_repl = is_repl;
Damien429d7192013-10-04 19:53:11 +01003324
Damien George62a3a282015-03-01 12:04:05 +00003325 // create the module scope
Damien George58e0f4a2015-09-23 10:50:43 +01003326 scope_t *module_scope = scope_new_and_link(comp, SCOPE_MODULE, parse_tree->root, emit_opt);
Damien George62a3a282015-03-01 12:04:05 +00003327
Damien Georgea210c772015-03-26 15:49:53 +00003328 // create standard emitter; it's used at least for MP_PASS_SCOPE
Damien Georgea210c772015-03-26 15:49:53 +00003329 emit_t *emit_bc = emit_bc_new();
Damien Georgea210c772015-03-26 15:49:53 +00003330
Damien826005c2013-10-05 23:17:28 +01003331 // compile pass 1
Damien Georgea210c772015-03-26 15:49:53 +00003332 comp->emit = emit_bc;
Damien George41125902015-03-26 16:44:14 +00003333 #if MICROPY_EMIT_NATIVE
Damien Georgea210c772015-03-26 15:49:53 +00003334 comp->emit_method_table = &emit_bc_method_table;
3335 #endif
Damien826005c2013-10-05 23:17:28 +01003336 uint max_num_labels = 0;
Damien Georgea91ac202014-10-05 19:01:34 +01003337 for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
Damienc025ebb2013-10-12 14:30:21 +01003338 if (false) {
Damien Georgead297a12016-12-09 13:17:49 +11003339 #if MICROPY_EMIT_INLINE_ASM
3340 } else if (s->emit_options == MP_EMIT_OPT_ASM) {
Damien George36db6bc2014-05-07 17:24:22 +01003341 compile_scope_inline_asm(comp, s, MP_PASS_SCOPE);
Damien Georgead297a12016-12-09 13:17:49 +11003342 #endif
Damien826005c2013-10-05 23:17:28 +01003343 } else {
Damien George36db6bc2014-05-07 17:24:22 +01003344 compile_scope(comp, s, MP_PASS_SCOPE);
Damien826005c2013-10-05 23:17:28 +01003345 }
3346
3347 // update maximim number of labels needed
3348 if (comp->next_label > max_num_labels) {
3349 max_num_labels = comp->next_label;
3350 }
Damien429d7192013-10-04 19:53:11 +01003351 }
3352
Damien826005c2013-10-05 23:17:28 +01003353 // compute some things related to scope and identifiers
Damien Georgea91ac202014-10-05 19:01:34 +01003354 for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
Damien Georgeff8dd3f2015-01-20 12:47:20 +00003355 scope_compute_things(s);
Damien429d7192013-10-04 19:53:11 +01003356 }
3357
Damien Georgea210c772015-03-26 15:49:53 +00003358 // set max number of labels now that it's calculated
Damien Georgea210c772015-03-26 15:49:53 +00003359 emit_bc_set_max_num_labels(emit_bc, max_num_labels);
Damien Georgea210c772015-03-26 15:49:53 +00003360
Damien826005c2013-10-05 23:17:28 +01003361 // compile pass 2 and 3
Damien Georgee67ed5d2014-01-04 13:55:24 +00003362#if MICROPY_EMIT_NATIVE
Damiendc833822013-10-06 01:01:01 +01003363 emit_t *emit_native = NULL;
Damienc025ebb2013-10-12 14:30:21 +01003364#endif
Damien Georgea91ac202014-10-05 19:01:34 +01003365 for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
Damienc025ebb2013-10-12 14:30:21 +01003366 if (false) {
3367 // dummy
3368
Damien Georgead297a12016-12-09 13:17:49 +11003369 #if MICROPY_EMIT_INLINE_ASM
3370 } else if (s->emit_options == MP_EMIT_OPT_ASM) {
3371 // inline assembly
3372 if (comp->emit_inline_asm == NULL) {
3373 comp->emit_inline_asm = ASM_EMITTER(new)(max_num_labels);
Damien826005c2013-10-05 23:17:28 +01003374 }
3375 comp->emit = NULL;
Damien Georgead297a12016-12-09 13:17:49 +11003376 comp->emit_inline_asm_method_table = &ASM_EMITTER(method_table);
Damien George36db6bc2014-05-07 17:24:22 +01003377 compile_scope_inline_asm(comp, s, MP_PASS_CODE_SIZE);
Damien Georgede9cd002016-12-19 17:42:25 +11003378 #if MICROPY_EMIT_INLINE_XTENSA
3379 // Xtensa requires an extra pass to compute size of l32r const table
3380 // TODO this can be improved by calculating it during SCOPE pass
3381 // but that requires some other structural changes to the asm emitters
3382 compile_scope_inline_asm(comp, s, MP_PASS_CODE_SIZE);
3383 #endif
Damien Georgea91ac202014-10-05 19:01:34 +01003384 if (comp->compile_error == MP_OBJ_NULL) {
Damien George36db6bc2014-05-07 17:24:22 +01003385 compile_scope_inline_asm(comp, s, MP_PASS_EMIT);
Damien Georgea26dc502014-04-12 17:54:52 +01003386 }
Damien Georgead297a12016-12-09 13:17:49 +11003387 #endif
Damienc025ebb2013-10-12 14:30:21 +01003388
Damien826005c2013-10-05 23:17:28 +01003389 } else {
Damienc025ebb2013-10-12 14:30:21 +01003390
3391 // choose the emit type
3392
Damien826005c2013-10-05 23:17:28 +01003393 switch (s->emit_options) {
Damien Georgee67ed5d2014-01-04 13:55:24 +00003394
3395#if MICROPY_EMIT_NATIVE
Damien George65cad122014-04-06 11:48:15 +01003396 case MP_EMIT_OPT_NATIVE_PYTHON:
3397 case MP_EMIT_OPT_VIPER:
Damiendc833822013-10-06 01:01:01 +01003398 if (emit_native == NULL) {
Damien George080a78b2016-12-07 11:17:17 +11003399 emit_native = NATIVE_EMITTER(new)(&comp->compile_error, max_num_labels);
Damien826005c2013-10-05 23:17:28 +01003400 }
Damien George080a78b2016-12-07 11:17:17 +11003401 comp->emit_method_table = &NATIVE_EMITTER(method_table);
Damienc025ebb2013-10-12 14:30:21 +01003402 comp->emit = emit_native;
Damien Georgea5190a72014-08-15 22:39:08 +01003403 EMIT_ARG(set_native_type, MP_EMIT_NATIVE_TYPE_ENABLE, s->emit_options == MP_EMIT_OPT_VIPER, 0);
Damien7af3d192013-10-07 00:02:49 +01003404 break;
Damien Georgee67ed5d2014-01-04 13:55:24 +00003405#endif // MICROPY_EMIT_NATIVE
Damien7af3d192013-10-07 00:02:49 +01003406
Damien826005c2013-10-05 23:17:28 +01003407 default:
Damien826005c2013-10-05 23:17:28 +01003408 comp->emit = emit_bc;
Damien George41125902015-03-26 16:44:14 +00003409 #if MICROPY_EMIT_NATIVE
Damien826005c2013-10-05 23:17:28 +01003410 comp->emit_method_table = &emit_bc_method_table;
Damien George41125902015-03-26 16:44:14 +00003411 #endif
Damien826005c2013-10-05 23:17:28 +01003412 break;
3413 }
Damienc025ebb2013-10-12 14:30:21 +01003414
Damien George1e1779e2015-01-14 00:20:28 +00003415 // need a pass to compute stack size
3416 compile_scope(comp, s, MP_PASS_STACK_SIZE);
3417
Damien George36db6bc2014-05-07 17:24:22 +01003418 // second last pass: compute code size
Damien Georgea91ac202014-10-05 19:01:34 +01003419 if (comp->compile_error == MP_OBJ_NULL) {
Damien George36db6bc2014-05-07 17:24:22 +01003420 compile_scope(comp, s, MP_PASS_CODE_SIZE);
3421 }
3422
3423 // final pass: emit code
Damien Georgea91ac202014-10-05 19:01:34 +01003424 if (comp->compile_error == MP_OBJ_NULL) {
Damien George36db6bc2014-05-07 17:24:22 +01003425 compile_scope(comp, s, MP_PASS_EMIT);
Damien Georgea26dc502014-04-12 17:54:52 +01003426 }
Damien6cdd3af2013-10-05 18:08:26 +01003427 }
Damien429d7192013-10-04 19:53:11 +01003428 }
3429
Damien Georgecfc4c332015-07-29 22:16:01 +00003430 if (comp->compile_error != MP_OBJ_NULL) {
3431 // if there is no line number for the error then use the line
3432 // number for the start of this scope
3433 compile_error_set_line(comp, comp->scope_cur->pn);
3434 // add a traceback to the exception using relevant source info
3435 mp_obj_exception_add_traceback(comp->compile_error, comp->source_file,
3436 comp->compile_error_line, comp->scope_cur->simple_name);
3437 }
3438
Damien George41d02b62014-01-24 22:42:28 +00003439 // free the emitters
Damien Georgea210c772015-03-26 15:49:53 +00003440
Damien Georgea210c772015-03-26 15:49:53 +00003441 emit_bc_free(emit_bc);
Damien George41d02b62014-01-24 22:42:28 +00003442#if MICROPY_EMIT_NATIVE
3443 if (emit_native != NULL) {
Damien George080a78b2016-12-07 11:17:17 +11003444 NATIVE_EMITTER(free)(emit_native);
Damien George41d02b62014-01-24 22:42:28 +00003445 }
3446#endif
Damien Georgead297a12016-12-09 13:17:49 +11003447 #if MICROPY_EMIT_INLINE_ASM
3448 if (comp->emit_inline_asm != NULL) {
3449 ASM_EMITTER(free)(comp->emit_inline_asm);
Damien George41d02b62014-01-24 22:42:28 +00003450 }
Damien Georgead297a12016-12-09 13:17:49 +11003451 #endif
Damien George41d02b62014-01-24 22:42:28 +00003452
Damien George52b5d762014-09-23 15:31:56 +00003453 // free the parse tree
Damien George58e0f4a2015-09-23 10:50:43 +01003454 mp_parse_tree_clear(parse_tree);
Damien George52b5d762014-09-23 15:31:56 +00003455
Damien George41d02b62014-01-24 22:42:28 +00003456 // free the scopes
Damien Georgedf8127a2014-04-13 11:04:33 +01003457 mp_raw_code_t *outer_raw_code = module_scope->raw_code;
Paul Sokolovskyfd313582014-01-23 23:05:47 +02003458 for (scope_t *s = module_scope; s;) {
3459 scope_t *next = s->next;
3460 scope_free(s);
3461 s = next;
3462 }
Damien5ac1b2e2013-10-18 19:58:12 +01003463
Damien George9d5e5c02015-09-24 13:15:57 +01003464 if (comp->compile_error != MP_OBJ_NULL) {
3465 nlr_raise(comp->compile_error);
Damien George1fb03172014-01-03 14:22:03 +00003466 } else {
Damien Georged4dba882015-11-13 13:38:28 +00003467 return outer_raw_code;
Damien George1fb03172014-01-03 14:22:03 +00003468 }
Damien429d7192013-10-04 19:53:11 +01003469}
Damien Georged4dba882015-11-13 13:38:28 +00003470
3471mp_obj_t mp_compile(mp_parse_tree_t *parse_tree, qstr source_file, uint emit_opt, bool is_repl) {
3472 mp_raw_code_t *rc = mp_compile_to_raw_code(parse_tree, source_file, emit_opt, is_repl);
3473 // return function that executes the outer module
3474 return mp_make_function_from_raw_code(rc, MP_OBJ_NULL, MP_OBJ_NULL);
3475}
Damien Georgedd5353a2015-12-18 12:35:44 +00003476
3477#endif // MICROPY_ENABLE_COMPILER