#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include "py/scope.h"

#include "py/emit.h"

#include "py/compile.h"

#include "py/runtime.h"

#include "py/asmbase.h"

#if MICROPY_ENABLE_COMPILER && !MICROPY_USE_SMALL_HEAP_COMPILER

#define INVALID_LABEL (0xffff)

typedef enum {

#define DEF_RULE(rule, comp, kind, ...) PN_##rule,

#define DEF_RULE_NC(rule, kind, ...)

#include "py/grammar.h"

#undef DEF_RULE

#undef DEF_RULE_NC

PN_const_object, // special node for a constant, generic Python object

#define DEF_RULE(rule, comp, kind, ...)

#define DEF_RULE_NC(rule, kind, ...) PN_##rule,

#include "py/grammar.h"

#undef DEF_RULE

#undef DEF_RULE_NC

} pn_kind_t;

#define NEED_METHOD_TABLE MICROPY_EMIT_NATIVE

#if NEED_METHOD_TABLE

#define EMIT(fun) (comp->emit_method_table->fun(comp->emit))

#define EMIT_ARG(fun, ...) (comp->emit_method_table->fun(comp->emit, __VA_ARGS__))

#define EMIT_LOAD_FAST(qst, local_num) (comp->emit_method_table->load_id.fast(comp->emit, qst, local_num))

#define EMIT_LOAD_GLOBAL(qst) (comp->emit_method_table->load_id.global(comp->emit, qst))

#define EMIT(fun) (mp_emit_bc_##fun(comp->emit))

#define EMIT_ARG(fun, ...) (mp_emit_bc_##fun(comp->emit, __VA_ARGS__))

#define EMIT_LOAD_FAST(qst, local_num) (mp_emit_bc_load_fast(comp->emit, qst, local_num))

#define EMIT_LOAD_GLOBAL(qst) (mp_emit_bc_load_global(comp->emit, qst))

#if MICROPY_EMIT_NATIVE

#if MICROPY_EMIT_X64

#define NATIVE_EMITTER(f) emit_native_x64_##f

#elif MICROPY_EMIT_X86

#define NATIVE_EMITTER(f) emit_native_x86_##f

#elif MICROPY_EMIT_THUMB

#define NATIVE_EMITTER(f) emit_native_thumb_##f

#elif MICROPY_EMIT_ARM

#define NATIVE_EMITTER(f) emit_native_arm_##f

#elif MICROPY_EMIT_XTENSA

#define NATIVE_EMITTER(f) emit_native_xtensa_##f

#error "unknown native emitter"

#if MICROPY_EMIT_INLINE_ASM

#if MICROPY_EMIT_INLINE_THUMB

#define ASM_DECORATOR_QSTR MP_QSTR_asm_thumb

#define ASM_EMITTER(f) emit_inline_thumb_##f

#elif MICROPY_EMIT_INLINE_XTENSA

#define ASM_DECORATOR_QSTR MP_QSTR_asm_xtensa

#define ASM_EMITTER(f) emit_inline_xtensa_##f

#error "unknown asm emitter"

#define EMIT_INLINE_ASM(fun) (comp->emit_inline_asm_method_table->fun(comp->emit_inline_asm))

#define EMIT_INLINE_ASM_ARG(fun, ...) (comp->emit_inline_asm_method_table->fun(comp->emit_inline_asm, __VA_ARGS__))

typedef struct _compiler_t {

} compiler_t;

STATIC void compile_error_set_line(compiler_t *comp, mp_parse_node_t pn) {

// if the line of the error is unknown then try to update it from the pn

if (comp->compile_error_line == 0 && MP_PARSE_NODE_IS_STRUCT(pn)) {

comp->compile_error_line = ((mp_parse_node_struct_t*)pn)->source_line;

}

}

STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, const char *msg) {

// only register the error if there has been no other error

if (comp->compile_error == MP_OBJ_NULL) {

comp->compile_error = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg);

compile_error_set_line(comp, pn);

}

}

STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_arglist, bool is_method_call, int n_positional_extra);

STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind);

STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn);

STATIC uint comp_next_label(compiler_t *comp) {

return comp->next_label++;

}

