#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include "py/scope.h"

#include "py/emit.h"

#include "py/compile.h"

#include "py/runtime.h"

#include "py/asmbase.h"

#include "py/nativeglue.h"

#include "py/persistentcode.h"

#include "py/smallint.h"

#if MICROPY_ENABLE_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 MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns) \

(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2 && \

MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for))

#define NEED_METHOD_TABLE MICROPY_EMIT_NATIVE

#if NEED_METHOD_TABLE

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

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

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

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

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

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

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

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

#if MICROPY_EMIT_NATIVE && MICROPY_DYNAMIC_COMPILER

#define NATIVE_EMITTER(f) emit_native_table[mp_dynamic_compiler.native_arch]->emit_##f

#define NATIVE_EMITTER_TABLE (emit_native_table[mp_dynamic_compiler.native_arch])

STATIC const emit_method_table_t *emit_native_table[] = {

NULL,

&emit_native_x86_method_table,

&emit_native_x64_method_table,

&emit_native_arm_method_table,

&emit_native_thumb_method_table,

&emit_native_thumb_method_table,

&emit_native_thumb_method_table,

&emit_native_thumb_method_table,

&emit_native_thumb_method_table,

&emit_native_xtensa_method_table,

&emit_native_xtensawin_method_table,

};

#elif MICROPY_EMIT_NATIVE

#if MICROPY_EMIT_X64

#define NATIVE_EMITTER(f) emit_native_x64_##f

#elif MICROPY_EMIT_X86

#define NATIVE_EMITTER(f) emit_native_x86_##f

#elif MICROPY_EMIT_THUMB

#define NATIVE_EMITTER(f) emit_native_thumb_##f

#elif MICROPY_EMIT_ARM

#define NATIVE_EMITTER(f) emit_native_arm_##f

#elif MICROPY_EMIT_XTENSA

#define NATIVE_EMITTER(f) emit_native_xtensa_##f

#elif MICROPY_EMIT_XTENSAWIN

#define NATIVE_EMITTER(f) emit_native_xtensawin_##f

#error "unknown native emitter"

#define NATIVE_EMITTER_TABLE (&NATIVE_EMITTER(method_table))

#if MICROPY_EMIT_INLINE_ASM && MICROPY_DYNAMIC_COMPILER

#define ASM_EMITTER(f) emit_asm_table[mp_dynamic_compiler.native_arch]->asm_##f

#define ASM_EMITTER_TABLE emit_asm_table[mp_dynamic_compiler.native_arch]

STATIC const emit_inline_asm_method_table_t *emit_asm_table[] = {

NULL,

NULL,

NULL,

&emit_inline_thumb_method_table,

&emit_inline_thumb_method_table,

&emit_inline_thumb_method_table,

&emit_inline_thumb_method_table,

&emit_inline_thumb_method_table,

&emit_inline_thumb_method_table,

&emit_inline_xtensa_method_table,

NULL,

};

#elif MICROPY_EMIT_INLINE_ASM

#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 ASM_EMITTER_TABLE &ASM_EMITTER(method_table)

#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 mp_emit_common_init(mp_emit_common_t *emit, qstr source_file) {

#if MICROPY_EMIT_BYTECODE_USES_QSTR_TABLE

mp_map_init(&emit->qstr_map, 1);

// add the source file as the first entry in the qstr table

mp_map_elem_t *elem = mp_map_lookup(&emit->qstr_map, MP_OBJ_NEW_QSTR(source_file), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);

elem->value = MP_OBJ_NEW_SMALL_INT(0);

#endif

mp_obj_list_init(&emit->const_obj_list, 0);

}

STATIC void mp_emit_common_start_pass(mp_emit_common_t *emit, pass_kind_t pass) {

emit->pass = pass;

if (pass == MP_PASS_CODE_SIZE) {

if (emit->ct_cur_child == 0) {

emit->children = NULL;

} else {

emit->children = m_new0(mp_raw_code_t *, emit->ct_cur_child);

}

}

emit->ct_cur_child = 0;

}

STATIC void mp_emit_common_populate_module_context(mp_emit_common_t *emit, qstr source_file, mp_module_context_t *context) {

#if MICROPY_EMIT_BYTECODE_USES_QSTR_TABLE

size_t qstr_map_used = emit->qstr_map.used;

mp_module_context_alloc_tables(context, qstr_map_used, emit->const_obj_list.len);

for (size_t i = 0; i < emit->qstr_map.alloc; ++i) {

if (mp_map_slot_is_filled(&emit->qstr_map, i)) {

size_t idx = MP_OBJ_SMALL_INT_VALUE(emit->qstr_map.table[i].value);

qstr qst = MP_OBJ_QSTR_VALUE(emit->qstr_map.table[i].key);

context->constants.qstr_table[idx] = qst;

}

}

#else

mp_module_context_alloc_tables(context, 0, emit->const_obj_list.len);

context->constants.source_file = source_file;

#endif

for (size_t i = 0; i < emit->const_obj_list.len; ++i) {

context->constants.obj_table[i] = emit->const_obj_list.items[i];

}

}

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, mp_rom_error_text_t msg) {

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

if (comp->compile_error == MP_OBJ_NULL) {

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

compile_error_set_line(comp, pn);

}

}

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

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

STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *pns, bool create_map);

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

STATIC uint comp_next_label(compiler_t *comp) {

return comp->next_label++;

}

#if MICROPY_EMIT_NATIVE

STATIC void reserve_labels_for_native(compiler_t *comp, int n) {

if (comp->scope_cur->emit_options != MP_EMIT_OPT_BYTECODE) {

comp->next_label += n;

}

}

#define reserve_labels_for_native(comp, n)

STATIC void compile_increase_except_level(compiler_t *comp, uint label, int kind) {

EMIT_ARG(setup_block, label, kind);

comp->cur_except_level += 1;

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

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

}

}

STATIC void compile_decrease_except_level(compiler_t *comp) {

assert(comp->cur_except_level > 0);

comp->cur_except_level -= 1;

EMIT(end_finally);

reserve_labels_for_native(comp, 1);

}

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

scope_t *scope = scope_new(kind, pn, emit_options);

scope->parent = comp->scope_cur;

scope->next = NULL;

if (comp->scope_head == NULL) {

comp->scope_head = scope;

} else {

scope_t *s = comp->scope_head;

while (s->next != NULL) {

s = s->next;

}

s->next = scope;

}

return scope;

}

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

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

if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, pn_list_kind)) {

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;

int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);

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

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

}

} else if (!MP_PARSE_NODE_IS_NULL(pn)) {

f(comp, pn);

}

}

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

int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);

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

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

if (comp->compile_error != MP_OBJ_NULL) {

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

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

return;

}

}

}

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

if (comp->pass == MP_PASS_SCOPE) {

mp_emit_common_get_id_for_load(comp->scope_cur, qst);

} else {

#if NEED_METHOD_TABLE

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

#else

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

#endif

}

}

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

if (comp->pass == MP_PASS_SCOPE) {

mp_emit_common_get_id_for_modification(comp->scope_cur, qst);

} else {

#if NEED_METHOD_TABLE

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

#else

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

#endif

}

}

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

if (comp->pass == MP_PASS_SCOPE) {

mp_emit_common_get_id_for_modification(comp->scope_cur, qst);

} else {

#if NEED_METHOD_TABLE

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

#else

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

#endif

}

}

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

// a simple tuple expression

size_t num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);

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

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

}

EMIT_ARG(build, num_nodes, MP_EMIT_BUILD_TUPLE);

}

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

if (mp_parse_node_is_const_false(pn)) {

if (jump_if == false) {

EMIT_ARG(jump, label);

}

return;

} else if (mp_parse_node_is_const_true(pn)) {

if (jump_if == true) {

EMIT_ARG(jump, label);

}

return;

} else if (MP_PARSE_NODE_IS_STRUCT(pn)) {

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);

if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {

if (jump_if == false) {

and_or_logic1:;

uint label2 = comp_next_label(comp);

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

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

}

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

EMIT_ARG(label_assign, label2);

} else {

and_or_logic2:

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

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

}

}

return;

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

if (jump_if == false) {

goto and_or_logic2;

} else {

goto and_or_logic1;

}

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

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

return;

}

}

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

compile_node(comp, pn);

EMIT_ARG(pop_jump_if, jump_if, label);

}

typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;

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

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

if (assign_kind != ASSIGN_AUG_STORE) {

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

}

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

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

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);

if (assign_kind != ASSIGN_AUG_STORE) {

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

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

}

}

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

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

}

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {

if (assign_kind == ASSIGN_AUG_STORE) {

EMIT(rot_three);

EMIT_ARG(subscr, MP_EMIT_SUBSCR_STORE);

} else {

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

if (assign_kind == ASSIGN_AUG_LOAD) {

EMIT(dup_top_two);

EMIT_ARG(subscr, MP_EMIT_SUBSCR_LOAD);

} else {

EMIT_ARG(subscr, MP_EMIT_SUBSCR_STORE);

}

}

return;

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

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

if (assign_kind == ASSIGN_AUG_LOAD) {

EMIT(dup_top);

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

} else {

if (assign_kind == ASSIGN_AUG_STORE) {

EMIT(rot_two);

}

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

}

return;

}

}

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

}

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

// look for star expression

uint have_star_index = -1;

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

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

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

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

have_star_index = i;

} else {

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

return;

}

}

}

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

EMIT_ARG(unpack_sequence, num_tail);

}

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

if (i == have_star_index) {

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

} else {

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

}

}

}

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

assert(!MP_PARSE_NODE_IS_NULL(pn));

if (MP_PARSE_NODE_IS_LEAF(pn)) {

if (MP_PARSE_NODE_IS_ID(pn)) {

qstr arg = MP_PARSE_NODE_LEAF_ARG(pn);

switch (assign_kind) {

case ASSIGN_STORE:

case ASSIGN_AUG_STORE:

compile_store_id(comp, arg);

break;

case ASSIGN_AUG_LOAD:

default:

compile_load_id(comp, arg);

break;

}

} else {

goto cannot_assign;

}

} else {

// pn must be a struct

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;

switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {

case PN_atom_expr_normal:

// lhs is an index or attribute

c_assign_atom_expr(comp, pns, assign_kind);

break;

case PN_testlist_star_expr:

case PN_exprlist:

// lhs is a tuple

if (assign_kind != ASSIGN_STORE) {

goto cannot_assign;

}

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

break;

case PN_atom_paren:

// lhs is something in parenthesis

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

// empty tuple

goto cannot_assign;

} else {

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

if (assign_kind != ASSIGN_STORE) {

goto cannot_assign;

}

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

goto testlist_comp;

}

break;

case PN_atom_bracket:

// lhs is something in brackets

if (assign_kind != ASSIGN_STORE) {

goto cannot_assign;

}

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

// empty list, assignment allowed

c_assign_tuple(comp, 0, NULL);

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

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

goto testlist_comp;

} else {

// brackets around 1 item

c_assign_tuple(comp, 1, pns->nodes);

}

break;

default:

goto cannot_assign;

}

return;

testlist_comp:

// lhs is a sequence

if (MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns)) {

goto cannot_assign;

}

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

return;

}

return;

cannot_assign:

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

}

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

assert(n_pos_defaults >= 0);

assert(n_kw_defaults >= 0);

// set flags

if (n_kw_defaults > 0) {

this_scope->scope_flags |= MP_SCOPE_FLAG_DEFKWARGS;

}

this_scope->num_def_pos_args = n_pos_defaults;

#if MICROPY_EMIT_NATIVE

// When creating a function/closure it will take a reference to the current globals

comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_REFGLOBALS | MP_SCOPE_FLAG_HASCONSTS;

#endif

// make closed over variables, if any

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

int nfree = 0;

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

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

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

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

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

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

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

// in MicroPython we load closures using LOAD_FAST

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

nfree += 1;

}

}

}

}

}

// make the function/closure

if (nfree == 0) {

EMIT_ARG(make_function, this_scope, n_pos_defaults, n_kw_defaults);

} else {

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

}

}

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

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

int pn_kind;

if (MP_PARSE_NODE_IS_ID(pn)) {

pn_kind = -1;

} else {

assert(MP_PARSE_NODE_IS_STRUCT(pn));

pn_kind = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn);

}

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

comp->have_star = true;

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

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

// named double star

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

} else {

mp_parse_node_t pn_id;

mp_parse_node_t pn_equal;

if (pn_kind == -1) {

// this parameter is just an id

pn_id = pn;

pn_equal = MP_PARSE_NODE_NULL;

} else if (pn_kind == PN_typedargslist_name) {

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

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;

pn_id = pns->nodes[0];

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

pn_equal = pns->nodes[2];

} else {

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

// this parameter has an equal specifier

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;

pn_id = pns->nodes[0];

pn_equal = pns->nodes[1];

}

if (MP_PARSE_NODE_IS_NULL(pn_equal)) {

// this parameter does not have a default value

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

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

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

return;

}

} else {

// this parameter has a default value

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

if (comp->have_star) {

comp->num_dict_params += 1;

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

if (comp->num_dict_params == 1) {

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

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

if (comp->num_default_params > 0) {

EMIT_ARG(build, comp->num_default_params, MP_EMIT_BUILD_TUPLE);

} else {

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

}

// first default dict param, so make the map

EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);

}

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

compile_node(comp, pn_equal);

EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pn_id));

EMIT(store_map);

} else {

comp->num_default_params += 1;

compile_node(comp, pn_equal);

}

}

}

}

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

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

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

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

bool orig_have_star = comp->have_star;

uint16_t orig_num_dict_params = comp->num_dict_params;

uint16_t orig_num_default_params = comp->num_default_params;

// compile default parameters

comp->have_star = false;

comp->num_dict_params = 0;

comp->num_default_params = 0;

apply_to_single_or_list(comp, pn_params, pn_list_kind, compile_funcdef_lambdef_param);

if (comp->compile_error != MP_OBJ_NULL) {

return;

}

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

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

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

EMIT_ARG(build, comp->num_default_params, MP_EMIT_BUILD_TUPLE);

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

}

// make the function

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

// restore state

comp->have_star = orig_have_star;

comp->num_dict_params = orig_num_dict_params;

comp->num_default_params = orig_num_default_params;

}

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, size_t name_len, mp_parse_node_t *name_nodes, uint *emit_options) {

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

return false;

}

if (name_len != 2) {

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

return true;

}

qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);

if (attr == MP_QSTR_bytecode) {

*emit_options = MP_EMIT_OPT_BYTECODE;

#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;

#endif

#if MICROPY_EMIT_INLINE_ASM

#if MICROPY_DYNAMIC_COMPILER

} else if (attr == MP_QSTR_asm_thumb) {

*emit_options = MP_EMIT_OPT_ASM;

} else if (attr == MP_QSTR_asm_xtensa) {

*emit_options = MP_EMIT_OPT_ASM;

#else

} else if (attr == ASM_DECORATOR_QSTR) {

*emit_options = MP_EMIT_OPT_ASM;

#endif

#endif

} else {

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

}

#if MICROPY_EMIT_NATIVE && MICROPY_DYNAMIC_COMPILER

if (*emit_options == MP_EMIT_OPT_NATIVE_PYTHON || *emit_options == MP_EMIT_OPT_VIPER) {

if (emit_native_table[mp_dynamic_compiler.native_arch] == NULL) {

compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid arch"));

}

} else if (*emit_options == MP_EMIT_OPT_ASM) {

if (emit_asm_table[mp_dynamic_compiler.native_arch] == NULL) {

compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid arch"));

}

}

#endif

return true;

}

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

// get the list of decorators

mp_parse_node_t *nodes;

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

// inherit emit options for this function/class definition

uint emit_options = comp->scope_cur->emit_options;

// compile each decorator

size_t num_built_in_decorators = 0;

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

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

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

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

mp_parse_node_t *name_nodes;

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

// check for built-in decorators

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

// this was a built-in

num_built_in_decorators += 1;

} else {

// not a built-in, compile normally

// compile the decorator function

compile_node(comp, name_nodes[0]);

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

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

EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[j]), MP_EMIT_ATTR_LOAD);

}

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

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

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

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

}

}

}

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

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

qstr body_name = 0;

if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {

body_name = compile_funcdef_helper(comp, pns_body, emit_options);

#if MICROPY_PY_ASYNC_AWAIT

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

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

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

body_name = compile_funcdef_helper(comp, pns0, emit_options);

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

fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR | MP_SCOPE_FLAG_ASYNC;

#endif

} else {

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

body_name = compile_classdef_helper(comp, pns_body, emit_options);

}

// call each decorator

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

EMIT_ARG(call_function, 1, 0, 0);

}

// store func/class object into name

compile_store_id(comp, body_name);

}

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

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

// store function object into function name

compile_store_id(comp, fname);

}

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

if (MP_PARSE_NODE_IS_ID(pn)) {

compile_delete_id(comp, MP_PARSE_NODE_LEAF_ARG(pn));

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

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;

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

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

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

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {

int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);

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

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

}

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

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

}

if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {

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

EMIT_ARG(subscr, MP_EMIT_SUBSCR_DELETE);

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

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

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

} else {

goto cannot_delete;

}

} else {

goto cannot_delete;

}

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

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

if (MP_PARSE_NODE_IS_NULL(pn)) {

goto cannot_delete;

} else {

assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp));

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;

if (MP_PARSE_NODE_TESTLIST_COMP_HAS_COMP_FOR(pns)) {

goto cannot_delete;

}

for (size_t i = 0; i < MP_PARSE_NODE_STRUCT_NUM_NODES(pns); ++i) {

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

}

}

} else {

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

goto cannot_delete;

}

return;

cannot_delete: