/*

* This file is part of the MicroPython project, http://micropython.org/

*

* The MIT License (MIT)

*

* Copyright (c) 2013-2016 Damien P. George

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

*/

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include "py/scope.h"

#include "py/emit.h"

#include "py/compile.h"

#include "py/runtime.h"

#if MICROPY_ENABLE_COMPILER

// TODO need to mangle __attr names

typedef enum {

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

#include "py/grammar.h"

#undef DEF_RULE

PN_maximum_number_of,

} pn_kind_t;

#define NEED_METHOD_TABLE MICROPY_EMIT_NATIVE

#if NEED_METHOD_TABLE

// we need a method table to do the lookup for the emitter functions

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

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

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

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

#else

// if we only have the bytecode emitter enabled then we can do a direct call to the functions

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

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

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

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

#endif

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

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

// elements in this struct are ordered to make it compact

typedef struct _compiler_t {

qstr source_file;

uint8_t is_repl;

uint8_t pass; // holds enum type pass_kind_t

uint8_t func_arg_is_super; // used to compile special case of super() function call

uint8_t have_star;

// try to keep compiler clean from nlr

mp_obj_t compile_error; // set to an exception object if there's an error

size_t compile_error_line; // set to best guess of line of error

uint next_label;

uint16_t num_dict_params;

uint16_t num_default_params;

uint16_t break_label; // highest bit set indicates we are breaking out of a for loop

uint16_t continue_label;

uint16_t cur_except_level; // increased for SETUP_EXCEPT, SETUP_FINALLY; decreased for POP_BLOCK, POP_EXCEPT

uint16_t break_continue_except_level;

mp_uint_t *co_data;

size_t num_scopes;

scope_t **scopes;

scope_t *scope_cur;

emit_t *emit; // current emitter

#if NEED_METHOD_TABLE

const emit_method_table_t *emit_method_table; // current emit method table

#endif

#if MICROPY_EMIT_INLINE_THUMB

emit_inline_asm_t *emit_inline_asm; // current emitter for inline asm

const emit_inline_asm_method_table_t *emit_inline_asm_method_table; // current emit method table for inline asm

#endif

} compiler_t;

STATIC void compile_error_set_line(compiler_t *comp, const byte *p) {

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

if (comp->compile_error_line == 0 && p != NULL && pt_is_any_rule(p)) {

size_t rule_id, src_line;

const byte *ptop;

pt_rule_extract(p, &rule_id, &src_line, &ptop);

comp->compile_error_line = src_line;

}

}

STATIC void compile_syntax_error(compiler_t *comp, const byte *p, 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, p);

}

}

STATIC void compile_trailer_paren_helper(compiler_t *comp, const byte *p_arglist, bool is_method_call, int n_positional_extra);

STATIC void compile_comprehension(compiler_t *comp, const byte *p, scope_kind_t kind);

STATIC const byte *compile_node(compiler_t *comp, const byte *p);

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 void scope_new_and_link(compiler_t *comp, size_t scope_idx, scope_kind_t kind, const byte *p, uint emit_options) {

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

scope->parent = comp->scope_cur;

comp->scopes[scope_idx] = scope;

}

typedef void (*apply_list_fun_t)(compiler_t *comp, const byte *p);

STATIC void apply_to_single_or_list(compiler_t *comp, const byte *p, pn_kind_t pn_list_kind, apply_list_fun_t f) {

if (pt_is_rule(p, pn_list_kind)) {

const byte *ptop;

p = pt_rule_extract_top(p, &ptop);

while (p != ptop) {

f(comp, p);

p = pt_next(p);

}

} else if (!pt_is_null(p)) {

f(comp, p);

}

}

