summaryrefslogtreecommitdiffstatshomepage
path: root/py
diff options
context:
space:
mode:
Diffstat (limited to 'py')
-rw-r--r--py/compile.c420
-rw-r--r--py/emit.h8
-rw-r--r--py/emitbc.c4
-rw-r--r--py/emitcommon.c28
-rw-r--r--py/emitcpy.c901
-rw-r--r--py/mkrules.mk2
-rw-r--r--py/mpconfig.h6
-rw-r--r--py/parse.c4
-rw-r--r--py/py.mk1
-rw-r--r--py/scope.c56
-rw-r--r--py/scope.h1
11 files changed, 26 insertions, 1405 deletions
diff --git a/py/compile.c b/py/compile.c
index a124203e4b..b7ec070299 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -49,7 +49,7 @@ typedef enum {
PN_const_object, // special node for a constant, generic Python object
} pn_kind_t;
-#define NEED_METHOD_TABLE (MICROPY_EMIT_CPYTHON || MICROPY_EMIT_NATIVE)
+#define NEED_METHOD_TABLE MICROPY_EMIT_NATIVE
#if NEED_METHOD_TABLE
@@ -323,23 +323,6 @@ STATIC mp_parse_node_t fold_constants(compiler_t *comp, mp_parse_node_t pn, mp_m
case PN_power:
if (0) {
-#if MICROPY_EMIT_CPYTHON
- } else if (MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_NULL(pns->nodes[1]) && !MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
- // int ** x
- // can overflow; enabled only to compare with CPython
- mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[2];
- if (MP_PARSE_NODE_IS_SMALL_INT(pns2->nodes[0])) {
- int power = MP_PARSE_NODE_LEAF_SMALL_INT(pns2->nodes[0]);
- if (power >= 0) {
- int ans = 1;
- int base = MP_PARSE_NODE_LEAF_SMALL_INT(pns->nodes[0]);
- for (; power > 0; power--) {
- ans *= base;
- }
- pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, ans);
- }
- }
-#endif
#if MICROPY_COMP_MODULE_CONST
} else if (MP_PARSE_NODE_IS_ID(pns->nodes[0]) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_trailer_period) && MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
// id.id
@@ -464,163 +447,7 @@ STATIC void compile_delete_id(compiler_t *comp, qstr qst) {
}
}
-#if MICROPY_EMIT_CPYTHON
-STATIC bool cpython_c_tuple_is_const(mp_parse_node_t pn) {
- if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_string)) {
- return true;
- }
- if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_bytes)) {
- return true;
- }
- if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_const_object)) {
- return true;
- }
- if (!MP_PARSE_NODE_IS_LEAF(pn)) {
- return false;
- }
- if (MP_PARSE_NODE_IS_ID(pn)) {
- return false;
- }
- return true;
-}
-
-STATIC void cpython_c_print_quoted_str(vstr_t *vstr, const char *str, uint len, bool bytes) {
- bool has_single_quote = false;
- bool has_double_quote = false;
- for (int i = 0; i < len; i++) {
- if (str[i] == '\'') {
- has_single_quote = true;
- } else if (str[i] == '"') {
- has_double_quote = true;
- }
- }
- if (bytes) {
- vstr_printf(vstr, "b");
- }
- bool quote_single = false;
- if (has_single_quote && !has_double_quote) {
- vstr_printf(vstr, "\"");
- } else {
- quote_single = true;
- vstr_printf(vstr, "'");
- }
- for (int i = 0; i < len; i++) {
- if (str[i] == '\n') {
- vstr_printf(vstr, "\\n");
- } else if (str[i] == '\\') {
- vstr_printf(vstr, "\\\\");
- } else if (str[i] == '\'' && quote_single) {
- vstr_printf(vstr, "\\'");
- } else {
- vstr_printf(vstr, "%c", str[i]);
- }
- }
- if (has_single_quote && !has_double_quote) {
- vstr_printf(vstr, "\"");
- } else {
- vstr_printf(vstr, "'");
- }
-}
-
-STATIC void cpython_c_tuple_emit_const(compiler_t *comp, mp_parse_node_t pn, vstr_t *vstr) {
- if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_string) || MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_bytes)) {
- mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
- cpython_c_print_quoted_str(vstr, (const char*)pns->nodes[0], (mp_uint_t)pns->nodes[1], MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_bytes));
- return;
- }
-
- if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_const_object)) {
- mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
- mp_obj_print((mp_obj_t)pns->nodes[0], PRINT_REPR);
- return;
- }
-
- assert(MP_PARSE_NODE_IS_LEAF(pn));
- if (MP_PARSE_NODE_IS_SMALL_INT(pn)) {
- vstr_printf(vstr, INT_FMT, MP_PARSE_NODE_LEAF_SMALL_INT(pn));
- return;
- }
-
- mp_uint_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
- switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
- case MP_PARSE_NODE_ID: assert(0);
- case MP_PARSE_NODE_STRING:
- case MP_PARSE_NODE_BYTES: {
- mp_uint_t len;
- const byte *str = qstr_data(arg, &len);
- cpython_c_print_quoted_str(vstr, (const char*)str, len, MP_PARSE_NODE_LEAF_KIND(pn) == MP_PARSE_NODE_BYTES);
- break;
- }
- case MP_PARSE_NODE_TOKEN:
- switch (arg) {
- case MP_TOKEN_KW_FALSE: vstr_printf(vstr, "False"); break;
- case MP_TOKEN_KW_NONE: vstr_printf(vstr, "None"); break;
- case MP_TOKEN_KW_TRUE: vstr_printf(vstr, "True"); break;
- default: assert(0); // shouldn't happen
- }
- break;
- default: assert(0);
- }
-}
-
-STATIC void cpython_c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t *pns_list) {
- int n = 0;
- if (pns_list != NULL) {
- n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
- }
- int total = n;
- bool is_const = true;
- if (!MP_PARSE_NODE_IS_NULL(pn)) {
- total += 1;
- if (!cpython_c_tuple_is_const(pn)) {
- is_const = false;
- }
- }
- for (int i = 0; i < n; i++) {
- if (!cpython_c_tuple_is_const(pns_list->nodes[i])) {
- is_const = false;
- break;
- }
- }
- if (total > 0 && is_const) {
- bool need_comma = false;
- vstr_t *vstr = vstr_new();
- vstr_printf(vstr, "(");
- if (!MP_PARSE_NODE_IS_NULL(pn)) {
- cpython_c_tuple_emit_const(comp, pn, vstr);
- need_comma = true;
- }
- for (int i = 0; i < n; i++) {
- if (need_comma) {
- vstr_printf(vstr, ", ");
- }
- cpython_c_tuple_emit_const(comp, pns_list->nodes[i], vstr);
- need_comma = true;
- }
- if (total == 1) {
- vstr_printf(vstr, ",)");
- } else {
- vstr_printf(vstr, ")");
- }
- EMIT_ARG(load_const_verbatim_strn, vstr_str(vstr), vstr_len(vstr));
- vstr_free(vstr);
- } else {
- if (!MP_PARSE_NODE_IS_NULL(pn)) {
- compile_node(comp, pn);
- }
- for (int i = 0; i < n; i++) {
- compile_node(comp, pns_list->nodes[i]);
- }
- EMIT_ARG(build_tuple, total);
- }
-}
-#endif
-
-// funnelling all tuple creations through this function is purely so we can optionally agree with CPython
STATIC void c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t *pns_list) {
-#if MICROPY_EMIT_CPYTHON
- cpython_c_tuple(comp, pn, pns_list);
-#else
int total = 0;
if (!MP_PARSE_NODE_IS_NULL(pn)) {
compile_node(comp, pn);
@@ -634,7 +461,6 @@ STATIC void c_tuple(compiler_t *comp, mp_parse_node_t pn, mp_parse_node_struct_t
total += n;
}
EMIT_ARG(build_tuple, total);
-#endif
}
STATIC void compile_generic_tuple(compiler_t *comp, mp_parse_node_struct_t *pns) {
@@ -652,66 +478,7 @@ STATIC bool node_is_const_true(mp_parse_node_t pn) {
|| (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_SMALL_INT(pn) != 0);
}
-#if MICROPY_EMIT_CPYTHON
-// the is_nested variable is purely to match with CPython, which doesn't fully optimise not's
-STATIC void cpython_c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label, bool is_nested) {
- if (node_is_const_false(pn)) {
- if (jump_if == false) {
- EMIT_ARG(jump, label);
- }
- return;
- } else if (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) {
- uint label2 = comp_next_label(comp);
- for (int i = 0; i < n - 1; i++) {
- cpython_c_if_cond(comp, pns->nodes[i], true, label2, true);
- }
- cpython_c_if_cond(comp, pns->nodes[n - 1], false, label, true);
- EMIT_ARG(label_assign, label2);
- } else {
- for (int i = 0; i < n; i++) {
- cpython_c_if_cond(comp, pns->nodes[i], true, label, true);
- }
- }
- return;
- } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
- if (jump_if == false) {
- for (int i = 0; i < n; i++) {
- cpython_c_if_cond(comp, pns->nodes[i], false, label, true);
- }
- } else {
- uint label2 = comp_next_label(comp);
- for (int i = 0; i < n - 1; i++) {
- cpython_c_if_cond(comp, pns->nodes[i], false, label2, true);
- }
- cpython_c_if_cond(comp, pns->nodes[n - 1], true, label, true);
- EMIT_ARG(label_assign, label2);
- }
- return;
- } else if (!is_nested && MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
- cpython_c_if_cond(comp, pns->nodes[0], !jump_if, label, true);
- return;
- }
- }
-
- // nothing special, fall back to default compiling for node and jump
- compile_node(comp, pn);
- EMIT_ARG(pop_jump_if, jump_if, label);
-}
-#endif
-
STATIC void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int label) {
-#if MICROPY_EMIT_CPYTHON
- cpython_c_if_cond(comp, pn, jump_if, label, false);
-#else
if (node_is_const_false(pn)) {
if (jump_if == false) {
EMIT_ARG(jump, label);
@@ -773,7 +540,6 @@ STATIC void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int la
// nothing special, fall back to default compiling for node and jump
compile_node(comp, pn);
EMIT_ARG(pop_jump_if, jump_if, label);
-#endif
}
typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
@@ -992,8 +758,7 @@ STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_
compile_syntax_error(comp, pn, "illegal expression for augmented assignment");
}
-// stuff for lambda and comprehensions and generators
-// if we are not in CPython compatibility mode then:
+// 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)
@@ -1011,12 +776,8 @@ STATIC void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int
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) {
-#if MICROPY_EMIT_CPYTHON
- EMIT_ARG(load_closure, id->qst, id->local_num);
-#else
// in Micro Python we load closures using LOAD_FAST
EMIT_LOAD_FAST(id->qst, id->local_num);
-#endif
nfree += 1;
}
}
@@ -1085,10 +846,6 @@ STATIC void compile_funcdef_param(compiler_t *comp, mp_parse_node_t pn) {
if (comp->have_star) {
comp->num_dict_params += 1;
-#if MICROPY_EMIT_CPYTHON
- EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pn_id));
- compile_node(comp, pn_equal);
-#else
// 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
@@ -1106,7 +863,6 @@ STATIC void compile_funcdef_param(compiler_t *comp, mp_parse_node_t pn) {
compile_node(comp, pn_equal);
EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pn_id));
EMIT(store_map);
-#endif
} else {
comp->num_default_params += 1;
compile_node(comp, pn_equal);
@@ -1143,14 +899,12 @@ STATIC qstr compile_funcdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns
return MP_QSTR_NULL;
}
-#if !MICROPY_EMIT_CPYTHON
// 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
}
-#endif
// get the scope for this function
scope_t *fscope = (scope_t*)pns->nodes[4];
@@ -1558,12 +1312,8 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
EMIT_ARG(load_const_small_int, import_level);
// build the "fromlist" tuple
-#if MICROPY_EMIT_CPYTHON
- EMIT_ARG(load_const_verbatim_strn, "('*',)", 6);
-#else
EMIT_ARG(load_const_str, MP_QSTR__star_);
EMIT_ARG(build_tuple, 1);
-#endif
// do the import
qstr dummy_q;
@@ -1576,31 +1326,6 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
// build the "fromlist" tuple
mp_parse_node_t *pn_nodes;
int n = mp_parse_node_extract_list(&pns->nodes[1], PN_import_as_names, &pn_nodes);
-#if MICROPY_EMIT_CPYTHON
- {
- vstr_t *vstr = vstr_new();
- vstr_printf(vstr, "(");
- for (int i = 0; i < n; i++) {
- assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
- mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
- qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
- if (i > 0) {
- vstr_printf(vstr, ", ");
- }
- vstr_printf(vstr, "'");
- mp_uint_t len;
- const byte *str = qstr_data(id2, &len);
- vstr_add_strn(vstr, (const char*)str, len);
- vstr_printf(vstr, "'");
- }
- if (n == 1) {
- vstr_printf(vstr, ",");
- }
- vstr_printf(vstr, ")");
- EMIT_ARG(load_const_verbatim_strn, vstr_str(vstr), vstr_len(vstr));
- vstr_free(vstr);
- }
-#else
for (int i = 0; i < n; i++) {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
@@ -1608,7 +1333,6 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
EMIT_ARG(load_const_str, id2);
}
EMIT_ARG(build_tuple, n);
-#endif
// do the import
qstr dummy_q;
@@ -1704,21 +1428,21 @@ STATIC void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
uint l_end = comp_next_label(comp);
- // optimisation: don't emit anything when "if False" (not in CPython)
- if (MICROPY_EMIT_CPYTHON || !node_is_const_false(pns->nodes[0])) {
+ // optimisation: don't emit anything when "if False"
+ if (!node_is_const_false(pns->nodes[0])) {
uint l_fail = comp_next_label(comp);
c_if_cond(comp, pns->nodes[0], false, l_fail); // if condition
compile_node(comp, pns->nodes[1]); // if block
- // optimisation: skip everything else when "if True" (not in CPython)
- if (!MICROPY_EMIT_CPYTHON && node_is_const_true(pns->nodes[0])) {
+ // optimisation: skip everything else when "if True"
+ if (node_is_const_true(pns->nodes[0])) {
goto done;
}
if (
- // optimisation: don't jump over non-existent elif/else blocks (not in CPython)
- (MICROPY_EMIT_CPYTHON || !(MP_PARSE_NODE_IS_NULL(pns->nodes[2]) && MP_PARSE_NODE_IS_NULL(pns->nodes[3])))
+ // optimisation: don't jump over non-existent elif/else blocks
+ !(MP_PARSE_NODE_IS_NULL(pns->nodes[2]) && MP_PARSE_NODE_IS_NULL(pns->nodes[3]))
// optimisation: don't jump if last instruction was return
&& !EMIT(last_emit_was_return_value)
) {
@@ -1736,15 +1460,15 @@ STATIC void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_elif[i], PN_if_stmt_elif)); // should be
mp_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t*)pn_elif[i];
- // optimisation: don't emit anything when "if False" (not in CPython)
- if (MICROPY_EMIT_CPYTHON || !node_is_const_false(pns_elif->nodes[0])) {
+ // optimisation: don't emit anything when "if False"
+ if (!node_is_const_false(pns_elif->nodes[0])) {
uint l_fail = comp_next_label(comp);
c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition
compile_node(comp, pns_elif->nodes[1]); // elif block
- // optimisation: skip everything else when "elif True" (not in CPython)
- if (!MICROPY_EMIT_CPYTHON && node_is_const_true(pns_elif->nodes[0])) {
+ // optimisation: skip everything else when "elif True"
+ if (node_is_const_true(pns_elif->nodes[0])) {
goto done;
}
@@ -1781,23 +1505,6 @@ done:
STATIC void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
START_BREAK_CONTINUE_BLOCK
- // compared to CPython, we have an optimised version of while loops
-#if MICROPY_EMIT_CPYTHON
- uint done_label = comp_next_label(comp);
- EMIT_ARG(setup_loop, break_label);
- EMIT_ARG(label_assign, continue_label);
- c_if_cond(comp, pns->nodes[0], false, done_label); // condition
- compile_node(comp, pns->nodes[1]); // body
- if (!EMIT(last_emit_was_return_value)) {
- EMIT_ARG(jump, continue_label);
- }
- EMIT_ARG(label_assign, done_label);
- // CPython does not emit POP_BLOCK if the condition was a constant; don't undertand why
- // this is a small hack to agree with CPython
- if (!node_is_const_true(pns->nodes[0])) {
- EMIT(pop_block);
- }
-#else
if (!node_is_const_false(pns->nodes[0])) { // optimisation: don't emit anything for "while False"
uint top_label = comp_next_label(comp);
if (!node_is_const_true(pns->nodes[0])) { // optimisation: don't jump to cond for "while True"
@@ -1808,7 +1515,6 @@ STATIC void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
EMIT_ARG(label_assign, continue_label);
c_if_cond(comp, pns->nodes[0], true, top_label); // condition
}
-#endif
// break/continue apply to outer loop (if any) in the else block
END_BREAK_CONTINUE_BLOCK
@@ -1818,7 +1524,6 @@ STATIC void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
EMIT_ARG(label_assign, break_label);
}
-#if !MICROPY_EMIT_CPYTHON
// This function compiles an optimised for-loop of the form:
// for <var> in range(<start>, <end>, <step>):
// <body>
@@ -1899,10 +1604,8 @@ STATIC void compile_for_stmt_optimised_range(compiler_t *comp, mp_parse_node_t p
EMIT(pop_top);
}
}
-#endif
STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
-#if !MICROPY_EMIT_CPYTHON
// this bit optimises: for <x> in range(...), turning it into an explicitly incremented variable
// this is actually slower, but uses no heap memory
// for viper it will be much, much faster
@@ -1945,7 +1648,6 @@ STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
}
}
}
-#endif
START_BREAK_CONTINUE_BLOCK
comp->break_label |= MP_EMIT_BREAK_FROM_FOR;
@@ -1953,11 +1655,6 @@ STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
uint pop_label = comp_next_label(comp);
uint end_label = comp_next_label(comp);
- // I don't think our implementation needs SETUP_LOOP/POP_BLOCK for for-statements
-#if MICROPY_EMIT_CPYTHON
- EMIT_ARG(setup_loop, end_label);
-#endif
-
compile_node(comp, pns->nodes[1]); // iterator
EMIT(get_iter);
EMIT_ARG(label_assign, continue_label);
@@ -1973,10 +1670,6 @@ STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
// break/continue apply to outer loop (if any) in the else block
END_BREAK_CONTINUE_BLOCK
-#if MICROPY_EMIT_CPYTHON
- EMIT(pop_block);
-#endif
-
compile_node(comp, pns->nodes[3]); // else (not tested)
EMIT_ARG(label_assign, break_label);
@@ -2233,7 +1926,7 @@ STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns1->nodes[0]) == 2
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[0]) == 2) {
- // optimisation for a, b = c, d; to match CPython's optimisation
+ // optimisation for a, b = c, d
mp_parse_node_struct_t *pns10 = (mp_parse_node_struct_t*)pns1->nodes[0];
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
if (MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[0], PN_star_expr)
@@ -2251,7 +1944,7 @@ STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
&& MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns1->nodes[0]) == 3
&& MP_PARSE_NODE_STRUCT_NUM_NODES((mp_parse_node_struct_t*)pns->nodes[0]) == 3) {
- // optimisation for a, b, c = d, e, f; to match CPython's optimisation
+ // optimisation for a, b, c = d, e, f
mp_parse_node_struct_t *pns10 = (mp_parse_node_struct_t*)pns1->nodes[0];
mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
if (MP_PARSE_NODE_IS_STRUCT_KIND(pns0->nodes[0], PN_star_expr)
@@ -2485,7 +2178,6 @@ STATIC void compile_power(compiler_t *comp, mp_parse_node_struct_t *pns) {
STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_arglist, bool is_method_call, int n_positional_extra) {
// function to call is on top of stack
-#if !MICROPY_EMIT_CPYTHON
// this is to handle special super() call
if (MP_PARSE_NODE_IS_NULL(pn_arglist) && comp->func_arg_is_super && comp->scope_cur->kind == SCOPE_FUNCTION) {
compile_load_id(comp, MP_QSTR___class__);
@@ -2501,7 +2193,6 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar
compile_syntax_error(comp, MP_PARSE_NODE_NULL, "super() call cannot find self"); // really a TypeError
return;
}
-#endif
// get the list of arguments
mp_parse_node_t *args;
@@ -3184,7 +2875,7 @@ STATIC void compile_scope_comp_iter(compiler_t *comp, mp_parse_node_t pn_iter, m
}
STATIC void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
-#if MICROPY_EMIT_CPYTHON || MICROPY_ENABLE_DOC_STRING
+#if MICROPY_ENABLE_DOC_STRING
// see http://www.python.org/dev/peps/pep-0257/
// look for the first statement
@@ -3240,12 +2931,6 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
scope->exc_stack_size = 0;
}
-#if MICROPY_EMIT_CPYTHON
- if (comp->pass == MP_PASS_EMIT) {
- scope_print_info(scope);
- }
-#endif
-
// compile
if (MP_PARSE_NODE_IS_STRUCT_KIND(scope->pn, PN_eval_input)) {
assert(scope->kind == SCOPE_MODULE);
@@ -3331,11 +3016,7 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
// CPython uses .0, but we should be able to use anything that won't
// clash with a user defined variable. Best to use an existing qstr,
// so we use the blank qstr.
-#if MICROPY_EMIT_CPYTHON
- qstr qstr_arg = QSTR_FROM_STR_STATIC(".0");
-#else
qstr qstr_arg = MP_QSTR_;
-#endif
if (comp->pass == MP_PASS_SCOPE) {
bool added;
id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qstr_arg, &added);
@@ -3395,11 +3076,7 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
if (id->kind == ID_INFO_KIND_LOCAL) {
EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
} else {
-#if MICROPY_EMIT_CPYTHON
- EMIT_ARG(load_closure, MP_QSTR___class__, 0); // XXX check this is the correct local num
-#else
EMIT_LOAD_FAST(MP_QSTR___class__, id->local_num);
-#endif
}
EMIT(return_value);
}
@@ -3547,7 +3224,6 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind
#endif
STATIC void scope_compute_things(scope_t *scope) {
-#if !MICROPY_EMIT_CPYTHON
// in Micro Python we put the *x parameter after all other parameters (except **y)
if (scope->scope_flags & MP_SCOPE_FLAG_VARARGS) {
id_info_t *id_param = NULL;
@@ -3564,7 +3240,6 @@ STATIC void scope_compute_things(scope_t *scope) {
}
}
}
-#endif
// in functions, turn implicit globals into explicit globals
// compute the index of each local
@@ -3584,19 +3259,9 @@ STATIC void scope_compute_things(scope_t *scope) {
}
}
- // compute the index of cell vars (freevars[idx] in CPython)
-#if MICROPY_EMIT_CPYTHON
- int num_cell = 0;
-#endif
+ // compute the index of cell vars
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
-#if MICROPY_EMIT_CPYTHON
- // in CPython the cells are numbered starting from 0
- if (id->kind == ID_INFO_KIND_CELL) {
- id->local_num = num_cell;
- num_cell += 1;
- }
-#else
// in Micro Python the cells come right after the fast locals
// parameters are not counted here, since they remain at the start
// of the locals, even if they are cell vars
@@ -3604,10 +3269,9 @@ STATIC void scope_compute_things(scope_t *scope) {
id->local_num = scope->num_locals;
scope->num_locals += 1;
}
-#endif
}
- // compute the index of free vars (freevars[idx] in CPython)
+ // compute the index of free vars
// make sure they are in the order of the parent scope
if (scope->parent != NULL) {
int num_free = 0;
@@ -3618,19 +3282,13 @@ STATIC void scope_compute_things(scope_t *scope) {
id_info_t *id2 = &scope->id_info[j];
if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) {
assert(!(id2->flags & ID_FLAG_IS_PARAM)); // free vars should not be params
-#if MICROPY_EMIT_CPYTHON
- // in CPython the frees are numbered after the cells
- id2->local_num = num_cell + num_free;
-#else
// in Micro Python the frees come first, before the params
id2->local_num = num_free;
-#endif
num_free += 1;
}
}
}
}
-#if !MICROPY_EMIT_CPYTHON
// in Micro Python shift all other locals after the free locals
if (num_free > 0) {
for (int i = 0; i < scope->id_info_len; i++) {
@@ -3642,23 +3300,9 @@ STATIC void scope_compute_things(scope_t *scope) {
scope->num_pos_args += num_free; // free vars are counted as params for passing them into the function
scope->num_locals += num_free;
}
-#endif
}
// compute scope_flags
-
-#if MICROPY_EMIT_CPYTHON
- // these flags computed here are for CPython compatibility only
- if (scope->kind == SCOPE_FUNCTION || scope->kind == SCOPE_LAMBDA || scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
- assert(scope->parent != NULL);
- scope->scope_flags |= MP_SCOPE_FLAG_NEWLOCALS;
- scope->scope_flags |= MP_SCOPE_FLAG_OPTIMISED;
- if ((SCOPE_FUNCTION <= scope->parent->kind && scope->parent->kind <= SCOPE_SET_COMP) || (scope->parent->kind == SCOPE_CLASS && scope->parent->parent->kind == SCOPE_FUNCTION)) {
- scope->scope_flags |= MP_SCOPE_FLAG_NESTED;
- }
- }
-#endif
-
int num_free = 0;
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
@@ -3688,22 +3332,13 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, uint emit_opt, bool is
mp_map_deinit(&consts);
// create standard emitter; it's used at least for MP_PASS_SCOPE
- #if MICROPY_EMIT_CPYTHON
- emit_t *emit_cpython = emit_cpython_new();
- #else
emit_t *emit_bc = emit_bc_new();
- #endif
// compile pass 1
- #if MICROPY_EMIT_CPYTHON
- comp->emit = emit_cpython;
- comp->emit_method_table = &emit_cpython_method_table;
- #else
comp->emit = emit_bc;
#if MICROPY_EMIT_NATIVE
comp->emit_method_table = &emit_bc_method_table;
#endif
- #endif
#if MICROPY_EMIT_INLINE_THUMB
comp->emit_inline_asm = NULL;
comp->emit_inline_asm_method_table = NULL;
@@ -3731,21 +3366,15 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, uint emit_opt, bool is
}
// set max number of labels now that it's calculated
- #if MICROPY_EMIT_CPYTHON
- emit_cpython_set_max_num_labels(emit_cpython, max_num_labels);
- #else
emit_bc_set_max_num_labels(emit_bc, max_num_labels);
- #endif
// compile pass 2 and 3
-#if !MICROPY_EMIT_CPYTHON
#if MICROPY_EMIT_NATIVE
emit_t *emit_native = NULL;
#endif
#if MICROPY_EMIT_INLINE_THUMB
emit_inline_asm_t *emit_inline_thumb = NULL;
#endif
-#endif // !MICROPY_EMIT_CPYTHON
for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
if (false) {
// dummy
@@ -3770,10 +3399,6 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, uint emit_opt, bool is
// choose the emit type
-#if MICROPY_EMIT_CPYTHON
- comp->emit = emit_cpython;
- comp->emit_method_table = &emit_cpython_method_table;
-#else
switch (s->emit_options) {
#if MICROPY_EMIT_NATIVE
@@ -3812,7 +3437,6 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, uint emit_opt, bool is
#endif
break;
}
-#endif // !MICROPY_EMIT_CPYTHON
// need a pass to compute stack size
compile_scope(comp, s, MP_PASS_STACK_SIZE);
@@ -3840,9 +3464,6 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, uint emit_opt, bool is
// free the emitters
-#if MICROPY_EMIT_CPYTHON
- emit_cpython_free(emit_cpython);
-#else
emit_bc_free(emit_bc);
#if MICROPY_EMIT_NATIVE
if (emit_native != NULL) {
@@ -3862,7 +3483,6 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, uint emit_opt, bool is
emit_inline_thumb_free(emit_inline_thumb);
}
#endif
-#endif // MICROPY_EMIT_CPYTHON
// free the parse tree
mp_parse_node_free(module_scope->pn);
@@ -3882,13 +3502,7 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, uint emit_opt, bool is
if (compile_error != MP_OBJ_NULL) {
nlr_raise(compile_error);
} else {
-#if MICROPY_EMIT_CPYTHON
- // can't create code, so just return true
- (void)outer_raw_code; // to suppress warning that outer_raw_code is unused
- return mp_const_true;
-#else
// return function that executes the outer module
return mp_make_function_from_raw_code(outer_raw_code, MP_OBJ_NULL, MP_OBJ_NULL);
-#endif
}
}
diff --git a/py/emit.h b/py/emit.h
index 8b980c1023..4f60a6fff8 100644
--- a/py/emit.h
+++ b/py/emit.h
@@ -145,14 +145,6 @@ typedef struct _emit_method_table_t {
// they may or may not emit code
void (*start_except_handler)(emit_t *emit);
void (*end_except_handler)(emit_t *emit);
-
-#if MICROPY_EMIT_CPYTHON
- // these methods are only needed for emitcpy
- void (*load_const_verbatim_strn)(emit_t *emit, const char *str, mp_uint_t len);
- void (*load_closure)(emit_t *emit, qstr qst, mp_uint_t local_num);
- void (*setup_loop)(emit_t *emit, mp_uint_t label);
-#endif
-
} emit_method_table_t;
void mp_emit_common_get_id_for_load(scope_t *scope, qstr qst);
diff --git a/py/emitbc.c b/py/emitbc.c
index fef9054c75..11e65f62e3 100644
--- a/py/emitbc.c
+++ b/py/emitbc.c
@@ -34,8 +34,6 @@
#include "py/emit.h"
#include "py/bc0.h"
-#if !MICROPY_EMIT_CPYTHON
-
#define BYTES_FOR_INT ((BYTES_PER_WORD * 8 + 6) / 7)
#define DUMMY_DATA_SIZE (BYTES_FOR_INT)
@@ -1030,5 +1028,3 @@ const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_delete_id_ops = {
mp_emit_bc_delete_global,
};
#endif
-
-#endif // !MICROPY_EMIT_CPYTHON
diff --git a/py/emitcommon.c b/py/emitcommon.c
index 7eda5e05fd..1fd2bd1dc1 100644
--- a/py/emitcommon.c
+++ b/py/emitcommon.c
@@ -33,28 +33,12 @@ void mp_emit_common_get_id_for_load(scope_t *scope, qstr qst) {
bool added;
id_info_t *id = scope_find_or_add_id(scope, qst, &added);
if (added) {
-#if MICROPY_EMIT_CPYTHON
- if (qst == MP_QSTR_super && scope->kind == SCOPE_FUNCTION) {
- // special case, super is a global, and also counts as use of __class__
- id->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
- id_info_t *id2 = scope_find_local_in_parent(scope, MP_QSTR___class__);
- if (id2 != NULL) {
- id2 = scope_find_or_add_id(scope, MP_QSTR___class__, &added);
- if (added) {
- id2->kind = ID_INFO_KIND_FREE;
- scope_close_over_in_parents(scope, MP_QSTR___class__);
- }
- }
- } else
-#endif
- {
- id_info_t *id2 = scope_find_local_in_parent(scope, qst);
- if (id2 != NULL && (id2->kind == ID_INFO_KIND_LOCAL || id2->kind == ID_INFO_KIND_CELL || id2->kind == ID_INFO_KIND_FREE)) {
- id->kind = ID_INFO_KIND_FREE;
- scope_close_over_in_parents(scope, qst);
- } else {
- id->kind = ID_INFO_KIND_GLOBAL_IMPLICIT;
- }
+ id_info_t *id2 = scope_find_local_in_parent(scope, qst);
+ if (id2 != NULL && (id2->kind == ID_INFO_KIND_LOCAL || id2->kind == ID_INFO_KIND_CELL || id2->kind == ID_INFO_KIND_FREE)) {
+ id->kind = ID_INFO_KIND_FREE;
+ scope_close_over_in_parents(scope, qst);
+ } else {
+ id->kind = ID_INFO_KIND_GLOBAL_IMPLICIT;
}
}
}
diff --git a/py/emitcpy.c b/py/emitcpy.c
deleted file mode 100644
index 3bdec1716d..0000000000
--- a/py/emitcpy.c
+++ /dev/null
@@ -1,901 +0,0 @@
-/*
- * This file is part of the Micro Python project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2013, 2014 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/emit.h"
-
-// wrapper around everything in this file
-#if MICROPY_EMIT_CPYTHON
-
-struct _emit_t {
- int pass;
- int bytecode_offset;
- int stack_size;
- bool last_emit_was_return_value;
-
- scope_t *scope;
-
- mp_uint_t max_num_labels;
- mp_uint_t *label_offsets;
-};
-
-emit_t *emit_cpython_new(void) {
- emit_t *emit = m_new0(emit_t, 1);
- return emit;
-}
-
-void emit_cpython_set_max_num_labels(emit_t* emit, mp_uint_t max_num_labels) {
- emit->max_num_labels = max_num_labels;
- emit->label_offsets = m_new(mp_uint_t, max_num_labels);
-}
-
-void emit_cpython_free(emit_t *emit) {
- m_del(mp_uint_t, emit->label_offsets, emit->max_num_labels);
- m_del_obj(emit_t, emit);
-}
-
-STATIC void emit_cpy_set_native_type(emit_t *emit, mp_uint_t op, mp_uint_t arg1, qstr arg2) {
-}
-
-STATIC void emit_cpy_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
- emit->pass = pass;
- emit->bytecode_offset = 0;
- emit->stack_size = 0;
- emit->last_emit_was_return_value = false;
- emit->scope = scope;
- if (pass < MP_PASS_EMIT) {
- memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(mp_uint_t));
- }
-}
-
-STATIC void emit_cpy_end_pass(emit_t *emit) {
- if (emit->pass == MP_PASS_SCOPE) {
- return;
- }
- // check stack is back to zero size
- if (emit->stack_size != 0) {
- printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
- }
-}
-
-STATIC bool emit_cpy_last_emit_was_return_value(emit_t *emit) {
- return emit->last_emit_was_return_value;
-}
-
-STATIC void emit_cpy_adjust_stack_size(emit_t *emit, mp_int_t delta) {
- emit->stack_size += delta;
-}
-
-STATIC void emit_cpy_set_source_line(emit_t *emit, mp_uint_t source_line) {
-}
-
-// TODO: module-polymorphic function (read: name clash if made global)
-static void emit_pre(emit_t *emit, int stack_size_delta, int bytecode_size) {
- if (emit->pass == MP_PASS_SCOPE) {
- return;
- }
- emit->stack_size += stack_size_delta;
- if (emit->stack_size > emit->scope->stack_size) {
- emit->scope->stack_size = emit->stack_size;
- }
- emit->last_emit_was_return_value = false;
- if (emit->pass == MP_PASS_EMIT && bytecode_size > 0) {
- if (emit->bytecode_offset >= 1000) {
- printf("%d ", emit->bytecode_offset);
- } else {
- printf("% 4d ", emit->bytecode_offset);
- }
- }
- emit->bytecode_offset += bytecode_size;
-}
-
-STATIC void emit_cpy_label_assign(emit_t *emit, mp_uint_t l) {
- emit_pre(emit, 0, 0);
- if (emit->pass == MP_PASS_SCOPE) {
- return;
- }
- assert(l < emit->max_num_labels);
- if (emit->pass < MP_PASS_EMIT) {
- // assign label offset
- assert(emit->label_offsets[l] == -1);
- emit->label_offsets[l] = emit->bytecode_offset;
- } else {
- // ensure label offset has not changed from MP_PASS_CODE_SIZE to MP_PASS_EMIT
- assert(emit->label_offsets[l] == emit->bytecode_offset);
- //printf("l%d: (at %d)\n", l, emit->bytecode_offset);
- }
-}
-
-STATIC void emit_cpy_import_name(emit_t *emit, qstr qst) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("IMPORT_NAME %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_import_from(emit_t *emit, qstr qst) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("IMPORT_FROM %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_import_star(emit_t *emit) {
- emit_pre(emit, -1, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("IMPORT_STAR\n");
- }
-}
-
-STATIC void emit_cpy_load_const_tok(emit_t *emit, mp_token_kind_t tok) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CONST ");
- switch (tok) {
- case MP_TOKEN_KW_FALSE: printf("False"); break;
- case MP_TOKEN_KW_NONE: printf("None"); break;
- case MP_TOKEN_KW_TRUE: printf("True"); break;
- default: printf("?=%d\n", tok); return; assert(0);
- }
- printf("\n");
- }
-}
-
-STATIC void emit_cpy_load_const_small_int(emit_t *emit, mp_int_t arg) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CONST " INT_FMT "\n", arg);
- }
-}
-
-STATIC void print_quoted_str(qstr qst) {
- const char *str = qstr_str(qst);
- int len = strlen(str);
- bool has_single_quote = false;
- bool has_double_quote = false;
- for (int i = 0; i < len; i++) {
- if (str[i] == '\'') {
- has_single_quote = true;
- } else if (str[i] == '"') {
- has_double_quote = true;
- }
- }
- int quote_char = '\'';
- if (has_single_quote && !has_double_quote) {
- quote_char = '"';
- }
- printf("%c", quote_char);
- for (const char *s = str, *top = str + len; s < top; s++) {
- if (*s == quote_char) {
- printf("\\%c", quote_char);
- } else if (*s == '\\') {
- printf("\\\\");
- } else if (32 <= *s && *s <= 126) {
- printf("%c", *s);
- } else if (*s == '\n') {
- printf("\\n");
- // TODO add more escape codes here
- } else {
- printf("\\x%02x", (*s) & 0xff);
- }
- }
- printf("%c", quote_char);
-}
-
-STATIC void emit_cpy_load_const_str(emit_t *emit, qstr qst) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CONST ");
- print_quoted_str(qst);
- printf("\n");
- }
-}
-
-STATIC void emit_cpy_load_const_obj(emit_t *emit, void *obj) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CONST ");
- mp_obj_print(obj, PRINT_REPR);
- printf("\n");
- }
-}
-
-STATIC void emit_cpy_load_null(emit_t *emit) {
- // unused for cpy
- assert(0);
-}
-
-STATIC void emit_cpy_load_fast(emit_t *emit, qstr qst, mp_uint_t local_num) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_FAST " UINT_FMT " %s\n", local_num, qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_load_deref(emit_t *emit, qstr qst, mp_uint_t local_num) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_DEREF " UINT_FMT " %s\n", local_num, qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_load_name(emit_t *emit, qstr qst) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_NAME %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_load_global(emit_t *emit, qstr qst) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_GLOBAL %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_load_attr(emit_t *emit, qstr qst) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_ATTR %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_load_method(emit_t *emit, qstr qst) {
- emit_cpy_load_attr(emit, qst);
-}
-
-STATIC void emit_cpy_load_build_class(emit_t *emit) {
- emit_pre(emit, 1, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_BUILD_CLASS\n");
- }
-}
-
-STATIC void emit_cpy_load_subscr(emit_t *emit) {
- emit_pre(emit, -1, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("BINARY_SUBSCR\n");
- }
-}
-
-STATIC void emit_cpy_store_fast(emit_t *emit, qstr qst, mp_uint_t local_num) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("STORE_FAST " UINT_FMT " %s\n", local_num, qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_store_deref(emit_t *emit, qstr qst, mp_uint_t local_num) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("STORE_DEREF " UINT_FMT " %s\n", local_num, qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_store_name(emit_t *emit, qstr qst) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("STORE_NAME %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_store_global(emit_t *emit, qstr qst) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("STORE_GLOBAL %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_store_attr(emit_t *emit, qstr qst) {
- emit_pre(emit, -2, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("STORE_ATTR %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_store_subscr(emit_t *emit) {
- emit_pre(emit, -3, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("STORE_SUBSCR\n");
- }
-}
-
-STATIC void emit_cpy_delete_fast(emit_t *emit, qstr qst, mp_uint_t local_num) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DELETE_FAST " UINT_FMT " %s\n", local_num, qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_delete_deref(emit_t *emit, qstr qst, mp_uint_t local_num) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DELETE_DEREF " UINT_FMT " %s\n", local_num, qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_delete_name(emit_t *emit, qstr qst) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DELETE_NAME %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_delete_global(emit_t *emit, qstr qst) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DELETE_GLOBAL %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_delete_attr(emit_t *emit, qstr qst) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DELETE_ATTR %s\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_delete_subscr(emit_t *emit) {
- emit_pre(emit, -2, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DELETE_SUBSCR\n");
- }
-}
-
-STATIC void emit_cpy_dup_top(emit_t *emit) {
- emit_pre(emit, 1, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DUP_TOP\n");
- }
-}
-
-STATIC void emit_cpy_dup_top_two(emit_t *emit) {
- emit_pre(emit, 2, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("DUP_TOP_TWO\n");
- }
-}
-
-STATIC void emit_cpy_pop_top(emit_t *emit) {
- emit_pre(emit, -1, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("POP_TOP\n");
- }
-}
-
-STATIC void emit_cpy_rot_two(emit_t *emit) {
- emit_pre(emit, 0, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("ROT_TWO\n");
- }
-}
-
-STATIC void emit_cpy_rot_three(emit_t *emit) {
- emit_pre(emit, 0, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("ROT_THREE\n");
- }
-}
-
-STATIC void emit_cpy_jump(emit_t *emit, mp_uint_t label) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- int dest = emit->label_offsets[label];
- if (dest < emit->bytecode_offset) {
- printf("JUMP_ABSOLUTE " UINT_FMT "\n", emit->label_offsets[label]);
- } else {
- printf("JUMP_FORWARD " UINT_FMT "\n", emit->label_offsets[label]);
- }
- }
-}
-
-STATIC void emit_cpy_pop_jump_if(emit_t *emit, bool cond, mp_uint_t label) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- if (cond) {
- printf("POP_JUMP_IF_TRUE " UINT_FMT "\n", emit->label_offsets[label]);
- } else {
- printf("POP_JUMP_IF_FALSE " UINT_FMT "\n", emit->label_offsets[label]);
- }
- }
-}
-
-STATIC void emit_cpy_jump_if_or_pop(emit_t *emit, bool cond, mp_uint_t label) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- if (cond) {
- printf("JUMP_IF_TRUE_OR_POP " UINT_FMT "\n", emit->label_offsets[label]);
- } else {
- printf("JUMP_IF_FALSE_OR_POP " UINT_FMT "\n", emit->label_offsets[label]);
- }
- }
-}
-
-STATIC void emit_cpy_break_loop(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) {
- emit_pre(emit, 0, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("BREAK_LOOP\n");
- }
-}
-
-STATIC void emit_cpy_continue_loop(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) {
- if (except_depth == 0) {
- emit_cpy_jump(emit, label);
- } else {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("CONTINUE_LOOP " UINT_FMT "\n", emit->label_offsets[label]);
- }
- }
-}
-
-STATIC void emit_cpy_setup_with(emit_t *emit, mp_uint_t label) {
- emit_pre(emit, 7, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("SETUP_WITH " UINT_FMT "\n", emit->label_offsets[label]);
- }
-}
-
-STATIC void emit_cpy_with_cleanup(emit_t *emit) {
- emit_pre(emit, -7, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("WITH_CLEANUP\n");
- }
-}
-
-STATIC void emit_cpy_setup_except(emit_t *emit, mp_uint_t label) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("SETUP_EXCEPT " UINT_FMT "\n", emit->label_offsets[label]);
- }
-}
-
-STATIC void emit_cpy_setup_finally(emit_t *emit, mp_uint_t label) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("SETUP_FINALLY " UINT_FMT "\n", emit->label_offsets[label]);
- }
-}
-
-STATIC void emit_cpy_end_finally(emit_t *emit) {
- emit_pre(emit, -1, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("END_FINALLY\n");
- }
-}
-
-STATIC void emit_cpy_get_iter(emit_t *emit) {
- emit_pre(emit, 0, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("GET_ITER\n");
- }
-}
-
-STATIC void emit_cpy_for_iter(emit_t *emit, mp_uint_t label) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("FOR_ITER " UINT_FMT "\n", emit->label_offsets[label]);
- }
-}
-
-STATIC void emit_cpy_for_iter_end(emit_t *emit) {
- emit_pre(emit, -1, 0);
-}
-
-STATIC void emit_cpy_pop_block(emit_t *emit) {
- emit_pre(emit, 0, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("POP_BLOCK\n");
- }
-}
-
-STATIC void emit_cpy_pop_except(emit_t *emit) {
- emit_pre(emit, 0, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("POP_EXCEPT\n");
- }
-}
-
-STATIC void emit_cpy_unary_op(emit_t *emit, mp_unary_op_t op) {
- emit_pre(emit, 0, 1);
- if (emit->pass == MP_PASS_EMIT) {
- switch (op) {
- case MP_UNARY_OP_POSITIVE: printf("UNARY_POSITIVE\n"); break;
- case MP_UNARY_OP_NEGATIVE: printf("UNARY_NEGATIVE\n"); break;
- case MP_UNARY_OP_INVERT: printf("UNARY_INVERT\n"); break;
- case MP_UNARY_OP_NOT: printf("UNARY_NOT\n"); break;
- default: assert(0);
- }
- }
-}
-
-STATIC void emit_cpy_binary_op(emit_t *emit, mp_binary_op_t op) {
- if (op <= MP_BINARY_OP_INPLACE_POWER) {
- // CPython uses a byte code for each binary op
- emit_pre(emit, -1, 1);
- } else {
- // CPython uses a byte code plus an argument for compare ops
- emit_pre(emit, -1, 3);
- }
- if (emit->pass == MP_PASS_EMIT) {
- switch (op) {
- case MP_BINARY_OP_OR: printf("BINARY_OR\n"); break;
- case MP_BINARY_OP_XOR: printf("BINARY_XOR\n"); break;
- case MP_BINARY_OP_AND: printf("BINARY_AND\n"); break;
- case MP_BINARY_OP_LSHIFT: printf("BINARY_LSHIFT\n"); break;
- case MP_BINARY_OP_RSHIFT: printf("BINARY_RSHIFT\n"); break;
- case MP_BINARY_OP_ADD: printf("BINARY_ADD\n"); break;
- case MP_BINARY_OP_SUBTRACT: printf("BINARY_SUBTRACT\n"); break;
- case MP_BINARY_OP_MULTIPLY: printf("BINARY_MULTIPLY\n"); break;
- case MP_BINARY_OP_FLOOR_DIVIDE: printf("BINARY_FLOOR_DIVIDE\n"); break;
- case MP_BINARY_OP_TRUE_DIVIDE: printf("BINARY_TRUE_DIVIDE\n"); break;
- case MP_BINARY_OP_MODULO: printf("BINARY_MODULO\n"); break;
- case MP_BINARY_OP_POWER: printf("BINARY_POWER\n"); break;
- case MP_BINARY_OP_INPLACE_OR: printf("INPLACE_OR\n"); break;
- case MP_BINARY_OP_INPLACE_XOR: printf("INPLACE_XOR\n"); break;
- case MP_BINARY_OP_INPLACE_AND: printf("INPLACE_AND\n"); break;
- case MP_BINARY_OP_INPLACE_LSHIFT: printf("INPLACE_LSHIFT\n"); break;
- case MP_BINARY_OP_INPLACE_RSHIFT: printf("INPLACE_RSHIFT\n"); break;
- case MP_BINARY_OP_INPLACE_ADD: printf("INPLACE_ADD\n"); break;
- case MP_BINARY_OP_INPLACE_SUBTRACT: printf("INPLACE_SUBTRACT\n"); break;
- case MP_BINARY_OP_INPLACE_MULTIPLY: printf("INPLACE_MULTIPLY\n"); break;
- case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: printf("INPLACE_FLOOR_DIVIDE\n"); break;
- case MP_BINARY_OP_INPLACE_TRUE_DIVIDE: printf("INPLACE_TRUE_DIVIDE\n"); break;
- case MP_BINARY_OP_INPLACE_MODULO: printf("INPLACE_MODULO\n"); break;
- case MP_BINARY_OP_INPLACE_POWER: printf("INPLACE_POWER\n"); break;
- case MP_BINARY_OP_LESS: printf("COMPARE_OP <\n"); break;
- case MP_BINARY_OP_MORE: printf("COMPARE_OP >\n"); break;
- case MP_BINARY_OP_EQUAL: printf("COMPARE_OP ==\n"); break;
- case MP_BINARY_OP_LESS_EQUAL: printf("COMPARE_OP <=\n"); break;
- case MP_BINARY_OP_MORE_EQUAL: printf("COMPARE_OP >=\n"); break;
- case MP_BINARY_OP_NOT_EQUAL: printf("COMPARE_OP !=\n"); break;
- case MP_BINARY_OP_IN: printf("COMPARE_OP in\n"); break;
- case MP_BINARY_OP_IS: printf("COMPARE_OP is\n"); break;
- case MP_BINARY_OP_EXCEPTION_MATCH: printf("COMPARE_OP exception match\n"); break;
- case MP_BINARY_OP_NOT_IN: printf("COMPARE_OP not in\n"); break;
- case MP_BINARY_OP_IS_NOT: printf("COMPARE_OP is not\n"); break;
- default: assert(0);
- }
- }
-}
-
-STATIC void emit_cpy_build_tuple(emit_t *emit, mp_uint_t n_args) {
- emit_pre(emit, 1 - n_args, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("BUILD_TUPLE " UINT_FMT "\n", n_args);
- }
-}
-
-STATIC void emit_cpy_build_list(emit_t *emit, mp_uint_t n_args) {
- emit_pre(emit, 1 - n_args, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("BUILD_LIST " UINT_FMT "\n", n_args);
- }
-}
-
-STATIC void emit_cpy_list_append(emit_t *emit, mp_uint_t list_index) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LIST_APPEND " UINT_FMT "\n", list_index);
- }
-}
-
-STATIC void emit_cpy_build_map(emit_t *emit, mp_uint_t n_args) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("BUILD_MAP " UINT_FMT "\n", n_args);
- }
-}
-
-STATIC void emit_cpy_store_map(emit_t *emit) {
- emit_pre(emit, -2, 1);
- if (emit->pass == MP_PASS_EMIT) {
- printf("STORE_MAP\n");
- }
-}
-
-STATIC void emit_cpy_map_add(emit_t *emit, mp_uint_t map_index) {
- emit_pre(emit, -2, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("MAP_ADD " UINT_FMT "\n", map_index);
- }
-}
-
-STATIC void emit_cpy_build_set(emit_t *emit, mp_uint_t n_args) {
- emit_pre(emit, 1 - n_args, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("BUILD_SET " UINT_FMT "\n", n_args);
- }
-}
-
-STATIC void emit_cpy_set_add(emit_t *emit, mp_uint_t set_index) {
- emit_pre(emit, -1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("SET_ADD " UINT_FMT "\n", set_index);
- }
-}
-
-STATIC void emit_cpy_build_slice(emit_t *emit, mp_uint_t n_args) {
- emit_pre(emit, 1 - n_args, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("BUILD_SLICE " UINT_FMT "\n", n_args);
- }
-}
-
-STATIC void emit_cpy_unpack_sequence(emit_t *emit, mp_uint_t n_args) {
- emit_pre(emit, -1 + n_args, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("UNPACK_SEQUENCE " UINT_FMT "\n", n_args);
- }
-}
-
-STATIC void emit_cpy_unpack_ex(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right) {
- emit_pre(emit, -1 + n_left + n_right + 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("UNPACK_EX " UINT_FMT "\n", n_left | (n_right << 8));
- }
-}
-
-STATIC void emit_cpy_call_function(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) {
- mp_int_t s = 0;
- if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) {
- s += 1;
- }
- if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) {
- s += 1;
- }
- emit_pre(emit, -(mp_int_t)n_positional - 2 * (mp_int_t)n_keyword - s, 3);
- if (emit->pass == MP_PASS_EMIT) {
- if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) {
- if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) {
- printf("CALL_FUNCTION_VAR_KW");
- } else {
- printf("CALL_FUNCTION_VAR");
- }
- } else {
- if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) {
- printf("CALL_FUNCTION_KW");
- } else {
- printf("CALL_FUNCTION");
- }
- }
- printf(" " UINT_FMT ", " UINT_FMT "\n", n_positional, n_keyword);
- }
-}
-
-STATIC void emit_cpy_call_method(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) {
- emit_cpy_call_function(emit, n_positional, n_keyword, star_flags);
-}
-
-STATIC void emit_cpy_return_value(emit_t *emit) {
- emit_pre(emit, -1, 1);
- emit->last_emit_was_return_value = true;
- if (emit->pass == MP_PASS_EMIT) {
- printf("RETURN_VALUE\n");
- }
-}
-
-STATIC void emit_cpy_raise_varargs(emit_t *emit, mp_uint_t n_args) {
- emit_pre(emit, -n_args, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("RAISE_VARARGS " UINT_FMT "\n", n_args);
- }
-}
-
-STATIC void load_cpy_const_code_and_name(emit_t *emit, qstr qst) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CONST code %s\n", qstr_str(qst));
- }
- // load qualified name
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CONST '");
- // code just to work out the qualname (or whatever it is)
- {
- int depth = 0;
- for (scope_t *s = emit->scope; s->parent != NULL; s = s->parent) {
- depth += 1;
- }
- for (int wanted_depth = depth; wanted_depth >= 0; wanted_depth--) {
- scope_t *s = emit->scope;
- for (int i = 0; i < wanted_depth; i++) {
- s = s->parent;
- }
- if (s->kind == SCOPE_FUNCTION) {
- printf("%s.<locals>.", qstr_str(s->simple_name));
- } else if (s->kind == SCOPE_CLASS) {
- printf("%s.", qstr_str(s->simple_name));
- }
- }
- }
- printf("%s'\n", qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_make_function(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) {
- load_cpy_const_code_and_name(emit, scope->simple_name);
- emit_pre(emit, -1 - n_pos_defaults - 2 * n_kw_defaults, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("MAKE_FUNCTION " UINT_FMT "\n", (n_kw_defaults << 8) | n_pos_defaults);
- }
-}
-
-STATIC void emit_cpy_make_closure(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) {
- emit_cpy_build_tuple(emit, n_closed_over);
- load_cpy_const_code_and_name(emit, scope->simple_name);
- emit_pre(emit, -2 - n_pos_defaults - 2 * n_kw_defaults, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("MAKE_CLOSURE " UINT_FMT "\n", (n_kw_defaults << 8) | n_pos_defaults);
- }
-}
-
-STATIC void emit_cpy_yield_value(emit_t *emit) {
- emit_pre(emit, 0, 1);
- emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
- if (emit->pass == MP_PASS_EMIT) {
- printf("YIELD_VALUE\n");
- }
-}
-
-STATIC void emit_cpy_yield_from(emit_t *emit) {
- emit_pre(emit, -1, 1);
- emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
- if (emit->pass == MP_PASS_EMIT) {
- printf("YIELD_FROM\n");
- }
-}
-
-STATIC void emit_cpy_start_except_handler(emit_t *emit) {
- emit_cpy_adjust_stack_size(emit, 3); // stack adjust for the 3 exception items
-}
-
-STATIC void emit_cpy_end_except_handler(emit_t *emit) {
- emit_cpy_adjust_stack_size(emit, -2); // stack adjust
-}
-
-STATIC void emit_cpy_load_const_verbatim_strn(emit_t *emit, const char *str, mp_uint_t len) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CONST %.*s\n", (int)len, str);
- }
-}
-
-STATIC void emit_cpy_load_closure(emit_t *emit, qstr qst, mp_uint_t local_num) {
- emit_pre(emit, 1, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("LOAD_CLOSURE " UINT_FMT " %s\n", local_num, qstr_str(qst));
- }
-}
-
-STATIC void emit_cpy_setup_loop(emit_t *emit, mp_uint_t label) {
- emit_pre(emit, 0, 3);
- if (emit->pass == MP_PASS_EMIT) {
- printf("SETUP_LOOP " UINT_FMT "\n", emit->label_offsets[label]);
- }
-}
-
-const emit_method_table_t emit_cpython_method_table = {
- emit_cpy_set_native_type,
- emit_cpy_start_pass,
- emit_cpy_end_pass,
- emit_cpy_last_emit_was_return_value,
- emit_cpy_adjust_stack_size,
- emit_cpy_set_source_line,
-
- {
- emit_cpy_load_fast,
- emit_cpy_load_deref,
- emit_cpy_load_name,
- emit_cpy_load_global,
- },
- {
- emit_cpy_store_fast,
- emit_cpy_store_deref,
- emit_cpy_store_name,
- emit_cpy_store_global,
- },
- {
- emit_cpy_delete_fast,
- emit_cpy_delete_deref,
- emit_cpy_delete_name,
- emit_cpy_delete_global,
- },
-
- emit_cpy_label_assign,
- emit_cpy_import_name,
- emit_cpy_import_from,
- emit_cpy_import_star,
- emit_cpy_load_const_tok,
- emit_cpy_load_const_small_int,
- emit_cpy_load_const_str,
- emit_cpy_load_const_obj,
- emit_cpy_load_null,
- emit_cpy_load_attr,
- emit_cpy_load_method,
- emit_cpy_load_build_class,
- emit_cpy_load_subscr,
- emit_cpy_store_attr,
- emit_cpy_store_subscr,
- emit_cpy_delete_attr,
- emit_cpy_delete_subscr,
- emit_cpy_dup_top,
- emit_cpy_dup_top_two,
- emit_cpy_pop_top,
- emit_cpy_rot_two,
- emit_cpy_rot_three,
- emit_cpy_jump,
- emit_cpy_pop_jump_if,
- emit_cpy_jump_if_or_pop,
- emit_cpy_break_loop,
- emit_cpy_continue_loop,
- emit_cpy_setup_with,
- emit_cpy_with_cleanup,
- emit_cpy_setup_except,
- emit_cpy_setup_finally,
- emit_cpy_end_finally,
- emit_cpy_get_iter,
- emit_cpy_for_iter,
- emit_cpy_for_iter_end,
- emit_cpy_pop_block,
- emit_cpy_pop_except,
- emit_cpy_unary_op,
- emit_cpy_binary_op,
- emit_cpy_build_tuple,
- emit_cpy_build_list,
- emit_cpy_list_append,
- emit_cpy_build_map,
- emit_cpy_store_map,
- emit_cpy_map_add,
- emit_cpy_build_set,
- emit_cpy_set_add,
- emit_cpy_build_slice,
- emit_cpy_unpack_sequence,
- emit_cpy_unpack_ex,
- emit_cpy_make_function,
- emit_cpy_make_closure,
- emit_cpy_call_function,
- emit_cpy_call_method,
- emit_cpy_return_value,
- emit_cpy_raise_varargs,
- emit_cpy_yield_value,
- emit_cpy_yield_from,
-
- emit_cpy_start_except_handler,
- emit_cpy_end_except_handler,
-
- // emitcpy specific functions
- emit_cpy_load_const_verbatim_strn,
- emit_cpy_load_closure,
- emit_cpy_setup_loop,
-};
-
-#endif // MICROPY_EMIT_CPYTHON
diff --git a/py/mkrules.mk b/py/mkrules.mk
index a994016148..fe70a0ee37 100644
--- a/py/mkrules.mk
+++ b/py/mkrules.mk
@@ -75,7 +75,7 @@ $(HEADER_BUILD):
$(MKDIR) -p $@
ifneq ($(PROG),)
-# Build a standalone executable (unix and unix-cpy do this)
+# Build a standalone executable (unix does this)
all: $(PROG)
diff --git a/py/mpconfig.h b/py/mpconfig.h
index 35a14ba88e..bfa7a1f68d 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -173,12 +173,6 @@
/*****************************************************************************/
/* Micro Python emitters */
-// Whether to emit CPython byte codes (for debugging/testing)
-// Enabling this overrides all other emitters
-#ifndef MICROPY_EMIT_CPYTHON
-#define MICROPY_EMIT_CPYTHON (0)
-#endif
-
// Whether to emit x64 native code
#ifndef MICROPY_EMIT_X64
#define MICROPY_EMIT_X64 (0)
diff --git a/py/parse.c b/py/parse.c
index b20fdaacd2..cd3acb2593 100644
--- a/py/parse.c
+++ b/py/parse.c
@@ -548,7 +548,7 @@ mp_parse_node_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) {
}
}
-#if !MICROPY_EMIT_CPYTHON && !MICROPY_ENABLE_DOC_STRING
+ #if !MICROPY_ENABLE_DOC_STRING
// this code discards lonely statements, such as doc strings
if (input_kind != MP_PARSE_SINGLE_INPUT && rule->rule_id == RULE_expr_stmt && peek_result(&parser, 0) == MP_PARSE_NODE_NULL) {
mp_parse_node_t p = peek_result(&parser, 1);
@@ -559,7 +559,7 @@ mp_parse_node_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) {
break;
}
}
-#endif
+ #endif
// always emit these rules, even if they have only 1 argument
if (rule->rule_id == RULE_expr_stmt || rule->rule_id == RULE_yield_stmt) {
diff --git a/py/py.mk b/py/py.mk
index 84f3295e14..5ba0f55085 100644
--- a/py/py.mk
+++ b/py/py.mk
@@ -32,7 +32,6 @@ PY_O_BASENAME = \
scope.o \
compile.o \
emitcommon.o \
- emitcpy.o \
emitbc.o \
asmx64.o \
emitnx64.o \
diff --git a/py/scope.c b/py/scope.c
index 4739ac3236..f9b1fb122b 100644
--- a/py/scope.c
+++ b/py/scope.c
@@ -149,59 +149,3 @@ void scope_close_over_in_parents(scope_t *scope, qstr qst) {
}
assert(0); // we should have found the variable in one of the parents
}
-
-#if MICROPY_EMIT_CPYTHON
-#include <stdio.h>
-
-void scope_print_info(scope_t *s) {
- if (s->kind == SCOPE_MODULE) {
- printf("code <module>\n");
- } else if (s->kind == SCOPE_LAMBDA) {
- printf("code <lambda>\n");
- } else if (s->kind == SCOPE_LIST_COMP) {
- printf("code <listcomp>\n");
- } else if (s->kind == SCOPE_DICT_COMP) {
- printf("code <dictcomp>\n");
- } else if (s->kind == SCOPE_SET_COMP) {
- printf("code <setcomp>\n");
- } else if (s->kind == SCOPE_GEN_EXPR) {
- printf("code <genexpr>\n");
- } else {
- printf("code %s\n", qstr_str(s->simple_name));
- }
- /*
- printf("var global:");
- for (int i = 0; i < s->id_info_len; i++) {
- if (s->id_info[i].kind == ID_INFO_KIND_GLOBAL_EXPLICIT) {
- printf(" %s", qstr_str(s->id_info[i].qst));
- }
- }
- printf("\n");
- printf("var name:");
- for (int i = 0; i < s->id_info_len; i++) {
- if (s->id_info[i].kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
- printf(" %s", qstr_str(s->id_info[i].qst));
- }
- }
- printf("\n");
- printf("var local:");
- for (int i = 0; i < s->id_info_len; i++) {
- if (s->id_info[i].kind == ID_INFO_KIND_LOCAL) {
- printf(" %s", qstr_str(s->id_info[i].qst));
- }
- }
- printf("\n");
- printf("var free:");
- for (int i = 0; i < s->id_info_len; i++) {
- if (s->id_info[i].kind == ID_INFO_KIND_FREE) {
- printf(" %s", qstr_str(s->id_info[i].qst));
- }
- }
- printf("\n");
- */
- printf(" flags %04x\n", s->scope_flags);
- printf(" argcount %d\n", s->num_pos_args);
- printf(" nlocals %d\n", s->num_locals);
- printf(" stacksize %d\n", s->stack_size);
-}
-#endif
diff --git a/py/scope.h b/py/scope.h
index 6d74b17d28..0ea003516a 100644
--- a/py/scope.h
+++ b/py/scope.h
@@ -81,6 +81,5 @@ id_info_t *scope_find(scope_t *scope, qstr qstr);
id_info_t *scope_find_global(scope_t *scope, qstr qstr);
id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qstr);
void scope_close_over_in_parents(scope_t *scope, qstr qstr);
-void scope_print_info(scope_t *s);
#endif // __MICROPY_INCLUDED_PY_SCOPE_H__
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-18 06:12:51 +0000