STATIC void compile_increase_except_level(compiler_t *comp) {

comp->cur_except_level += 1;

if (comp->cur_except_level > comp->scope_cur->exc_stack_size) {

comp->scope_cur->exc_stack_size = comp->cur_except_level;

}

}

STATIC void compile_decrease_except_level(compiler_t *comp) {

assert(comp->cur_except_level > 0);

comp->cur_except_level -= 1;

}

STATIC scope_t *scope_new_and_link(compiler_t *comp, scope_kind_t kind, mp_parse_node_t pn, uint emit_options) {

scope_t *scope = scope_new(kind, pn, comp->source_file, emit_options);

scope->parent = comp->scope_cur;

scope->next = NULL;

if (comp->scope_head == NULL) {

comp->scope_head = scope;

} else {

scope_t *s = comp->scope_head;

while (s->next != NULL) {

s = s->next;

}

s->next = scope;

}

return scope;

}

typedef void (*apply_list_fun_t)(compiler_t *comp, mp_parse_node_t pn);

STATIC void apply_to_single_or_list(compiler_t *comp, mp_parse_node_t pn, pn_kind_t pn_list_kind, apply_list_fun_t f) {

if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, pn_list_kind)) {

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);

for (int i = 0; i < num_nodes; i++) {

f(comp, pns->nodes[i]);

}

} else if (!MP_PARSE_NODE_IS_NULL(pn)) {

f(comp, pn);

}

}

STATIC void compile_generic_all_nodes(compiler_t *comp, mp_parse_node_struct_t *pns) {

int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);

for (int i = 0; i < num_nodes; i++) {

compile_node(comp, pns->nodes[i]);

if (comp->compile_error != MP_OBJ_NULL) {

// add line info for the error in case it didn't have a line number

compile_error_set_line(comp, pns->nodes[i]);

return;

}

}

}

STATIC void compile_load_id(compiler_t *comp, qstr qst) {

if (comp->pass == MP_PASS_SCOPE) {

mp_emit_common_get_id_for_load(comp->scope_cur, qst);

} else {

#if NEED_METHOD_TABLE

mp_emit_common_id_op(comp->emit, &comp->emit_method_table->load_id, comp->scope_cur, qst);

#else

mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_load_id_ops, comp->scope_cur, qst);

#endif

}

}

STATIC void compile_store_id(compiler_t *comp, qstr qst) {

if (comp->pass == MP_PASS_SCOPE) {

mp_emit_common_get_id_for_modification(comp->scope_cur, qst);

} else {

#if NEED_METHOD_TABLE

mp_emit_common_id_op(comp->emit, &comp->emit_method_table->store_id, comp->scope_cur, qst);

#else

mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_store_id_ops, comp->scope_cur, qst);

#endif

}

}

STATIC void compile_delete_id(compiler_t *comp, qstr qst) {

if (comp->pass == MP_PASS_SCOPE) {

mp_emit_common_get_id_for_modification(comp->scope_cur, qst);

} else {

#if NEED_METHOD_TABLE

mp_emit_common_id_op(comp->emit, &comp->emit_method_table->delete_id, comp->scope_cur, qst);

#else

mp_emit_common_id_op(comp->emit, &mp_emit_bc_method_table_delete_id_ops, comp->scope_cur, qst);

#endif

}

}

STATIC void c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t *pns_list) {

int total = 0;

if (!MP_PARSE_NODE_IS_NULL(pn)) {

compile_node(comp, pn);

total += 1;

}

if (pns_list != NULL) {

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);

for (int i = 0; i < n; i++) {

compile_node(comp, pns_list->nodes[i]);

}

total += n;

}

EMIT_ARG(build_tuple, total);

}

STATIC void compile_generic_tuple(compiler_t *comp, mp_parse_node_struct_t *pns) {

// a simple tuple expression

c_tuple(comp, MP_PARSE_NODE_NULL, pns);

}

STATIC void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label) {

if (mp_parse_node_is_const_false(pn)) {

if (jump_if == false) {

EMIT_ARG(jump, label);

}

return;

} else if (mp_parse_node_is_const_true(pn)) {

if (jump_if == true) {

EMIT_ARG(jump, label);

}

return;

} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);