STATIC void compile_generic_all_nodes(compiler_t *comp, const byte *p, const byte *ptop) {

while (p != ptop) {

//printf("NODE: %02x %02x %02x %02x\n", p[0], p[1], p[2], p[3]);

p = compile_node(comp, p);

}

}

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, const byte *p, const byte *p_list, const byte *p_list_top) {

int total = 0;

if (p != NULL) {

compile_node(comp, p);

total += 1;

}

while (p_list != p_list_top) {

p_list = compile_node(comp, p_list);

total += 1;

}

EMIT_ARG(build_tuple, total);

}

STATIC void compile_generic_tuple(compiler_t *comp, const byte *p, const byte *ptop) {

// a simple tuple expression

c_tuple(comp, NULL, p, ptop);

}

STATIC bool node_is_const_false(const byte *p) {

return pt_is_tok(p, MP_TOKEN_KW_FALSE)

|| (pt_is_small_int(p) && pt_small_int_value(p) == 0);

}

STATIC bool node_is_const_true(const byte *p) {

return pt_is_tok(p, MP_TOKEN_KW_TRUE)

|| (pt_is_small_int(p) && pt_small_int_value(p) != 0);

}

STATIC const byte *c_if_cond(compiler_t *comp, const byte *p, bool jump_if, int label) {

if (node_is_const_false(p)) {

if (jump_if == false) {

EMIT_ARG(jump, label);

}

return pt_next(p);

} else if (node_is_const_true(p)) {

if (jump_if == true) {

EMIT_ARG(jump, label);

}

return pt_next(p);

} else if (pt_is_any_rule(p)) {

const byte *ptop;

const byte *p2 = pt_rule_extract_top(p, &ptop);

if (pt_is_rule(p, PN_or_test)) {

if (jump_if == false) {

and_or_logic1:;

uint label2 = comp_next_label(comp);

while (pt_next(p2) != ptop) {

p2 = c_if_cond(comp, p2, !jump_if, label2);

}

p2 = c_if_cond(comp, p2, jump_if, label);

EMIT_ARG(label_assign, label2);

} else {

and_or_logic2:

while (p2 != ptop) {

p2 = c_if_cond(comp, p2, jump_if, label);

}

}

return p2;

} else if (pt_is_rule(p, PN_and_test)) {

if (jump_if == false) {

goto and_or_logic2;

} else {

goto and_or_logic1;

}

} else if (pt_is_rule(p, PN_not_test_2)) {

return c_if_cond(comp, p2, !jump_if, label);

} else if (pt_is_rule(p, PN_atom_paren)) {

// cond is something in parenthesis

if (pt_is_rule_empty(p)) {

// empty tuple, acts as false for the condition

if (jump_if == false) {

EMIT_ARG(jump, label);

}

} else {

assert(pt_is_rule(pt_rule_first(p), PN_testlist_comp));

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

if (jump_if == true) {

EMIT_ARG(jump, label);

}

}

return pt_next(p);

}

}

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

p = compile_node(comp, p);

EMIT_ARG(pop_jump_if, jump_if, label);

return p;

}

typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;

STATIC void c_assign(compiler_t *comp, const byte *p, assign_kind_t kind);

STATIC void c_assign_power(compiler_t *comp, const byte *p_orig, assign_kind_t assign_kind) {

const byte *ptop;

const byte *p0 = pt_rule_extract_top(p_orig, &ptop);

if (assign_kind != ASSIGN_AUG_STORE) {

compile_node(comp, p0);

}

const byte *p1 = pt_next(p0);

if (pt_is_null_with_top(p1, ptop)) {

cannot_assign:

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

return;

}

if (pt_is_rule(p1, PN_power_trailers)) {

const byte *p1top;

p1 = pt_rule_extract_top(p1, &p1top);

for (;;) {

const byte *p1next = pt_next(p1);

if (p1next >= p1top) {

break;

}

if (assign_kind != ASSIGN_AUG_STORE) {

compile_node(comp, p1);

}

p1 = p1next;

}

// p1 now points to final trailer for store

}

if (pt_is_rule(p1, PN_trailer_bracket)) {

if (assign_kind == ASSIGN_AUG_STORE) {

EMIT(rot_three);

EMIT(store_subscr);

} else {

compile_node(comp, pt_rule_first(p1));

if (assign_kind == ASSIGN_AUG_LOAD) {

EMIT(dup_top_two);

EMIT(load_subscr);

} else {

EMIT(store_subscr);

}

}

} else if (pt_is_rule(p1, PN_trailer_period)) {

qstr attr;

pt_extract_id(pt_rule_first(p1), &attr);

if (assign_kind == ASSIGN_AUG_LOAD) {

EMIT(dup_top);

EMIT_ARG(load_attr, attr);

} else {

if (assign_kind == ASSIGN_AUG_STORE) {

EMIT(rot_two);

}

EMIT_ARG(store_attr, attr);

}

} else {

goto cannot_assign;

}

if (!pt_is_null_with_top(pt_next(p1), ptop)) {

goto cannot_assign;

}

}

// we need to allow for a caller passing in 1 initial node followed by an array of nodes

STATIC void c_assign_tuple(compiler_t *comp, const byte *p_head, const byte *p_tail, const byte *p_tail_top) {

uint num_head = (p_head == NULL) ? 0 : 1;

uint num_tail = pt_num_nodes(p_tail, p_tail_top);

// look for star expression

const byte *p_star = NULL;

if (num_head != 0 && pt_is_rule(p_head, PN_star_expr)) {

EMIT_ARG(unpack_ex, 0, num_tail);

p_star = p_head;

}

uint i = 0;

for (const byte *p = p_tail; p != p_tail_top; p = pt_next(p), ++i) {

if (pt_is_rule(p, PN_star_expr)) {

if (p_star == NULL) {

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

p_star = p;

} else {

compile_syntax_error(comp, p, "multiple *x in assignment");

return;

}

}

}

if (p_star == NULL) {

EMIT_ARG(unpack_sequence, num_head + num_tail);

}

if (num_head != 0) {

if (p_head == p_star) {

c_assign(comp, pt_rule_first(p_head), ASSIGN_STORE);

} else {

c_assign(comp, p_head, ASSIGN_STORE);

}

}

for (const byte *p = p_tail; p != p_tail_top; p = pt_next(p)) {

if (p == p_star) {

c_assign(comp, pt_rule_first(p), ASSIGN_STORE);

} else {

c_assign(comp, p, ASSIGN_STORE);

}

}

}

// assigns top of stack to pn

STATIC void c_assign(compiler_t *comp, const byte *p, assign_kind_t assign_kind) {

assert(!pt_is_null(p));

if (pt_is_any_id(p)) {

qstr arg;

p = pt_extract_id(p, &arg);

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 if (!pt_is_any_rule(p)) {

compile_syntax_error(comp, p, "can't assign to literal");

} else {

switch (pt_rule_extract_rule_id(p)) {

case PN_power:

// lhs is an index or attribute

c_assign_power(comp, p, assign_kind);

break;

case PN_testlist_star_expr:

case PN_exprlist: {

// lhs is a tuple

if (assign_kind != ASSIGN_STORE) {

goto bad_aug;

}

const byte *ptop;

const byte *p0 = pt_rule_extract_top(p, &ptop);

c_assign_tuple(comp, NULL, p0, ptop);

break;

}

case PN_atom_paren: {

// lhs is something in parenthesis

const byte *ptop;

const byte *p0 = pt_rule_extract_top(p, &ptop);

if (pt_is_null_with_top(p0, ptop)) {

// empty tuple

goto cannot_assign;

} else {

assert(pt_is_rule(p0, PN_testlist_comp));

if (assign_kind != ASSIGN_STORE) {

goto bad_aug;

}

p = p0;

goto testlist_comp;

}

break;

}

case PN_atom_bracket: {

// lhs is something in brackets

if (assign_kind != ASSIGN_STORE) {

goto bad_aug;

}

const byte *ptop;

const byte *p0 = pt_rule_extract_top(p, &ptop); // skip rule header

if (pt_is_null_with_top(p0, ptop)) {

// empty list, assignment allowed

c_assign_tuple(comp, NULL, NULL, NULL);

} else if (pt_is_rule(p0, PN_testlist_comp)) {

p = p0;

goto testlist_comp;

} else {

// brackets around 1 item

c_assign_tuple(comp, p0, NULL, NULL);

}

break;

}

default:

goto cannot_assign;

}

return;

testlist_comp:;

// lhs is a sequence

const byte *ptop;

const byte *p0 = pt_rule_extract_top(p, &ptop);

const byte *p1 = pt_next(p0);

if (pt_is_rule(p1, PN_testlist_comp_3b)) {

// sequence of one item, with trailing comma

assert(pt_is_rule_empty(p1));

c_assign_tuple(comp, p0, NULL, NULL);

} else if (pt_is_rule(p1, PN_testlist_comp_3c)) {

// sequence of many items

p1 = pt_rule_extract_top(p1, &ptop);

c_assign_tuple(comp, p0, p1, ptop);

} else if (pt_is_rule(p1, PN_comp_for)) {

// TODO can we ever get here? can it be compiled?

goto cannot_assign;

} else {

// sequence with 2 items

c_assign_tuple(comp, NULL, p0, pt_next(p1));

}

}

return;

cannot_assign:

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

return;

bad_aug:

compile_syntax_error(comp, p, "illegal expression for augmented assignment");

}

// stuff for lambda and comprehensions and generators:

// if n_pos_defaults > 0 then there is a tuple on the stack with the positional defaults

// if n_kw_defaults > 0 then there is a dictionary on the stack with the keyword defaults

// if both exist, the tuple is above the dictionary (ie the first pop gets the tuple)

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

assert(n_pos_defaults >= 0);

assert(n_kw_defaults >= 0);

// set flags

if (n_kw_defaults > 0) {

this_scope->scope_flags |= MP_SCOPE_FLAG_DEFKWARGS;

}

this_scope->num_def_pos_args = n_pos_defaults;

// 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 Micro Python 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, const byte *p) {

const byte *p_orig = p;

if (pt_is_rule(p, PN_typedargslist_star)

|| pt_is_rule(p, PN_varargslist_star)) {

comp->have_star = true;

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

mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;

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

// bare star

} else {

// named star

}

*/

} else if (pt_is_rule(p, PN_typedargslist_dbl_star)

|| pt_is_rule(p, PN_varargslist_dbl_star)) {

// named double star

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

} else {

const byte *p_id;

const byte *p_colon = NULL;

const byte *p_equal = NULL;

if (pt_is_any_id(p)) {

// this parameter is just an id

p_id = p;

} else if (pt_is_rule(p, PN_typedargslist_name)) {

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

const byte *ptop;

p = pt_rule_extract_top(p, &ptop);

p_id = p;

p = pt_next(p);

if (p != ptop) {

p_colon = p;

p = pt_next(p);

if (p != ptop) {

p_equal = p;

}

}

} else {

assert(pt_is_rule(p, PN_varargslist_name)); // should be

// this parameter has an equal specifier

p_id = pt_rule_first(p);

p_equal = pt_next(p_id);

}

qstr q_id;

pt_extract_id(p_id, &q_id);

if (p_equal == NULL || pt_is_null(p_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, p_orig, "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 Micro Python we put the default dict parameters into a dictionary using the bytecode

if (comp->num_dict_params == 1) {

// in Micro Python 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, p_equal);

EMIT_ARG(load_const_str, q_id);

EMIT(store_map);

} else {

comp->num_default_params += 1;

compile_node(comp, p_equal);

}

}

// TODO p_colon not implemented

(void)p_colon;

}

}

STATIC void compile_funcdef_lambdef(compiler_t *comp, scope_t *scope, const byte *p, 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, p, pn_list_kind, compile_funcdef_lambdef_param);

if (comp->compile_error != MP_OBJ_NULL) {

return;

}

// in Micro Python 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;

}

// leaves function object on stack

// returns function name

STATIC qstr compile_funcdef_helper(compiler_t *comp, const byte *p, uint emit_options) {

mp_int_t scope_idx;

p = pt_get_small_int(p, &scope_idx);

if (comp->pass == MP_PASS_SCOPE) {

// create a new scope for this function

scope_new_and_link(comp, scope_idx, SCOPE_FUNCTION, p, emit_options);

}

p = pt_next(p); // skip function name

// get the scope for this function

scope_t *fscope = comp->scopes[scope_idx];

// compile the function definition

compile_funcdef_lambdef(comp, fscope, p, PN_typedargslist);

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

return fscope->simple_name;

}

// leaves class object on stack

// returns class name

STATIC qstr compile_classdef_helper(compiler_t *comp, const byte *p, uint emit_options) {

mp_int_t scope_idx;

p = pt_get_small_int(p, &scope_idx);

if (comp->pass == MP_PASS_SCOPE) {

// create a new scope for this class

scope_new_and_link(comp, scope_idx, SCOPE_CLASS, p, emit_options);

}

EMIT(load_build_class);

// scope for this class

scope_t *cscope = comp->scopes[scope_idx];

// compile the class

close_over_variables_etc(comp, cscope, 0, 0);

// get its name

EMIT_ARG(load_const_str, cscope->simple_name);

// second node has parent classes, if any

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

const byte *p_parents = pt_next(p);

if (pt_is_rule(p_parents, PN_classdef_2)) {

p_parents = NULL;

}

comp->func_arg_is_super = false;

compile_trailer_paren_helper(comp, p_parents, false, 2);

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

return cscope->simple_name;

}

// returns true if it was a built-in decorator (even if the built-in had an error)

STATIC bool compile_built_in_decorator(compiler_t *comp, const byte *p, const byte *ptop, uint *emit_options) {

qstr qst;

p = pt_extract_id(p, &qst);

if (qst != MP_QSTR_micropython) {

return false;

}

if (p >= ptop || pt_next(p) != ptop) {

compile_syntax_error(comp, NULL, "invalid micropython decorator");

return true;

}

qstr attr;

p = pt_extract_id(p, &attr);

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_THUMB

} else if (attr == MP_QSTR_asm_thumb) {

*emit_options = MP_EMIT_OPT_ASM_THUMB;

#endif

} else {

compile_syntax_error(comp, NULL, "invalid micropython decorator");

}

return true;

}

STATIC void compile_decorated(compiler_t *comp, const byte *p, const byte *ptop) {

// get the list of decorators

ptop = mp_parse_node_extract_list(&p, PN_decorators);

// inherit emit options for this function/class definition

uint emit_options = comp->scope_cur->emit_options;

// compile each decorator

int num_non_built_in_decorators = 0;

while (p != ptop) {

assert(pt_is_rule(p, PN_decorator)); // should be

const byte *ptop_decorator;

p = pt_rule_extract_top(p, &ptop_decorator);

// first node contains the decorator function, which is a dotted name

const byte *ptop_dotted_name = mp_parse_node_extract_list(&p, PN_dotted_name);

// check for built-in decorators

if (compile_built_in_decorator(comp, p, ptop_dotted_name, &emit_options)) {

// this was a built-in

} else {

// not a built-in, compile normally

num_non_built_in_decorators += 1;

// compile the decorator function

p = compile_node(comp, p);

while (p != ptop_dotted_name) {

assert(pt_is_any_id(p)); // should be

qstr qst;

p = pt_extract_id(p, &qst);

EMIT_ARG(load_attr, qst);

}

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

if (!pt_is_null_with_top(p, ptop_decorator)) {

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

comp->func_arg_is_super = false;

compile_node(comp, p);

}

}

p = ptop_decorator;

}

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

qstr body_name = 0;

p = pt_rule_first(ptop); // skip the rule header

if (pt_is_rule(ptop, PN_funcdef)) {

body_name = compile_funcdef_helper(comp, p, emit_options);

} else {

assert(pt_is_rule(ptop, PN_classdef)); // should be

body_name = compile_classdef_helper(comp, p, emit_options);

}

// call each decorator

while (num_non_built_in_decorators-- > 0) {

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, const byte *p, const byte *ptop) {

(void)ptop;

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

// store function object into function name

compile_store_id(comp, fname);

}

STATIC void c_del_stmt(compiler_t *comp, const byte *p) {

if (pt_is_any_id(p)) {

qstr id;

pt_extract_id(p, &id);

compile_delete_id(comp, id);

} else if (pt_is_rule(p, PN_power)) {

const byte *ptop;

const byte *p0 = pt_rule_extract_top(p, &ptop);

const byte *p1 = compile_node(comp, p0); // base of the power node

if (pt_is_rule(p1, PN_power_trailers)) {

const byte *p1top;

p1 = pt_rule_extract_top(p1, &p1top);

for (;;) {

const byte *p1next = pt_next(p1);

if (p1next == p1top) {

break;

}

compile_node(comp, p1);

p1 = p1next;

}

// p1 now points to final trailer for delete

}

const byte *p2;

if (pt_is_rule(p1, PN_trailer_bracket)) {

p2 = compile_node(comp, pt_rule_first(p1));

EMIT(delete_subscr);

} else if (pt_is_rule(p1, PN_trailer_period)) {

qstr id;

p2 = pt_extract_id(pt_rule_first(p1), &id);

EMIT_ARG(delete_attr, id);

} else {

goto cannot_delete;

}

if (!pt_is_null_with_top(p2, ptop)) {

goto cannot_delete;

}

} else if (pt_is_rule(p, PN_atom_paren)) {

if (pt_is_rule_empty(p)) {

goto cannot_delete;

} else {

p = pt_rule_first(p);

assert(pt_is_rule(p, PN_testlist_comp));

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

// or, simplify the logic here my making the parser simplify everything to a list

const byte *p0 = pt_rule_first(p);

c_del_stmt(comp, p0);

const byte *p1 = pt_next(p0);

if (pt_is_rule(p1, PN_testlist_comp_3b)) {

// sequence of one item, with trailing comma

assert(pt_is_rule_empty(p1));

} else if (pt_is_rule(p1, PN_testlist_comp_3c)) {

// sequence of many items

const byte *ptop;

p1 = pt_rule_extract_top(p1, &ptop);

while (p1 != ptop) {

c_del_stmt(comp, p1);

p1 = pt_next(p1);

}

} else if (pt_is_rule(p1, PN_comp_for)) {

// TODO not implemented; can't del comprehension? can we get here?

goto cannot_delete;

} else {

// sequence with 2 items

c_del_stmt(comp, p1);

}

}

} else {

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

goto cannot_delete;

}

return;

cannot_delete:

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

}

STATIC void compile_del_stmt(compiler_t *comp, const byte *p, const byte *ptop) {

(void)ptop;

apply_to_single_or_list(comp, p, PN_exprlist, c_del_stmt);

}

STATIC void compile_break_stmt(compiler_t *comp, const byte *p, const byte *ptop) {

(void)ptop;

if (comp->break_label == 0) {

compile_syntax_error(comp, p, "'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, const byte *p, const byte *ptop) {

(void)ptop;

if (comp->continue_label == 0) {

compile_syntax_error(comp, p, "'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, const byte *p, const byte *ptop) {

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

compile_syntax_error(comp, NULL, "'return' outside function");

return;

}

if (pt_is_null_with_top(p, ptop)) {

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

EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);

#if 0

// TODO do we need this optimisation? i guess it's hardly used

} else if (pt_is_rule(p, 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

#endif

} else {

compile_node(comp, p);

}

EMIT(return_value);

}

STATIC void compile_yield_stmt(compiler_t *comp, const byte *p, const byte *ptop) {

(void)ptop;

compile_node(comp, p);