if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {

if (jump_if == false) {

and_or_logic1:;

uint label2 = comp_next_label(comp);

for (int i = 0; i < n - 1; i++) {

c_if_cond(comp, pns->nodes[i], !jump_if, label2);

}

c_if_cond(comp, pns->nodes[n - 1], jump_if, label);

EMIT_ARG(label_assign, label2);

} else {

and_or_logic2:

for (int i = 0; i < n; i++) {

c_if_cond(comp, pns->nodes[i], jump_if, label);

}

}

return;

} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {

if (jump_if == false) {

goto and_or_logic2;

} else {

goto and_or_logic1;

}

} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {

c_if_cond(comp, pns->nodes[0], !jump_if, label);

return;

} else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_atom_paren) {

// cond is something in parenthesis

if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {

// empty tuple, acts as false for the condition

if (jump_if == false) {

EMIT_ARG(jump, label);

}

} else {

assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));

// non-empty tuple, acts as true for the condition

if (jump_if == true) {

EMIT_ARG(jump, label);

}

}

return;

}

}

// nothing special, fall back to default compiling for node and jump

compile_node(comp, pn);

EMIT_ARG(pop_jump_if, jump_if, label);

}

typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;

STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t kind);

STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, assign_kind_t assign_kind) {

if (assign_kind != ASSIGN_AUG_STORE) {

compile_node(comp, pns->nodes[0]);

}

if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {

mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);

if (assign_kind != ASSIGN_AUG_STORE) {

for (int i = 0; i < n - 1; i++) {

compile_node(comp, pns1->nodes[i]);

}

}

assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));

pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];

}

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {

if (assign_kind == ASSIGN_AUG_STORE) {

EMIT(rot_three);

EMIT(store_subscr);

} else {

compile_node(comp, pns1->nodes[0]);

if (assign_kind == ASSIGN_AUG_LOAD) {

EMIT(dup_top_two);

EMIT(load_subscr);

} else {

EMIT(store_subscr);

}

}

} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {

assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));

if (assign_kind == ASSIGN_AUG_LOAD) {

EMIT(dup_top);

EMIT_ARG(load_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));

} else {

if (assign_kind == ASSIGN_AUG_STORE) {

EMIT(rot_two);

}

EMIT_ARG(store_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));

}

} else {

goto cannot_assign;

}

} else {

goto cannot_assign;

}

return;

cannot_assign:

compile_syntax_error(comp, (mp_parse_node_t)pns, "can't assign to expression");

}

STATIC void c_assign_tuple(compiler_t *comp, mp_parse_node_t node_head, uint num_tail, mp_parse_node_t *nodes_tail) {

uint num_head = (node_head == MP_PARSE_NODE_NULL) ? 0 : 1;

// look for star expression

uint have_star_index = -1;

if (num_head != 0 && MP_PARSE_NODE_IS_STRUCT_KIND(node_head, PN_star_expr)) {

EMIT_ARG(unpack_ex, 0, num_tail);

have_star_index = 0;

}

for (uint i = 0; i < num_tail; i++) {

if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes_tail[i], PN_star_expr)) {

if (have_star_index == (uint)-1) {

EMIT_ARG(unpack_ex, num_head + i, num_tail - i - 1);

have_star_index = num_head + i;

} else {

compile_syntax_error(comp, nodes_tail[i], "multiple *x in assignment");

return;

}

}

}

if (have_star_index == (uint)-1) {

EMIT_ARG(unpack_sequence, num_head + num_tail);

}

if (num_head != 0) {

if (0 == have_star_index) {

c_assign(comp, ((mp_parse_node_struct_t*)node_head)->nodes[0], ASSIGN_STORE);

} else {

c_assign(comp, node_head, ASSIGN_STORE);

}

}

for (uint i = 0; i < num_tail; i++) {

if (num_head + i == have_star_index) {

c_assign(comp, ((mp_parse_node_struct_t*)nodes_tail[i])->nodes[0], ASSIGN_STORE);

} else {

c_assign(comp, nodes_tail[i], ASSIGN_STORE);

}

}

}

STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_kind) {

assert(!MP_PARSE_NODE_IS_NULL(pn));

if (MP_PARSE_NODE_IS_LEAF(pn)) {

if (MP_PARSE_NODE_IS_ID(pn)) {

qstr arg = MP_PARSE_NODE_LEAF_ARG(pn);

switch (assign_kind) {

case ASSIGN_STORE:

case ASSIGN_AUG_STORE:

compile_store_id(comp, arg);

break;

case ASSIGN_AUG_LOAD:

default:

compile_load_id(comp, arg);

break;

}

} else {

goto cannot_assign;

}

} else {

// pn must be a struct

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {

case PN_atom_expr_normal:

// lhs is an index or attribute

c_assign_atom_expr(comp, pns, assign_kind);

break;

case PN_testlist_star_expr:

case PN_exprlist:

// lhs is a tuple

if (assign_kind != ASSIGN_STORE) {

goto cannot_assign;

}

c_assign_tuple(comp, MP_PARSE_NODE_NULL, MP_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);

break;

case PN_atom_paren:

// lhs is something in parenthesis

if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {

// empty tuple

goto cannot_assign;

} else {

assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));

if (assign_kind != ASSIGN_STORE) {

goto cannot_assign;

}

pns = (mp_parse_node_struct_t*)pns->nodes[0];

goto testlist_comp;

}

break;

case PN_atom_bracket:

// lhs is something in brackets

if (assign_kind != ASSIGN_STORE) {

goto cannot_assign;

}

if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {

// empty list, assignment allowed

c_assign_tuple(comp, MP_PARSE_NODE_NULL, 0, NULL);

} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {

pns = (mp_parse_node_struct_t*)pns->nodes[0];

goto testlist_comp;

} else {

// brackets around 1 item

c_assign_tuple(comp, pns->nodes[0], 0, NULL);

}

break;

default:

goto cannot_assign;

}

return;

testlist_comp:

// lhs is a sequence

if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {

mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];

if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {

// sequence of one item, with trailing comma

assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));

c_assign_tuple(comp, pns->nodes[0], 0, NULL);

} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {

// sequence of many items

uint n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns2);

c_assign_tuple(comp, pns->nodes[0], n, pns2->nodes);

} else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {

goto cannot_assign;

} else {

// sequence with 2 items

goto sequence_with_2_items;

}

} else {

// sequence with 2 items

sequence_with_2_items:

c_assign_tuple(comp, MP_PARSE_NODE_NULL, 2, pns->nodes);

}

return;

}

return;

cannot_assign:

compile_syntax_error(comp, pn, "can't assign to expression");

}

STATIC void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int n_pos_defaults, int n_kw_defaults) {

assert(n_pos_defaults >= 0);

assert(n_kw_defaults >= 0);

// set flags

if (n_kw_defaults > 0) {

this_scope->scope_flags |= MP_SCOPE_FLAG_DEFKWARGS;

}

this_scope->num_def_pos_args = n_pos_defaults;

// make closed over variables, if any

// ensure they are closed over in the order defined in the outer scope (mainly to agree with CPython)

int nfree = 0;

if (comp->scope_cur->kind != SCOPE_MODULE) {

for (int i = 0; i < comp->scope_cur->id_info_len; i++) {

id_info_t *id = &comp->scope_cur->id_info[i];

if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) {

for (int j = 0; j < this_scope->id_info_len; j++) {

id_info_t *id2 = &this_scope->id_info[j];

if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {

// in MicroPython we load closures using LOAD_FAST

EMIT_LOAD_FAST(id->qst, id->local_num);

nfree += 1;

}

}

}

}

}

// make the function/closure

if (nfree == 0) {

EMIT_ARG(make_function, this_scope, n_pos_defaults, n_kw_defaults);

} else {

EMIT_ARG(make_closure, this_scope, nfree, n_pos_defaults, n_kw_defaults);

}

}

STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn) {

// For efficiency of the code below we extract the parse-node kind here

int pn_kind;

if (MP_PARSE_NODE_IS_ID(pn)) {

pn_kind = -1;

} else {

assert(MP_PARSE_NODE_IS_STRUCT(pn));

pn_kind = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn);

}

if (pn_kind == PN_typedargslist_star || pn_kind == PN_varargslist_star) {

comp->have_star = true;

/* don't need to distinguish bare from named star

} else if (pn_kind == PN_typedargslist_dbl_star || pn_kind == PN_varargslist_dbl_star) {

// named double star

// TODO do we need to do anything with this?

} else {

mp_parse_node_t pn_id;

mp_parse_node_t pn_equal;

if (pn_kind == -1) {

// this parameter is just an id

pn_id = pn;

pn_equal = MP_PARSE_NODE_NULL;

} else if (pn_kind == PN_typedargslist_name) {

// this parameter has a colon and/or equal specifier

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

pn_id = pns->nodes[0];

//pn_colon = pns->nodes[1]; // unused

pn_equal = pns->nodes[2];

} else {

assert(pn_kind == PN_varargslist_name); // should be

// this parameter has an equal specifier

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

pn_id = pns->nodes[0];

pn_equal = pns->nodes[1];

}

if (MP_PARSE_NODE_IS_NULL(pn_equal)) {

// this parameter does not have a default value

// check for non-default parameters given after default parameters (allowed by parser, but not syntactically valid)

if (!comp->have_star && comp->num_default_params != 0) {

compile_syntax_error(comp, pn, "non-default argument follows default argument");

return;

}

} else {

// this parameter has a default value

// in CPython, None (and True, False?) as default parameters are loaded with LOAD_NAME; don't understandy why

if (comp->have_star) {

comp->num_dict_params += 1;

// in MicroPython we put the default dict parameters into a dictionary using the bytecode

if (comp->num_dict_params == 1) {

// in MicroPython we put the default positional parameters into a tuple using the bytecode

// we need to do this here before we start building the map for the default keywords

if (comp->num_default_params > 0) {

EMIT_ARG(build_tuple, comp->num_default_params);

} else {

EMIT(load_null); // sentinel indicating empty default positional args

}

// first default dict param, so make the map

EMIT_ARG(build_map, 0);

}

// compile value then key, then store it to the dict

compile_node(comp, pn_equal);

EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pn_id));

EMIT(store_map);

} else {

comp->num_default_params += 1;

compile_node(comp, pn_equal);

}

}

}

}

STATIC void compile_funcdef_lambdef(compiler_t *comp, scope_t *scope, mp_parse_node_t pn_params, pn_kind_t pn_list_kind) {

// When we call compile_funcdef_lambdef_param below it can compile an arbitrary

// expression for default arguments, which may contain a lambda. The lambda will

// call here in a nested way, so we must save and restore the relevant state.

bool orig_have_star = comp->have_star;

uint16_t orig_num_dict_params = comp->num_dict_params;

uint16_t orig_num_default_params = comp->num_default_params;

// compile default parameters

comp->have_star = false;

comp->num_dict_params = 0;

comp->num_default_params = 0;

apply_to_single_or_list(comp, pn_params, pn_list_kind, compile_funcdef_lambdef_param);

if (comp->compile_error != MP_OBJ_NULL) {

return;

}

// in MicroPython we put the default positional parameters into a tuple using the bytecode

// the default keywords args may have already made the tuple; if not, do it now

if (comp->num_default_params > 0 && comp->num_dict_params == 0) {

EMIT_ARG(build_tuple, comp->num_default_params);

EMIT(load_null); // sentinel indicating empty default keyword args

}

// make the function

close_over_variables_etc(comp, scope, comp->num_default_params, comp->num_dict_params);

// restore state

comp->have_star = orig_have_star;

comp->num_dict_params = orig_num_dict_params;

comp->num_default_params = orig_num_default_params;

}

STATIC qstr compile_funcdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {

if (comp->pass == MP_PASS_SCOPE) {

// create a new scope for this function

scope_t *s = scope_new_and_link(comp, SCOPE_FUNCTION, (mp_parse_node_t)pns, emit_options);

// store the function scope so the compiling function can use it at each pass

pns->nodes[4] = (mp_parse_node_t)s;

}

// get the scope for this function

scope_t *fscope = (scope_t*)pns->nodes[4];

// compile the function definition

compile_funcdef_lambdef(comp, fscope, pns->nodes[1], PN_typedargslist);

// return its name (the 'f' in "def f(...):")

return fscope->simple_name;

}

STATIC qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {

if (comp->pass == MP_PASS_SCOPE) {

// create a new scope for this class

scope_t *s = scope_new_and_link(comp, SCOPE_CLASS, (mp_parse_node_t)pns, emit_options);

// store the class scope so the compiling function can use it at each pass

pns->nodes[3] = (mp_parse_node_t)s;

}

EMIT(load_build_class);

// scope for this class

scope_t *cscope = (scope_t*)pns->nodes[3];

// compile the class

close_over_variables_etc(comp, cscope, 0, 0);

// get its name

EMIT_ARG(load_const_str, cscope->simple_name);

// nodes[1] has parent classes, if any

// empty parenthesis (eg class C():) gets here as an empty PN_classdef_2 and needs special handling

mp_parse_node_t parents = pns->nodes[1];

if (MP_PARSE_NODE_IS_STRUCT_KIND(parents, PN_classdef_2)) {

parents = MP_PARSE_NODE_NULL;

}

compile_trailer_paren_helper(comp, parents, false, 2);

// return its name (the 'C' in class C(...):")

return cscope->simple_name;

}

STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_node_t *name_nodes, uint *emit_options) {

if (MP_PARSE_NODE_LEAF_ARG(name_nodes[0]) != MP_QSTR_micropython) {

return false;

}

if (name_len != 2) {

compile_syntax_error(comp, name_nodes[0], "invalid micropython decorator");

return true;

}

qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);

if (attr == MP_QSTR_bytecode) {

*emit_options = MP_EMIT_OPT_BYTECODE;

#if MICROPY_EMIT_NATIVE

} else if (attr == MP_QSTR_native) {

*emit_options = MP_EMIT_OPT_NATIVE_PYTHON;

} else if (attr == MP_QSTR_viper) {

*emit_options = MP_EMIT_OPT_VIPER;

#if MICROPY_EMIT_INLINE_ASM

} else if (attr == ASM_DECORATOR_QSTR) {

*emit_options = MP_EMIT_OPT_ASM;

#endif

} else {

compile_syntax_error(comp, name_nodes[1], "invalid micropython decorator");

}

return true;

}

STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {

// get the list of decorators

mp_parse_node_t *nodes;

int n = mp_parse_node_extract_list(&pns->nodes[0], PN_decorators, &nodes);

// inherit emit options for this function/class definition

uint emit_options = comp->scope_cur->emit_options;

// compile each decorator

int num_built_in_decorators = 0;

for (int i = 0; i < n; i++) {

assert(MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be

mp_parse_node_struct_t *pns_decorator = (mp_parse_node_struct_t*)nodes[i];

// nodes[0] contains the decorator function, which is a dotted name

mp_parse_node_t *name_nodes;

int name_len = mp_parse_node_extract_list(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);

// check for built-in decorators

if (compile_built_in_decorator(comp, name_len, name_nodes, &emit_options)) {

// this was a built-in

num_built_in_decorators += 1;

} else {

// not a built-in, compile normally

// compile the decorator function

compile_node(comp, name_nodes[0]);

for (int j = 1; j < name_len; j++) {

assert(MP_PARSE_NODE_IS_ID(name_nodes[j])); // should be

EMIT_ARG(load_attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[j]));

}

// nodes[1] contains arguments to the decorator function, if any

if (!MP_PARSE_NODE_IS_NULL(pns_decorator->nodes[1])) {

// call the decorator function with the arguments in nodes[1]

compile_node(comp, pns_decorator->nodes[1]);

}

}

}

// compile the body (funcdef, async funcdef or classdef) and get its name

mp_parse_node_struct_t *pns_body = (mp_parse_node_struct_t*)pns->nodes[1];

qstr body_name = 0;

if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {

body_name = compile_funcdef_helper(comp, pns_body, emit_options);

#if MICROPY_PY_ASYNC_AWAIT

} else if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_async_funcdef) {

assert(MP_PARSE_NODE_IS_STRUCT(pns_body->nodes[0]));

mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns_body->nodes[0];

body_name = compile_funcdef_helper(comp, pns0, emit_options);

scope_t *fscope = (scope_t*)pns0->nodes[4];

fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;

#endif

} else {

assert(MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef); // should be

body_name = compile_classdef_helper(comp, pns_body, emit_options);

}

// call each decorator

for (int i = 0; i < n - num_built_in_decorators; i++) {

EMIT_ARG(call_function, 1, 0, 0);

}

// store func/class object into name

compile_store_id(comp, body_name);

}

STATIC void compile_funcdef(compiler_t *comp, mp_parse_node_struct_t *pns) {

qstr fname = compile_funcdef_helper(comp, pns, comp->scope_cur->emit_options);

// store function object into function name

compile_store_id(comp, fname);

}

STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {

if (MP_PARSE_NODE_IS_ID(pn)) {

compile_delete_id(comp, MP_PARSE_NODE_LEAF_ARG(pn));

} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_expr_normal)) {

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

compile_node(comp, pns->nodes[0]); // base of the atom_expr_normal node

if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {

mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);

for (int i = 0; i < n - 1; i++) {

compile_node(comp, pns1->nodes[i]);

}

assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));

pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];

}

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {

compile_node(comp, pns1->nodes[0]);

EMIT(delete_subscr);

} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {

assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));

EMIT_ARG(delete_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));

} else {

goto cannot_delete;

}

} else {

goto cannot_delete;

}

} else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {

pn = ((mp_parse_node_struct_t*)pn)->nodes[0];

if (MP_PARSE_NODE_IS_NULL(pn)) {

goto cannot_delete;

} else {

assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp));

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

// TODO perhaps factorise testlist_comp code with other uses of PN_testlist_comp

if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {

mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {

// sequence of one item, with trailing comma

assert(MP_PARSE_NODE_IS_NULL(pns1->nodes[0]));

c_del_stmt(comp, pns->nodes[0]);

} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3c) {

// sequence of many items

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);

c_del_stmt(comp, pns->nodes[0]);

for (int i = 0; i < n; i++) {

c_del_stmt(comp, pns1->nodes[i]);

}

} else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for) {

goto cannot_delete;

} else {

// sequence with 2 items

goto sequence_with_2_items;

}

} else {

// sequence with 2 items

sequence_with_2_items:

c_del_stmt(comp, pns->nodes[0]);

c_del_stmt(comp, pns->nodes[1]);

}

}

} else {

// some arbitrary statement that we can't delete (eg del 1)

goto cannot_delete;

}

return;

cannot_delete:

compile_syntax_error(comp, (mp_parse_node_t)pn, "can't delete expression");

}

STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {

apply_to_single_or_list(comp, pns->nodes[0], PN_exprlist, c_del_stmt);

}

STATIC void compile_break_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {

if (comp->break_label == INVALID_LABEL) {

compile_syntax_error(comp, (mp_parse_node_t)pns, "'break' outside loop");

}

assert(comp->cur_except_level >= comp->break_continue_except_level);

EMIT_ARG(break_loop, comp->break_label, comp->cur_except_level - comp->break_continue_except_level);

}

STATIC void compile_continue_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {

if (comp->continue_label == INVALID_LABEL) {

compile_syntax_error(comp, (mp_parse_node_t)pns, "'continue' outside loop");

}

assert(comp->cur_except_level >= comp->break_continue_except_level);

EMIT_ARG(continue_loop, comp->continue_label, comp->cur_except_level - comp->break_continue_except_level);

}

STATIC void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {

if (comp->scope_cur->kind != SCOPE_FUNCTION) {

compile_syntax_error(comp, (mp_parse_node_t)pns, "'return' outside function");

return;

}

if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {

// no argument to 'return', so return None

EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);

} else if (MICROPY_COMP_RETURN_IF_EXPR

&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {

// special case when returning an if-expression; to match CPython optimisation

mp_parse_node_struct_t *pns_test_if_expr = (mp_parse_node_struct_t*)pns->nodes[0];

mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns_test_if_expr->nodes[1];

uint l_fail = comp_next_label(comp);

c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition

compile_node(comp, pns_test_if_expr->nodes[0]); // success value

EMIT(return_value);

EMIT_ARG(label_assign, l_fail);

compile_node(comp, pns_test_if_else->nodes[1]); // failure value

} else {

compile_node(comp, pns->nodes[0]);

}

EMIT(return_value);

}

STATIC void compile_yield_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {

compile_node(comp, pns->nodes[0]);

EMIT(pop_top);

}

STATIC void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {