Change object representation from 1 big union to individual structs.
A big change. Micro Python objects are allocated as individual structs
with the first element being a pointer to the type information (which
is itself an object). This scheme follows CPython. Much more flexible,
not necessarily slower, uses same heap memory, and can allocate objects
statically.
Also change name prefix, from py_ to mp_ (mp for Micro Python).
diff --git a/py/compile.c b/py/compile.c
index 42bac7d..38f1415 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -6,12 +6,12 @@
#include <assert.h>
#include "misc.h"
-#include "mpyconfig.h"
+#include "mpconfig.h"
#include "lexer.h"
#include "parse.h"
#include "scope.h"
#include "compile.h"
-#include "runtime.h"
+#include "runtime0.h"
#include "emit.h"
// TODO need to mangle __attr names
@@ -78,28 +78,28 @@
const emit_inline_asm_method_table_t *emit_inline_asm_method_table; // current emit method table for inline asm
} compiler_t;
-py_parse_node_t fold_constants(py_parse_node_t pn) {
- if (PY_PARSE_NODE_IS_STRUCT(pn)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+mp_parse_node_t fold_constants(mp_parse_node_t pn) {
+ 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);
// fold arguments first
for (int i = 0; i < n; i++) {
pns->nodes[i] = fold_constants(pns->nodes[i]);
}
- switch (PY_PARSE_NODE_STRUCT_KIND(pns)) {
+ switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
case PN_shift_expr:
- if (n == 3 && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
- int arg0 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
- int arg1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_DBL_LESS)) {
+ if (n == 3 && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
+ int arg0 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ int arg1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_DBL_LESS)) {
#if MICROPY_EMIT_CPYTHON
// can overflow; enabled only to compare with CPython
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 << arg1);
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 << arg1);
#endif
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_DBL_MORE)) {
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 >> arg1);
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_DBL_MORE)) {
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 >> arg1);
} else {
// shouldn't happen
assert(0);
@@ -109,42 +109,42 @@
case PN_arith_expr:
// overflow checking here relies on SMALL_INT being strictly smaller than machine_int_t
- if (n == 3 && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
- machine_int_t arg0 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
- machine_int_t arg1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
+ if (n == 3 && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
+ machine_int_t arg0 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ machine_int_t arg1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
machine_int_t res;
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_PLUS)) {
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_PLUS)) {
res = arg0 + arg1;
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_MINUS)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_MINUS)) {
res = arg0 - arg1;
} else {
// shouldn't happen
assert(0);
res = 0;
}
- if (PY_FIT_SMALL_INT(res)) {
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, res);
+ if (MP_FIT_SMALL_INT(res)) {
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, res);
}
}
break;
case PN_term:
- if (n == 3 && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
- int arg0 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
- int arg1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_STAR)) {
+ if (n == 3 && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[2])) {
+ int arg0 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ int arg1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[2]);
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
#if MICROPY_EMIT_CPYTHON
// can overflow; enabled only to compare with CPython
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 * arg1);
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 * arg1);
#endif
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_SLASH)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_SLASH)) {
; // pass
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_PERCENT)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_PERCENT)) {
// XXX implement this properly as Python's % operator acts differently to C's
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 % arg1);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_DBL_SLASH)) {
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 % arg1);
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_DBL_SLASH)) {
// XXX implement this properly as Python's // operator acts differently to C's
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg0 / arg1);
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0 / arg1);
} else {
// shouldn't happen
assert(0);
@@ -153,14 +153,14 @@
break;
case PN_factor_2:
- if (PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[1])) {
- machine_int_t arg = PY_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_PLUS)) {
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, arg);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_MINUS)) {
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, -arg);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_TILDE)) {
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, ~arg);
+ if (MP_PARSE_NODE_IS_SMALL_INT(pns->nodes[1])) {
+ machine_int_t arg = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_PLUS)) {
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg);
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_MINUS)) {
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, -arg);
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_TILDE)) {
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, ~arg);
} else {
// shouldn't happen
assert(0);
@@ -171,17 +171,17 @@
#if MICROPY_EMIT_CPYTHON
case PN_power:
// can overflow; enabled only to compare with CPython
- if (PY_PARSE_NODE_IS_SMALL_INT(pns->nodes[0]) && PY_PARSE_NODE_IS_NULL(pns->nodes[1]) && !PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
- py_parse_node_struct_t* pns2 = (py_parse_node_struct_t*)pns->nodes[2];
- if (PY_PARSE_NODE_IS_SMALL_INT(pns2->nodes[0])) {
- int power = PY_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
+ 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])) {
+ 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_ARG(pns2->nodes[0]);
if (power >= 0) {
int ans = 1;
- int base = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ int base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
for (; power > 0; power--) {
ans *= base;
}
- pn = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, ans);
+ pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, ans);
}
}
}
@@ -193,13 +193,13 @@
return pn;
}
-void compile_node(compiler_t *comp, py_parse_node_t pn);
+void compile_node(compiler_t *comp, mp_parse_node_t pn);
static int comp_next_label(compiler_t *comp) {
return comp->next_label++;
}
-static scope_t *scope_new_and_link(compiler_t *comp, scope_kind_t kind, py_parse_node_t pn, uint emit_options) {
+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, rt_get_unique_code_id(kind == SCOPE_MODULE), emit_options);
scope->parent = comp->scope_cur;
scope->next = NULL;
@@ -215,68 +215,68 @@
return scope;
}
-static int list_len(py_parse_node_t pn, int pn_kind) {
- if (PY_PARSE_NODE_IS_NULL(pn)) {
+static int list_len(mp_parse_node_t pn, int pn_kind) {
+ if (MP_PARSE_NODE_IS_NULL(pn)) {
return 0;
- } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
+ } else if (MP_PARSE_NODE_IS_LEAF(pn)) {
return 1;
} else {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- if (PY_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
return 1;
} else {
- return PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ return MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
}
}
}
-static void apply_to_single_or_list(compiler_t *comp, py_parse_node_t pn, int pn_list_kind, void (*f)(compiler_t*, py_parse_node_t)) {
- if (PY_PARSE_NODE_IS_STRUCT(pn) && PY_PARSE_NODE_STRUCT_KIND((py_parse_node_struct_t*)pn) == pn_list_kind) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+static void apply_to_single_or_list(compiler_t *comp, mp_parse_node_t pn, int pn_list_kind, void (*f)(compiler_t*, mp_parse_node_t)) {
+ if (MP_PARSE_NODE_IS_STRUCT(pn) && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)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 (!PY_PARSE_NODE_IS_NULL(pn)) {
+ } else if (!MP_PARSE_NODE_IS_NULL(pn)) {
f(comp, pn);
}
}
-static int list_get(py_parse_node_t *pn, int pn_kind, py_parse_node_t **nodes) {
- if (PY_PARSE_NODE_IS_NULL(*pn)) {
+static int list_get(mp_parse_node_t *pn, int pn_kind, mp_parse_node_t **nodes) {
+ if (MP_PARSE_NODE_IS_NULL(*pn)) {
*nodes = NULL;
return 0;
- } else if (PY_PARSE_NODE_IS_LEAF(*pn)) {
+ } else if (MP_PARSE_NODE_IS_LEAF(*pn)) {
*nodes = pn;
return 1;
} else {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)(*pn);
- if (PY_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)(*pn);
+ if (MP_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
*nodes = pn;
return 1;
} else {
*nodes = pns->nodes;
- return PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ return MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
}
}
}
-void compile_do_nothing(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_do_nothing(compiler_t *comp, mp_parse_node_struct_t *pns) {
}
-void compile_generic_all_nodes(compiler_t *comp, py_parse_node_struct_t *pns) {
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+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 MICROPY_EMIT_CPYTHON
-static bool cpython_c_tuple_is_const(py_parse_node_t pn) {
- if (!PY_PARSE_NODE_IS_LEAF(pn)) {
+static bool cpython_c_tuple_is_const(mp_parse_node_t pn) {
+ if (!MP_PARSE_NODE_IS_LEAF(pn)) {
return false;
}
- if (PY_PARSE_NODE_IS_ID(pn)) {
+ if (MP_PARSE_NODE_IS_ID(pn)) {
return false;
}
return true;
@@ -322,21 +322,21 @@
}
}
-static void cpython_c_tuple_emit_const(compiler_t *comp, py_parse_node_t pn, vstr_t *vstr) {
- assert(PY_PARSE_NODE_IS_LEAF(pn));
- int arg = PY_PARSE_NODE_LEAF_ARG(pn);
- switch (PY_PARSE_NODE_LEAF_KIND(pn)) {
- case PY_PARSE_NODE_ID: assert(0);
- case PY_PARSE_NODE_SMALL_INT: vstr_printf(vstr, "%d", arg); break;
- case PY_PARSE_NODE_INTEGER: vstr_printf(vstr, "%s", qstr_str(arg)); break;
- case PY_PARSE_NODE_DECIMAL: vstr_printf(vstr, "%s", qstr_str(arg)); break;
- case PY_PARSE_NODE_STRING: cpython_c_print_quoted_str(vstr, arg, false); break;
- case PY_PARSE_NODE_BYTES: cpython_c_print_quoted_str(vstr, arg, true); break;
- case PY_PARSE_NODE_TOKEN:
+static void cpython_c_tuple_emit_const(compiler_t *comp, mp_parse_node_t pn, vstr_t *vstr) {
+ assert(MP_PARSE_NODE_IS_LEAF(pn));
+ int 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_SMALL_INT: vstr_printf(vstr, "%d", arg); break;
+ case MP_PARSE_NODE_INTEGER: vstr_printf(vstr, "%s", qstr_str(arg)); break;
+ case MP_PARSE_NODE_DECIMAL: vstr_printf(vstr, "%s", qstr_str(arg)); break;
+ case MP_PARSE_NODE_STRING: cpython_c_print_quoted_str(vstr, arg, false); break;
+ case MP_PARSE_NODE_BYTES: cpython_c_print_quoted_str(vstr, arg, true); break;
+ case MP_PARSE_NODE_TOKEN:
switch (arg) {
- case PY_TOKEN_KW_FALSE: vstr_printf(vstr, "False"); break;
- case PY_TOKEN_KW_NONE: vstr_printf(vstr, "None"); break;
- case PY_TOKEN_KW_TRUE: vstr_printf(vstr, "True"); break;
+ 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);
}
break;
@@ -344,14 +344,14 @@
}
}
-static void cpython_c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_list) {
+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 = PY_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
+ n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
}
int total = n;
bool is_const = true;
- if (!PY_PARSE_NODE_IS_NULL(pn)) {
+ if (!MP_PARSE_NODE_IS_NULL(pn)) {
total += 1;
if (!cpython_c_tuple_is_const(pn)) {
is_const = false;
@@ -367,7 +367,7 @@
bool need_comma = false;
vstr_t *vstr = vstr_new();
vstr_printf(vstr, "(");
- if (!PY_PARSE_NODE_IS_NULL(pn)) {
+ if (!MP_PARSE_NODE_IS_NULL(pn)) {
cpython_c_tuple_emit_const(comp, pn, vstr);
need_comma = true;
}
@@ -386,7 +386,7 @@
EMIT(load_const_verbatim_str, vstr_str(vstr));
vstr_free(vstr);
} else {
- if (!PY_PARSE_NODE_IS_NULL(pn)) {
+ if (!MP_PARSE_NODE_IS_NULL(pn)) {
compile_node(comp, pn);
}
for (int i = 0; i < n; i++) {
@@ -398,17 +398,17 @@
#endif
// funnelling all tuple creations through this function is purely so we can optionally agree with CPython
-void c_tuple(compiler_t *comp, py_parse_node_t pn, py_parse_node_struct_t *pns_list) {
+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 (!PY_PARSE_NODE_IS_NULL(pn)) {
+ if (!MP_PARSE_NODE_IS_NULL(pn)) {
compile_node(comp, pn);
total += 1;
}
if (pns_list != NULL) {
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_list);
for (int i = 0; i < n; i++) {
compile_node(comp, pns_list->nodes[i]);
}
@@ -418,23 +418,23 @@
#endif
}
-void compile_generic_tuple(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_generic_tuple(compiler_t *comp, mp_parse_node_struct_t *pns) {
// a simple tuple expression
- c_tuple(comp, PY_PARSE_NODE_NULL, pns);
+ c_tuple(comp, MP_PARSE_NODE_NULL, pns);
}
-static bool node_is_const_false(py_parse_node_t pn) {
- return PY_PARSE_NODE_IS_TOKEN_KIND(pn, PY_TOKEN_KW_FALSE);
- // untested: || (PY_PARSE_NODE_IS_SMALL_INT(pn) && PY_PARSE_NODE_LEAF_ARG(pn) == 1);
+static bool node_is_const_false(mp_parse_node_t pn) {
+ return MP_PARSE_NODE_IS_TOKEN_KIND(pn, MP_TOKEN_KW_FALSE);
+ // untested: || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_ARG(pn) == 1);
}
-static bool node_is_const_true(py_parse_node_t pn) {
- return PY_PARSE_NODE_IS_TOKEN_KIND(pn, PY_TOKEN_KW_TRUE) || (PY_PARSE_NODE_IS_SMALL_INT(pn) && PY_PARSE_NODE_LEAF_ARG(pn) == 1);
+static bool node_is_const_true(mp_parse_node_t pn) {
+ return MP_PARSE_NODE_IS_TOKEN_KIND(pn, MP_TOKEN_KW_TRUE) || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_ARG(pn) == 1);
}
#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, py_parse_node_t pn, bool jump_if, int label, bool is_nested) {
+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(jump, label);
@@ -445,10 +445,10 @@
EMIT(jump, label);
}
return;
- } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
- if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
+ } 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) {
int label2 = comp_next_label(comp);
for (int i = 0; i < n - 1; i++) {
@@ -462,7 +462,7 @@
}
}
return;
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
+ } 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);
@@ -476,7 +476,7 @@
EMIT(label_assign, label2);
}
return;
- } else if (!is_nested && PY_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
+ } 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;
}
@@ -492,7 +492,7 @@
}
#endif
-static void c_if_cond(compiler_t *comp, py_parse_node_t pn, bool jump_if, int label) {
+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
@@ -506,10 +506,10 @@
EMIT(jump, label);
}
return;
- } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
- if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
+ } 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) {
int label2 = comp_next_label(comp);
for (int i = 0; i < n - 1; i++) {
@@ -523,7 +523,7 @@
}
}
return;
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_and_test) {
if (jump_if == false) {
for (int i = 0; i < n; i++) {
c_if_cond(comp, pns->nodes[i], false, label);
@@ -537,7 +537,7 @@
EMIT(label_assign, label2);
}
return;
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_not_test_2) {
c_if_cond(comp, pns->nodes[0], !jump_if, label);
return;
}
@@ -554,29 +554,29 @@
}
typedef enum { ASSIGN_STORE, ASSIGN_AUG_LOAD, ASSIGN_AUG_STORE } assign_kind_t;
-void c_assign(compiler_t *comp, py_parse_node_t pn, assign_kind_t kind);
+void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t kind);
-void c_assign_power(compiler_t *comp, py_parse_node_struct_t *pns, assign_kind_t assign_kind) {
+void c_assign_power(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 (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
- py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_power_trailers) {
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1);
+ 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_power_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(PY_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
- pns1 = (py_parse_node_struct_t*)pns1->nodes[n - 1];
+ assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
+ pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
}
- if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
+ if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
printf("SyntaxError: can't assign to function call\n");
return;
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
if (assign_kind == ASSIGN_AUG_STORE) {
EMIT(rot_three);
EMIT(store_subscr);
@@ -589,16 +589,16 @@
EMIT(store_subscr);
}
}
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
- assert(PY_PARSE_NODE_IS_ID(pns1->nodes[0]));
+ } 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(load_attr, PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
+ EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
} else {
if (assign_kind == ASSIGN_AUG_STORE) {
EMIT(rot_two);
}
- EMIT(store_attr, PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
+ EMIT(store_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
}
} else {
// shouldn't happen
@@ -609,17 +609,17 @@
assert(0);
}
- if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+ if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
// SyntaxError, cannot assign
assert(0);
}
}
-void c_assign_tuple(compiler_t *comp, int n, py_parse_node_t *nodes) {
+void c_assign_tuple(compiler_t *comp, int n, mp_parse_node_t *nodes) {
assert(n >= 0);
int have_star_index = -1;
for (int i = 0; i < n; i++) {
- if (PY_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_star_expr)) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_star_expr)) {
if (have_star_index < 0) {
EMIT(unpack_ex, i, n - i - 1);
have_star_index = i;
@@ -634,7 +634,7 @@
}
for (int i = 0; i < n; i++) {
if (i == have_star_index) {
- c_assign(comp, ((py_parse_node_struct_t*)nodes[i])->nodes[0], ASSIGN_STORE);
+ c_assign(comp, ((mp_parse_node_struct_t*)nodes[i])->nodes[0], ASSIGN_STORE);
} else {
c_assign(comp, nodes[i], ASSIGN_STORE);
}
@@ -642,13 +642,13 @@
}
// assigns top of stack to pn
-void c_assign(compiler_t *comp, py_parse_node_t pn, assign_kind_t assign_kind) {
+void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_kind) {
tail_recursion:
- if (PY_PARSE_NODE_IS_NULL(pn)) {
+ if (MP_PARSE_NODE_IS_NULL(pn)) {
assert(0);
- } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
- if (PY_PARSE_NODE_IS_ID(pn)) {
- int arg = PY_PARSE_NODE_LEAF_ARG(pn);
+ } else if (MP_PARSE_NODE_IS_LEAF(pn)) {
+ if (MP_PARSE_NODE_IS_ID(pn)) {
+ int arg = MP_PARSE_NODE_LEAF_ARG(pn);
switch (assign_kind) {
case ASSIGN_STORE:
case ASSIGN_AUG_STORE:
@@ -663,8 +663,8 @@
return;
}
} else {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- switch (PY_PARSE_NODE_STRUCT_KIND(pns)) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+ switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
case PN_power:
// lhs is an index or attribute
c_assign_power(comp, pns, assign_kind);
@@ -676,17 +676,17 @@
if (assign_kind != ASSIGN_STORE) {
goto bad_aug;
}
- c_assign_tuple(comp, PY_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
+ c_assign_tuple(comp, MP_PARSE_NODE_STRUCT_NUM_NODES(pns), pns->nodes);
break;
case PN_atom_paren:
// lhs is something in parenthesis
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// empty tuple
printf("SyntaxError: can't assign to ()\n");
return;
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
- pns = (py_parse_node_struct_t*)pns->nodes[0];
+ } 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 {
// parenthesis around 1 item, is just that item
@@ -700,11 +700,11 @@
if (assign_kind != ASSIGN_STORE) {
goto bad_aug;
}
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// empty list, assignment allowed
c_assign_tuple(comp, 0, NULL);
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
- pns = (py_parse_node_struct_t*)pns->nodes[0];
+ } 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
@@ -713,29 +713,29 @@
break;
default:
- printf("unknown assign, %u\n", (uint)PY_PARSE_NODE_STRUCT_KIND(pns));
+ printf("unknown assign, %u\n", (uint)MP_PARSE_NODE_STRUCT_KIND(pns));
assert(0);
}
return;
testlist_comp:
// lhs is a sequence
- if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
- py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
+ if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+ mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
+ if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
// sequence of one item, with trailing comma
- assert(PY_PARSE_NODE_IS_NULL(pns2->nodes[0]));
+ assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
c_assign_tuple(comp, 1, &pns->nodes[0]);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
// sequence of many items
// TODO call c_assign_tuple instead
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns2);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns2);
EMIT(unpack_sequence, 1 + n);
c_assign(comp, pns->nodes[0], ASSIGN_STORE);
for (int i = 0; i < n; i++) {
c_assign(comp, pns2->nodes[i], ASSIGN_STORE);
}
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
// TODO not implemented
assert(0);
} else {
@@ -786,16 +786,16 @@
}
}
-void compile_funcdef_param(compiler_t *comp, py_parse_node_t pn) {
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_typedargslist_name)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+void compile_funcdef_param(compiler_t *comp, mp_parse_node_t pn) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_typedargslist_name)) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+ if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
// 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_bare_star) {
comp->param_pass_num_dict_params += 1;
if (comp->param_pass == 1) {
- EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+ EMIT(load_const_id, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
compile_node(comp, pns->nodes[2]);
}
} else {
@@ -805,9 +805,9 @@
}
}
}
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_typedargslist_star)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_typedargslist_star)) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// bare star
comp->have_bare_star = true;
}
@@ -816,12 +816,12 @@
// leaves function object on stack
// returns function name
-qstr compile_funcdef_helper(compiler_t *comp, py_parse_node_struct_t *pns, uint emit_options) {
+qstr compile_funcdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
if (comp->pass == PASS_1) {
// create a new scope for this function
- scope_t *s = scope_new_and_link(comp, SCOPE_FUNCTION, (py_parse_node_t)pns, emit_options);
+ 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] = (py_parse_node_t)s;
+ pns->nodes[4] = (mp_parse_node_t)s;
}
// save variables (probably don't need to do this, since we can't have nested definitions..?)
@@ -860,12 +860,12 @@
// leaves class object on stack
// returns class name
-qstr compile_classdef_helper(compiler_t *comp, py_parse_node_struct_t *pns, uint emit_options) {
+qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns, uint emit_options) {
if (comp->pass == PASS_1) {
// create a new scope for this class
- scope_t *s = scope_new_and_link(comp, SCOPE_CLASS, (py_parse_node_t)pns, emit_options);
+ 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] = (py_parse_node_t)s;
+ pns->nodes[3] = (mp_parse_node_t)s;
}
EMIT(load_build_class);
@@ -880,7 +880,7 @@
EMIT(load_const_id, cscope->simple_name);
// nodes[1] has parent classes, if any
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
// no parent classes
EMIT(call_function, 2, 0, false, false);
} else {
@@ -895,8 +895,8 @@
}
// 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, int name_len, py_parse_node_t *name_nodes, uint *emit_options) {
- if (PY_PARSE_NODE_LEAF_ARG(name_nodes[0]) != comp->qstr_micropython) {
+static bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_node_t *name_nodes, uint *emit_options) {
+ if (MP_PARSE_NODE_LEAF_ARG(name_nodes[0]) != comp->qstr_micropython) {
return false;
}
@@ -905,7 +905,7 @@
return true;
}
- qstr attr = PY_PARSE_NODE_LEAF_ARG(name_nodes[1]);
+ qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
if (attr == comp->qstr_byte_code) {
*emit_options = EMIT_OPT_BYTE_CODE;
#if MICROPY_EMIT_NATIVE
@@ -925,9 +925,9 @@
return true;
}
-void compile_decorated(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
// get the list of decorators
- py_parse_node_t *nodes;
+ mp_parse_node_t *nodes;
int n = list_get(&pns->nodes[0], PN_decorators, &nodes);
// inherit emit options for this function/class definition
@@ -936,11 +936,11 @@
// compile each decorator
int num_built_in_decorators = 0;
for (int i = 0; i < n; i++) {
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be
- py_parse_node_struct_t *pns_decorator = (py_parse_node_struct_t*)nodes[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
- py_parse_node_t *name_nodes;
+ mp_parse_node_t *name_nodes;
int name_len = list_get(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);
// check for built-in decorators
@@ -954,12 +954,12 @@
// compile the decorator function
compile_node(comp, name_nodes[0]);
for (int i = 1; i < name_len; i++) {
- assert(PY_PARSE_NODE_IS_ID(name_nodes[i])); // should be
- EMIT(load_attr, PY_PARSE_NODE_LEAF_ARG(name_nodes[i]));
+ assert(MP_PARSE_NODE_IS_ID(name_nodes[i])); // should be
+ EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[i]));
}
// nodes[1] contains arguments to the decorator function, if any
- if (!PY_PARSE_NODE_IS_NULL(pns_decorator->nodes[1])) {
+ 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]);
}
@@ -967,11 +967,11 @@
}
// compile the body (funcdef or classdef) and get its name
- py_parse_node_struct_t *pns_body = (py_parse_node_struct_t*)pns->nodes[1];
+ mp_parse_node_struct_t *pns_body = (mp_parse_node_struct_t*)pns->nodes[1];
qstr body_name = 0;
- if (PY_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
+ if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
body_name = compile_funcdef_helper(comp, pns_body, emit_options);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_classdef) {
body_name = compile_classdef_helper(comp, pns_body, emit_options);
} else {
// shouldn't happen
@@ -987,39 +987,39 @@
EMIT(store_id, body_name);
}
-void compile_funcdef(compiler_t *comp, py_parse_node_struct_t *pns) {
+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
EMIT(store_id, fname);
}
-void c_del_stmt(compiler_t *comp, py_parse_node_t pn) {
- if (PY_PARSE_NODE_IS_ID(pn)) {
- EMIT(delete_id, PY_PARSE_NODE_LEAF_ARG(pn));
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_power)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
+ if (MP_PARSE_NODE_IS_ID(pn)) {
+ EMIT(delete_id, MP_PARSE_NODE_LEAF_ARG(pn));
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_power)) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
compile_node(comp, pns->nodes[0]); // base of the power node
- if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
- py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_power_trailers) {
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1);
+ 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_power_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(PY_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
- pns1 = (py_parse_node_struct_t*)pns1->nodes[n - 1];
+ assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
+ pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
}
- if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
+ if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_paren) {
// SyntaxError: can't delete a function call
assert(0);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
compile_node(comp, pns1->nodes[0]);
EMIT(delete_subscr);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
- assert(PY_PARSE_NODE_IS_ID(pns1->nodes[0]));
- EMIT(delete_attr, PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_period) {
+ assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
+ EMIT(delete_attr, MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]));
} else {
// shouldn't happen
assert(0);
@@ -1029,30 +1029,30 @@
assert(0);
}
- if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+ if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
// SyntaxError, cannot delete
assert(0);
}
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {
- pn = ((py_parse_node_struct_t*)pn)->nodes[0];
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+ } 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_STRUCT_KIND(pn, PN_testlist_comp)) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
// TODO perhaps factorise testlist_comp code with other uses of PN_testlist_comp
- if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
- py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {
+ if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+ mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+ if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {
// sequence of one item, with trailing comma
- assert(PY_PARSE_NODE_IS_NULL(pns1->nodes[0]));
+ assert(MP_PARSE_NODE_IS_NULL(pns1->nodes[0]));
c_del_stmt(comp, pns->nodes[0]);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3c) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3c) {
// sequence of many items
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
c_del_stmt(comp, pns->nodes[0]);
for (int i = 0; i < n; i++) {
c_del_stmt(comp, pns1->nodes[i]);
}
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_comp_for) {
// TODO not implemented; can't del comprehension?
assert(0);
} else {
@@ -1075,18 +1075,18 @@
}
}
-void compile_del_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
apply_to_single_or_list(comp, pns->nodes[0], PN_exprlist, c_del_stmt);
}
-void compile_break_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_break_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->break_label == 0) {
printf("ERROR: cannot break from here\n");
}
EMIT(break_loop, comp->break_label);
}
-void compile_continue_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_continue_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->continue_label == 0) {
printf("ERROR: cannot continue from here\n");
}
@@ -1097,19 +1097,19 @@
}
}
-void compile_return_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->scope_cur->kind != SCOPE_FUNCTION) {
printf("SyntaxError: 'return' outside function\n");
comp->had_error = true;
return;
}
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// no argument to 'return', so return None
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
// special case when returning an if-expression; to match CPython optimisation
- py_parse_node_struct_t *pns_test_if_expr = (py_parse_node_struct_t*)pns->nodes[0];
- py_parse_node_struct_t *pns_test_if_else = (py_parse_node_struct_t*)pns_test_if_expr->nodes[1];
+ 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];
int l_fail = comp_next_label(comp);
c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
@@ -1123,18 +1123,18 @@
EMIT(return_value);
}
-void compile_yield_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_yield_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[0]);
EMIT(pop_top);
}
-void compile_raise_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// raise
EMIT(raise_varargs, 0);
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
// raise x from y
- pns = (py_parse_node_struct_t*)pns->nodes[0];
+ pns = (mp_parse_node_struct_t*)pns->nodes[0];
compile_node(comp, pns->nodes[0]);
compile_node(comp, pns->nodes[1]);
EMIT(raise_varargs, 2);
@@ -1148,33 +1148,33 @@
// q1 holds the base, q2 the full name
// eg a -> q1=q2=a
// a.b.c -> q1=a, q2=a.b.c
-void do_import_name(compiler_t *comp, py_parse_node_t pn, qstr *q1, qstr *q2) {
+void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q1, qstr *q2) {
bool is_as = false;
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
// a name of the form x as y; unwrap it
- *q1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
+ *q1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
pn = pns->nodes[0];
is_as = true;
}
- if (PY_PARSE_NODE_IS_ID(pn)) {
+ if (MP_PARSE_NODE_IS_ID(pn)) {
// just a simple name
- *q2 = PY_PARSE_NODE_LEAF_ARG(pn);
+ *q2 = MP_PARSE_NODE_LEAF_ARG(pn);
if (!is_as) {
*q1 = *q2;
}
EMIT(import_name, *q2);
- } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_dotted_name) {
+ } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dotted_name) {
// a name of the form a.b.c
if (!is_as) {
- *q1 = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ *q1 = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
}
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
int len = n - 1;
for (int i = 0; i < n; i++) {
- len += strlen(qstr_str(PY_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
+ len += strlen(qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
}
char *str = m_new(char, len + 1);
str[0] = 0;
@@ -1182,13 +1182,13 @@
if (i > 0) {
strcat(str, ".");
}
- strcat(str, qstr_str(PY_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
+ strcat(str, qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
}
*q2 = qstr_from_str_take(str);
EMIT(import_name, *q2);
if (is_as) {
for (int i = 1; i < n; i++) {
- EMIT(load_attr, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+ EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
}
}
} else {
@@ -1201,20 +1201,20 @@
}
}
-void compile_dotted_as_name(compiler_t *comp, py_parse_node_t pn) {
+void compile_dotted_as_name(compiler_t *comp, mp_parse_node_t pn) {
EMIT(load_const_small_int, 0); // ??
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
qstr q1, q2;
do_import_name(comp, pn, &q1, &q2);
EMIT(store_id, q1);
}
-void compile_import_name(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_import_name(compiler_t *comp, mp_parse_node_struct_t *pns) {
apply_to_single_or_list(comp, pns->nodes[0], PN_dotted_as_names, compile_dotted_as_name);
}
-void compile_import_from(compiler_t *comp, py_parse_node_struct_t *pns) {
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], PY_TOKEN_OP_STAR)) {
+void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
EMIT(load_const_small_int, 0); // level 0 for __import__
// build the "fromlist" tuple
@@ -1234,16 +1234,16 @@
EMIT(load_const_small_int, 0); // level 0 for __import__
// build the "fromlist" tuple
- py_parse_node_t *pn_nodes;
+ mp_parse_node_t *pn_nodes;
int n = list_get(&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(PY_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
- py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pn_nodes[i];
- qstr id2 = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
+ 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, ", ");
}
@@ -1260,9 +1260,9 @@
}
#else
for (int i = 0; i < n; i++) {
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
- py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pn_nodes[i];
- qstr id2 = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
+ 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
EMIT(load_const_str, id2, false);
}
EMIT(build_tuple, n);
@@ -1272,53 +1272,53 @@
qstr dummy_q, id1;
do_import_name(comp, pns->nodes[0], &dummy_q, &id1);
for (int i = 0; i < n; i++) {
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
- py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pn_nodes[i];
- qstr id2 = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
+ 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
EMIT(import_from, id2);
- if (PY_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
+ if (MP_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
EMIT(store_id, id2);
} else {
- EMIT(store_id, PY_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
+ EMIT(store_id, MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
}
}
EMIT(pop_top);
}
}
-void compile_global_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_global_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->pass == PASS_1) {
- if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
- scope_declare_global(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+ if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+ scope_declare_global(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
} else {
- pns = (py_parse_node_struct_t*)pns->nodes[0];
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ pns = (mp_parse_node_struct_t*)pns->nodes[0];
+ int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
for (int i = 0; i < num_nodes; i++) {
- scope_declare_global(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+ scope_declare_global(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
}
}
}
}
-void compile_nonlocal_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_nonlocal_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->pass == PASS_1) {
- if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
- scope_declare_nonlocal(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+ if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+ scope_declare_nonlocal(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
} else {
- pns = (py_parse_node_struct_t*)pns->nodes[0];
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ pns = (mp_parse_node_struct_t*)pns->nodes[0];
+ int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
for (int i = 0; i < num_nodes; i++) {
- scope_declare_nonlocal(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+ scope_declare_nonlocal(comp->scope_cur, MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
}
}
}
}
-void compile_assert_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_assert_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
int l_end = comp_next_label(comp);
c_if_cond(comp, pns->nodes[0], true, l_end);
EMIT(load_id, comp->qstr_assertion_error);
- if (!PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+ if (!MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
// assertion message
compile_node(comp, pns->nodes[1]);
EMIT(call_function, 1, 0, false, false);
@@ -1327,7 +1327,7 @@
EMIT(label_assign, l_end);
}
-void compile_if_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
// TODO proper and/or short circuiting
int l_end = comp_next_label(comp);
@@ -1336,7 +1336,7 @@
c_if_cond(comp, pns->nodes[0], false, l_fail); // if condition
compile_node(comp, pns->nodes[1]); // if block
- //if (!(PY_PARSE_NODE_IS_NULL(pns->nodes[2]) && PY_PARSE_NODE_IS_NULL(pns->nodes[3]))) { // optimisation; doesn't align with CPython
+ //if (!(MP_PARSE_NODE_IS_NULL(pns->nodes[2]) && MP_PARSE_NODE_IS_NULL(pns->nodes[3]))) { // optimisation; doesn't align with CPython
// jump over elif/else blocks if they exist
if (!EMIT(last_emit_was_return_value)) { // simple optimisation to align with CPython
EMIT(jump, l_end);
@@ -1344,17 +1344,17 @@
//}
EMIT(label_assign, l_fail);
- if (!PY_PARSE_NODE_IS_NULL(pns->nodes[2])) {
+ if (!MP_PARSE_NODE_IS_NULL(pns->nodes[2])) {
// compile elif blocks
- py_parse_node_struct_t *pns_elif = (py_parse_node_struct_t*)pns->nodes[2];
+ mp_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t*)pns->nodes[2];
- if (PY_PARSE_NODE_STRUCT_KIND(pns_elif) == PN_if_stmt_elif_list) {
+ if (MP_PARSE_NODE_STRUCT_KIND(pns_elif) == PN_if_stmt_elif_list) {
// multiple elif blocks
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns_elif);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_elif);
for (int i = 0; i < n; i++) {
- py_parse_node_struct_t *pns_elif2 = (py_parse_node_struct_t*)pns_elif->nodes[i];
+ mp_parse_node_struct_t *pns_elif2 = (mp_parse_node_struct_t*)pns_elif->nodes[i];
l_fail = comp_next_label(comp);
c_if_cond(comp, pns_elif2->nodes[0], false, l_fail); // elif condition
@@ -1385,7 +1385,7 @@
EMIT(label_assign, l_end);
}
-void compile_while_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_while_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
int old_break_label = comp->break_label;
int old_continue_label = comp->continue_label;
@@ -1431,7 +1431,7 @@
// TODO preload end and step onto stack if they are not constants
// TODO check if step is negative and do opposite test
-void compile_for_stmt_optimised_range(compiler_t *comp, py_parse_node_t pn_var, py_parse_node_t pn_start, py_parse_node_t pn_end, py_parse_node_t pn_step, py_parse_node_t pn_body, py_parse_node_t pn_else) {
+void compile_for_stmt_optimised_range(compiler_t *comp, mp_parse_node_t pn_var, mp_parse_node_t pn_start, mp_parse_node_t pn_end, mp_parse_node_t pn_step, mp_parse_node_t pn_body, mp_parse_node_t pn_else) {
int old_break_label = comp->break_label;
int old_continue_label = comp->continue_label;
@@ -1476,29 +1476,29 @@
EMIT(label_assign, break_label);
}
-void compile_for_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+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
- if (/*comp->scope_cur->emit_options == EMIT_OPT_VIPER &&*/ PY_PARSE_NODE_IS_ID(pns->nodes[0]) && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_power)) {
- py_parse_node_struct_t *pns_it = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_IS_ID(pns_it->nodes[0]) && PY_PARSE_NODE_LEAF_ARG(pns_it->nodes[0]) == comp->qstr_range && PY_PARSE_NODE_IS_STRUCT_KIND(pns_it->nodes[1], PN_trailer_paren) && PY_PARSE_NODE_IS_NULL(pns_it->nodes[2])) {
- py_parse_node_t pn_range_args = ((py_parse_node_struct_t*)pns_it->nodes[1])->nodes[0];
- py_parse_node_t *args;
+ if (/*comp->scope_cur->emit_options == EMIT_OPT_VIPER &&*/ MP_PARSE_NODE_IS_ID(pns->nodes[0]) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_power)) {
+ mp_parse_node_struct_t *pns_it = (mp_parse_node_struct_t*)pns->nodes[1];
+ if (MP_PARSE_NODE_IS_ID(pns_it->nodes[0]) && MP_PARSE_NODE_LEAF_ARG(pns_it->nodes[0]) == comp->qstr_range && MP_PARSE_NODE_IS_STRUCT_KIND(pns_it->nodes[1], PN_trailer_paren) && MP_PARSE_NODE_IS_NULL(pns_it->nodes[2])) {
+ mp_parse_node_t pn_range_args = ((mp_parse_node_struct_t*)pns_it->nodes[1])->nodes[0];
+ mp_parse_node_t *args;
int n_args = list_get(&pn_range_args, PN_arglist, &args);
if (1 <= n_args && n_args <= 3) {
- py_parse_node_t pn_range_start;
- py_parse_node_t pn_range_end;
- py_parse_node_t pn_range_step;
+ mp_parse_node_t pn_range_start;
+ mp_parse_node_t pn_range_end;
+ mp_parse_node_t pn_range_step;
if (n_args == 1) {
- pn_range_start = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, 0);
+ pn_range_start = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, 0);
pn_range_end = args[0];
- pn_range_step = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, 1);
+ pn_range_step = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, 1);
} else if (n_args == 2) {
pn_range_start = args[0];
pn_range_end = args[1];
- pn_range_step = py_parse_node_new_leaf(PY_PARSE_NODE_SMALL_INT, 1);
+ pn_range_step = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, 1);
} else {
pn_range_start = args[0];
pn_range_end = args[1];
@@ -1554,7 +1554,7 @@
EMIT(label_assign, end_label);
}
-void compile_try_except(compiler_t *comp, py_parse_node_t pn_body, int n_except, py_parse_node_t *pn_excepts, py_parse_node_t pn_else) {
+void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_except, mp_parse_node_t *pn_excepts, mp_parse_node_t pn_else) {
// this function is a bit of a hack at the moment
// don't understand how the stack works with exceptions, so we force it to return to the correct value
@@ -1571,13 +1571,13 @@
int l2 = comp_next_label(comp);
for (int i = 0; i < n_except; i++) {
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
- py_parse_node_struct_t *pns_except = (py_parse_node_struct_t*)pn_excepts[i];
+ assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
+ mp_parse_node_struct_t *pns_except = (mp_parse_node_struct_t*)pn_excepts[i];
qstr qstr_exception_local = 0;
int end_finally_label = comp_next_label(comp);
- if (PY_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
+ if (MP_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
// this is a catch all exception handler
if (i + 1 != n_except) {
printf("SyntaxError: default 'except:' must be last\n");
@@ -1585,13 +1585,13 @@
}
} else {
// this exception handler requires a match to a certain type of exception
- py_parse_node_t pns_exception_expr = pns_except->nodes[0];
- if (PY_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
- py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pns_exception_expr;
- if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
+ mp_parse_node_t pns_exception_expr = pns_except->nodes[0];
+ if (MP_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
+ mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns_exception_expr;
+ if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
// handler binds the exception to a local
pns_exception_expr = pns3->nodes[0];
- qstr_exception_local = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[1]);
+ qstr_exception_local = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[1]);
}
}
EMIT(dup_top);
@@ -1621,9 +1621,9 @@
}
EMIT(pop_except);
if (qstr_exception_local != 0) {
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(label_assign, l3);
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(store_id, qstr_exception_local);
EMIT(delete_id, qstr_exception_local);
EMIT(end_finally);
@@ -1640,47 +1640,47 @@
EMIT(set_stack_size, stack_size);
}
-void compile_try_finally(compiler_t *comp, py_parse_node_t pn_body, int n_except, py_parse_node_t *pn_except, py_parse_node_t pn_else, py_parse_node_t pn_finally) {
+void compile_try_finally(compiler_t *comp, mp_parse_node_t pn_body, int n_except, mp_parse_node_t *pn_except, mp_parse_node_t pn_else, mp_parse_node_t pn_finally) {
// don't understand how the stack works with exceptions, so we force it to return to the correct value
int stack_size = EMIT(get_stack_size);
int l_finally_block = comp_next_label(comp);
EMIT(setup_finally, l_finally_block);
if (n_except == 0) {
- assert(PY_PARSE_NODE_IS_NULL(pn_else));
+ assert(MP_PARSE_NODE_IS_NULL(pn_else));
compile_node(comp, pn_body);
} else {
compile_try_except(comp, pn_body, n_except, pn_except, pn_else);
}
EMIT(pop_block);
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(label_assign, l_finally_block);
compile_node(comp, pn_finally);
EMIT(end_finally);
EMIT(set_stack_size, stack_size);
}
-void compile_try_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
- if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
- py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
+void compile_try_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+ mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
+ if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
// just try-finally
- compile_try_finally(comp, pns->nodes[0], 0, NULL, PY_PARSE_NODE_NULL, pns2->nodes[0]);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_except_and_more) {
+ compile_try_finally(comp, pns->nodes[0], 0, NULL, MP_PARSE_NODE_NULL, pns2->nodes[0]);
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_except_and_more) {
// try-except and possibly else and/or finally
- py_parse_node_t *pn_excepts;
+ mp_parse_node_t *pn_excepts;
int n_except = list_get(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
- if (PY_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
+ if (MP_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
// no finally
compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1]);
} else {
// have finally
- compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((py_parse_node_struct_t*)pns2->nodes[2])->nodes[0]);
+ compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((mp_parse_node_struct_t*)pns2->nodes[2])->nodes[0]);
}
} else {
// just try-except
- py_parse_node_t *pn_excepts;
+ mp_parse_node_t *pn_excepts;
int n_except = list_get(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
- compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, PY_PARSE_NODE_NULL);
+ compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, MP_PARSE_NODE_NULL);
}
} else {
// shouldn't happen
@@ -1688,15 +1688,15 @@
}
}
-void compile_with_stmt_helper(compiler_t *comp, int n, py_parse_node_t *nodes, py_parse_node_t body) {
+void compile_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *nodes, mp_parse_node_t body) {
if (n == 0) {
// no more pre-bits, compile the body of the with
compile_node(comp, body);
} else {
int l_end = comp_next_label(comp);
- if (PY_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
// this pre-bit is of the form "a as b"
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)nodes[0];
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)nodes[0];
compile_node(comp, pns->nodes[0]);
EMIT(setup_with, l_end);
c_assign(comp, pns->nodes[1], ASSIGN_STORE);
@@ -1710,16 +1710,16 @@
compile_with_stmt_helper(comp, n - 1, nodes + 1, body);
// finish this with block
EMIT(pop_block);
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(label_assign, l_end);
EMIT(with_cleanup);
EMIT(end_finally);
}
}
-void compile_with_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
// get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
- py_parse_node_t *nodes;
+ mp_parse_node_t *nodes;
int n = list_get(&pns->nodes[0], PN_with_stmt_list, &nodes);
assert(n > 0);
@@ -1727,8 +1727,8 @@
compile_with_stmt_helper(comp, n, nodes, pns->nodes[1]);
}
-void compile_expr_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
if (comp->is_repl && comp->scope_cur->kind == SCOPE_MODULE) {
// for REPL, evaluate then print the expression
EMIT(load_id, qstr_from_str_static("__repl_print__"));
@@ -1738,7 +1738,7 @@
} else {
// for non-REPL, evaluate then discard the expression
- if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !PY_PARSE_NODE_IS_ID(pns->nodes[0])) {
+ if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
// do nothing with a lonely constant
} else {
compile_node(comp, pns->nodes[0]); // just an expression
@@ -1746,32 +1746,32 @@
}
}
} else {
- py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
- int kind = PY_PARSE_NODE_STRUCT_KIND(pns1);
+ mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+ int kind = MP_PARSE_NODE_STRUCT_KIND(pns1);
if (kind == PN_expr_stmt_augassign) {
c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
compile_node(comp, pns1->nodes[1]); // rhs
- assert(PY_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
+ assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
// note that we don't really need to implement separate inplace ops, just normal binary ops will suffice
- switch (PY_PARSE_NODE_LEAF_ARG(pns1->nodes[0])) {
- case PY_TOKEN_DEL_PIPE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_OR); break;
- case PY_TOKEN_DEL_CARET_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_XOR); break;
- case PY_TOKEN_DEL_AMPERSAND_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_AND); break;
- case PY_TOKEN_DEL_DBL_LESS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_LSHIFT); break;
- case PY_TOKEN_DEL_DBL_MORE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_RSHIFT); break;
- case PY_TOKEN_DEL_PLUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_ADD); break;
- case PY_TOKEN_DEL_MINUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_SUBTRACT); break;
- case PY_TOKEN_DEL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MULTIPLY); break;
- case PY_TOKEN_DEL_DBL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_FLOOR_DIVIDE); break;
- case PY_TOKEN_DEL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_TRUE_DIVIDE); break;
- case PY_TOKEN_DEL_PERCENT_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MODULO); break;
- case PY_TOKEN_DEL_DBL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_POWER); break;
+ switch (MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0])) {
+ case MP_TOKEN_DEL_PIPE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_OR); break;
+ case MP_TOKEN_DEL_CARET_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_XOR); break;
+ case MP_TOKEN_DEL_AMPERSAND_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_AND); break;
+ case MP_TOKEN_DEL_DBL_LESS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_LSHIFT); break;
+ case MP_TOKEN_DEL_DBL_MORE_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_RSHIFT); break;
+ case MP_TOKEN_DEL_PLUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_ADD); break;
+ case MP_TOKEN_DEL_MINUS_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_SUBTRACT); break;
+ case MP_TOKEN_DEL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MULTIPLY); break;
+ case MP_TOKEN_DEL_DBL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_FLOOR_DIVIDE); break;
+ case MP_TOKEN_DEL_SLASH_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_TRUE_DIVIDE); break;
+ case MP_TOKEN_DEL_PERCENT_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_MODULO); break;
+ case MP_TOKEN_DEL_DBL_STAR_EQUAL: EMIT(binary_op, RT_BINARY_OP_INPLACE_POWER); break;
default: assert(0); // shouldn't happen
}
c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
} else if (kind == PN_expr_stmt_assign_list) {
- int rhs = PY_PARSE_NODE_STRUCT_NUM_NODES(pns1) - 1;
- compile_node(comp, ((py_parse_node_struct_t*)pns1->nodes[rhs])->nodes[0]); // rhs
+ int rhs = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1) - 1;
+ compile_node(comp, ((mp_parse_node_struct_t*)pns1->nodes[rhs])->nodes[0]); // rhs
// following CPython, we store left-most first
if (rhs > 0) {
EMIT(dup_top);
@@ -1781,28 +1781,28 @@
if (i + 1 < rhs) {
EMIT(dup_top);
}
- c_assign(comp, ((py_parse_node_struct_t*)pns1->nodes[i])->nodes[0], ASSIGN_STORE); // middle store
+ c_assign(comp, ((mp_parse_node_struct_t*)pns1->nodes[i])->nodes[0], ASSIGN_STORE); // middle store
}
} else if (kind == PN_expr_stmt_assign) {
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
- && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
- && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns1->nodes[0]) == 2
- && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns->nodes[0]) == 2) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
+ && 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
- py_parse_node_struct_t* pns10 = (py_parse_node_struct_t*)pns1->nodes[0];
- py_parse_node_struct_t* pns0 = (py_parse_node_struct_t*)pns->nodes[0];
+ 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];
compile_node(comp, pns10->nodes[0]); // rhs
compile_node(comp, pns10->nodes[1]); // rhs
EMIT(rot_two);
c_assign(comp, pns0->nodes[0], ASSIGN_STORE); // lhs store
c_assign(comp, pns0->nodes[1], ASSIGN_STORE); // lhs store
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
- && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)
- && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns1->nodes[0]) == 3
- && PY_PARSE_NODE_STRUCT_NUM_NODES((py_parse_node_struct_t*)pns->nodes[0]) == 3) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns1->nodes[0], PN_testlist_star_expr)
+ && 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
- py_parse_node_struct_t* pns10 = (py_parse_node_struct_t*)pns1->nodes[0];
- py_parse_node_struct_t* pns0 = (py_parse_node_struct_t*)pns->nodes[0];
+ 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];
compile_node(comp, pns10->nodes[0]); // rhs
compile_node(comp, pns10->nodes[1]); // rhs
compile_node(comp, pns10->nodes[2]); // rhs
@@ -1822,8 +1822,8 @@
}
}
-void c_binary_op(compiler_t *comp, py_parse_node_struct_t *pns, rt_binary_op_t binary_op) {
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+void c_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns, rt_binary_op_t binary_op) {
+ int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
compile_node(comp, pns->nodes[0]);
for (int i = 1; i < num_nodes; i += 1) {
compile_node(comp, pns->nodes[i]);
@@ -1831,9 +1831,9 @@
}
}
-void compile_test_if_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
- py_parse_node_struct_t *pns_test_if_else = (py_parse_node_struct_t*)pns->nodes[1];
+void compile_test_if_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
+ mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns->nodes[1];
int stack_size = EMIT(get_stack_size);
int l_fail = comp_next_label(comp);
@@ -1847,16 +1847,16 @@
EMIT(label_assign, l_end);
}
-void compile_lambdef(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_lambdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
// TODO default params etc for lambda; possibly just use funcdef code
- //py_parse_node_t pn_params = pns->nodes[0];
- //py_parse_node_t pn_body = pns->nodes[1];
+ //mp_parse_node_t pn_params = pns->nodes[0];
+ //mp_parse_node_t pn_body = pns->nodes[1];
if (comp->pass == PASS_1) {
// create a new scope for this lambda
- scope_t *s = scope_new_and_link(comp, SCOPE_LAMBDA, (py_parse_node_t)pns, comp->scope_cur->emit_options);
+ scope_t *s = scope_new_and_link(comp, SCOPE_LAMBDA, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
// store the lambda scope so the compiling function (this one) can use it at each pass
- pns->nodes[2] = (py_parse_node_t)s;
+ pns->nodes[2] = (mp_parse_node_t)s;
}
// get the scope for this lambda
@@ -1866,9 +1866,9 @@
close_over_variables_etc(comp, this_scope, 0, 0);
}
-void compile_or_test(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_or_test(compiler_t *comp, mp_parse_node_struct_t *pns) {
int l_end = comp_next_label(comp);
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
for (int i = 0; i < n; i += 1) {
compile_node(comp, pns->nodes[i]);
if (i + 1 < n) {
@@ -1878,9 +1878,9 @@
EMIT(label_assign, l_end);
}
-void compile_and_test(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_and_test(compiler_t *comp, mp_parse_node_struct_t *pns) {
int l_end = comp_next_label(comp);
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
for (int i = 0; i < n; i += 1) {
compile_node(comp, pns->nodes[i]);
if (i + 1 < n) {
@@ -1890,14 +1890,14 @@
EMIT(label_assign, l_end);
}
-void compile_not_test_2(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_not_test_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[0]);
EMIT(unary_op, RT_UNARY_OP_NOT);
}
-void compile_comparison(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
int stack_size = EMIT(get_stack_size);
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
compile_node(comp, pns->nodes[0]);
bool multi = (num_nodes > 3);
int l_fail = 0;
@@ -1910,27 +1910,27 @@
EMIT(dup_top);
EMIT(rot_three);
}
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_LESS)) {
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_LESS)) {
EMIT(compare_op, RT_COMPARE_OP_LESS);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_MORE)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MORE)) {
EMIT(compare_op, RT_COMPARE_OP_MORE);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_EQUAL)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_EQUAL)) {
EMIT(compare_op, RT_COMPARE_OP_EQUAL);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_LESS_EQUAL)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_LESS_EQUAL)) {
EMIT(compare_op, RT_COMPARE_OP_LESS_EQUAL);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_MORE_EQUAL)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MORE_EQUAL)) {
EMIT(compare_op, RT_COMPARE_OP_MORE_EQUAL);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_NOT_EQUAL)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_NOT_EQUAL)) {
EMIT(compare_op, RT_COMPARE_OP_NOT_EQUAL);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_KW_IN)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_KW_IN)) {
EMIT(compare_op, RT_COMPARE_OP_IN);
- } else if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[i])) {
- py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[i];
- int kind = PY_PARSE_NODE_STRUCT_KIND(pns2);
+ } else if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])) {
+ mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[i];
+ int kind = MP_PARSE_NODE_STRUCT_KIND(pns2);
if (kind == PN_comp_op_not_in) {
EMIT(compare_op, RT_COMPARE_OP_NOT_IN);
} else if (kind == PN_comp_op_is) {
- if (PY_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
+ if (MP_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
EMIT(compare_op, RT_COMPARE_OP_IS);
} else {
EMIT(compare_op, RT_COMPARE_OP_IS_NOT);
@@ -1958,33 +1958,33 @@
}
}
-void compile_star_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_star_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
// TODO
assert(0);
compile_node(comp, pns->nodes[0]);
//EMIT(unary_op, "UNARY_STAR");
}
-void compile_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
c_binary_op(comp, pns, RT_BINARY_OP_OR);
}
-void compile_xor_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_xor_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
c_binary_op(comp, pns, RT_BINARY_OP_XOR);
}
-void compile_and_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_and_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
c_binary_op(comp, pns, RT_BINARY_OP_AND);
}
-void compile_shift_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+void compile_shift_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
compile_node(comp, pns->nodes[0]);
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_LESS)) {
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_LESS)) {
EMIT(binary_op, RT_BINARY_OP_LSHIFT);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_MORE)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_MORE)) {
EMIT(binary_op, RT_BINARY_OP_RSHIFT);
} else {
// shouldn't happen
@@ -1993,14 +1993,14 @@
}
}
-void compile_arith_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+void compile_arith_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
compile_node(comp, pns->nodes[0]);
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_PLUS)) {
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PLUS)) {
EMIT(binary_op, RT_BINARY_OP_ADD);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_MINUS)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MINUS)) {
EMIT(binary_op, RT_BINARY_OP_SUBTRACT);
} else {
// shouldn't happen
@@ -2009,18 +2009,18 @@
}
}
-void compile_term(compiler_t *comp, py_parse_node_struct_t *pns) {
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+void compile_term(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
compile_node(comp, pns->nodes[0]);
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_STAR)) {
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_STAR)) {
EMIT(binary_op, RT_BINARY_OP_MULTIPLY);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_DBL_SLASH)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_SLASH)) {
EMIT(binary_op, RT_BINARY_OP_FLOOR_DIVIDE);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_SLASH)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_SLASH)) {
EMIT(binary_op, RT_BINARY_OP_TRUE_DIVIDE);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], PY_TOKEN_OP_PERCENT)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PERCENT)) {
EMIT(binary_op, RT_BINARY_OP_MODULO);
} else {
// shouldn't happen
@@ -2029,13 +2029,13 @@
}
}
-void compile_factor_2(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_factor_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[1]);
- if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_PLUS)) {
+ if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_PLUS)) {
EMIT(unary_op, RT_UNARY_OP_POSITIVE);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_MINUS)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_MINUS)) {
EMIT(unary_op, RT_UNARY_OP_NEGATIVE);
- } else if (PY_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], PY_TOKEN_OP_TILDE)) {
+ } else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_TILDE)) {
EMIT(unary_op, RT_UNARY_OP_INVERT);
} else {
// shouldn't happen
@@ -2043,7 +2043,7 @@
}
}
-void compile_trailer_paren_helper(compiler_t *comp, py_parse_node_struct_t *pns, bool is_method_call) {
+void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_struct_t *pns, bool is_method_call) {
// function to call is on top of stack
int old_n_arg_keyword = comp->n_arg_keyword;
@@ -2075,14 +2075,14 @@
comp->have_dbl_star_arg = old_have_dbl_star_arg;
}
-void compile_power_trailers(compiler_t *comp, py_parse_node_struct_t *pns) {
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+void compile_power_trailers(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++) {
- if (i + 1 < num_nodes && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i], PN_trailer_period) && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i + 1], PN_trailer_paren)) {
+ if (i + 1 < num_nodes && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i], PN_trailer_period) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[i + 1], PN_trailer_paren)) {
// optimisation for method calls a.f(...), following PyPy
- py_parse_node_struct_t *pns_period = (py_parse_node_struct_t*)pns->nodes[i];
- py_parse_node_struct_t *pns_paren = (py_parse_node_struct_t*)pns->nodes[i + 1];
- EMIT(load_method, PY_PARSE_NODE_LEAF_ARG(pns_period->nodes[0])); // get the method
+ mp_parse_node_struct_t *pns_period = (mp_parse_node_struct_t*)pns->nodes[i];
+ mp_parse_node_struct_t *pns_paren = (mp_parse_node_struct_t*)pns->nodes[i + 1];
+ EMIT(load_method, MP_PARSE_NODE_LEAF_ARG(pns_period->nodes[0])); // get the method
compile_trailer_paren_helper(comp, pns_paren, true);
i += 1;
} else {
@@ -2091,29 +2091,29 @@
}
}
-void compile_power_dbl_star(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_power_dbl_star(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[0]);
EMIT(binary_op, RT_BINARY_OP_POWER);
}
-void compile_atom_string(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_atom_string(compiler_t *comp, mp_parse_node_struct_t *pns) {
// a list of strings
// check type of list (string or bytes) and count total number of bytes
- int n = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
int n_bytes = 0;
- int string_kind = PY_PARSE_NODE_NULL;
+ int string_kind = MP_PARSE_NODE_NULL;
for (int i = 0; i < n; i++) {
- assert(PY_PARSE_NODE_IS_LEAF(pns->nodes[i]));
- int pn_kind = PY_PARSE_NODE_LEAF_KIND(pns->nodes[i]);
- assert(pn_kind == PY_PARSE_NODE_STRING || pn_kind == PY_PARSE_NODE_BYTES);
+ assert(MP_PARSE_NODE_IS_LEAF(pns->nodes[i]));
+ int pn_kind = MP_PARSE_NODE_LEAF_KIND(pns->nodes[i]);
+ assert(pn_kind == MP_PARSE_NODE_STRING || pn_kind == MP_PARSE_NODE_BYTES);
if (i == 0) {
string_kind = pn_kind;
} else if (pn_kind != string_kind) {
printf("SyntaxError: cannot mix bytes and nonbytes literals\n");
return;
}
- const char *str = qstr_str(PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+ const char *str = qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
n_bytes += strlen(str);
}
@@ -2123,24 +2123,24 @@
// concatenate string/bytes
for (int i = 0; i < n; i++) {
- const char *str = qstr_str(PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+ const char *str = qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
strcat(cat_str, str);
}
- EMIT(load_const_str, qstr_from_str_take(cat_str), string_kind == PY_PARSE_NODE_BYTES);
+ EMIT(load_const_str, qstr_from_str_take(cat_str), string_kind == MP_PARSE_NODE_BYTES);
}
// pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node
-void compile_comprehension(compiler_t *comp, py_parse_node_struct_t *pns, scope_kind_t kind) {
- assert(PY_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
- py_parse_node_struct_t *pns_comp_for = (py_parse_node_struct_t*)pns->nodes[1];
+void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind) {
+ assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
+ assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
+ mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
if (comp->pass == PASS_1) {
// create a new scope for this comprehension
- scope_t *s = scope_new_and_link(comp, kind, (py_parse_node_t)pns, comp->scope_cur->emit_options);
+ scope_t *s = scope_new_and_link(comp, kind, (mp_parse_node_t)pns, comp->scope_cur->emit_options);
// store the comprehension scope so the compiling function (this one) can use it at each pass
- pns_comp_for->nodes[3] = (py_parse_node_t)s;
+ pns_comp_for->nodes[3] = (mp_parse_node_t)s;
}
// get the scope for this comprehension
@@ -2154,23 +2154,23 @@
EMIT(call_function, 1, 0, false, false);
}
-void compile_atom_paren(compiler_t *comp, py_parse_node_struct_t *pns) {
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+void compile_atom_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// an empty tuple
- c_tuple(comp, PY_PARSE_NODE_NULL, NULL);
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
- pns = (py_parse_node_struct_t*)pns->nodes[0];
- assert(!PY_PARSE_NODE_IS_NULL(pns->nodes[1]));
- if (PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
- py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
+ c_tuple(comp, MP_PARSE_NODE_NULL, NULL);
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
+ pns = (mp_parse_node_struct_t*)pns->nodes[0];
+ assert(!MP_PARSE_NODE_IS_NULL(pns->nodes[1]));
+ if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
+ mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
+ if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
// tuple of one item, with trailing comma
- assert(PY_PARSE_NODE_IS_NULL(pns2->nodes[0]));
+ assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
c_tuple(comp, pns->nodes[0], NULL);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3c) {
// tuple of many items
c_tuple(comp, pns->nodes[0], pns2);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
// generator expression
compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
} else {
@@ -2180,7 +2180,7 @@
} else {
// tuple with 2 items
tuple_with_2_items:
- c_tuple(comp, PY_PARSE_NODE_NULL, pns);
+ c_tuple(comp, MP_PARSE_NODE_NULL, pns);
}
} else {
// parenthesis around a single item, is just that item
@@ -2188,25 +2188,25 @@
}
}
-void compile_atom_bracket(compiler_t *comp, py_parse_node_struct_t *pns) {
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+void compile_atom_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// empty list
EMIT(build_list, 0);
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
- py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[0];
- if (PY_PARSE_NODE_IS_STRUCT(pns2->nodes[1])) {
- py_parse_node_struct_t *pns3 = (py_parse_node_struct_t*)pns2->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3b) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
+ mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[0];
+ if (MP_PARSE_NODE_IS_STRUCT(pns2->nodes[1])) {
+ mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns2->nodes[1];
+ if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3b) {
// list of one item, with trailing comma
- assert(PY_PARSE_NODE_IS_NULL(pns3->nodes[0]));
+ assert(MP_PARSE_NODE_IS_NULL(pns3->nodes[0]));
compile_node(comp, pns2->nodes[0]);
EMIT(build_list, 1);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3c) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3c) {
// list of many items
compile_node(comp, pns2->nodes[0]);
compile_generic_all_nodes(comp, pns3);
- EMIT(build_list, 1 + PY_PARSE_NODE_STRUCT_NUM_NODES(pns3));
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns3) == PN_comp_for) {
+ EMIT(build_list, 1 + MP_PARSE_NODE_STRUCT_NUM_NODES(pns3));
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_comp_for) {
// list comprehension
compile_comprehension(comp, pns2, SCOPE_LIST_COMP);
} else {
@@ -2227,31 +2227,31 @@
}
}
-void compile_atom_brace(compiler_t *comp, py_parse_node_struct_t *pns) {
- py_parse_node_t pn = pns->nodes[0];
- if (PY_PARSE_NODE_IS_NULL(pn)) {
+void compile_atom_brace(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ mp_parse_node_t pn = pns->nodes[0];
+ if (MP_PARSE_NODE_IS_NULL(pn)) {
// empty dict
EMIT(build_map, 0);
- } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
- pns = (py_parse_node_struct_t*)pn;
- if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
+ } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
+ pns = (mp_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
// dict with one element
EMIT(build_map, 1);
compile_node(comp, pn);
EMIT(store_map);
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
- assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
- py_parse_node_struct_t *pns1 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
+ assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
+ mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+ if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
// dict/set with multiple elements
// get tail elements (2nd, 3rd, ...)
- py_parse_node_t *nodes;
+ mp_parse_node_t *nodes;
int n = list_get(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
// first element sets whether it's a dict or set
bool is_dict;
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
// a dictionary
EMIT(build_map, 1 + n);
compile_node(comp, pns->nodes[0]);
@@ -2265,8 +2265,8 @@
// process rest of elements
for (int i = 0; i < n; i++) {
- py_parse_node_t pn = nodes[i];
- bool is_key_value = PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dictorsetmaker_item);
+ mp_parse_node_t pn = nodes[i];
+ bool is_key_value = MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dictorsetmaker_item);
compile_node(comp, pn);
if (is_dict) {
if (!is_key_value) {
@@ -2286,9 +2286,9 @@
if (!is_dict) {
EMIT(build_set, 1 + n);
}
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_comp_for) {
// dict/set comprehension
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_dictorsetmaker_item)) {
// a dictionary comprehension
compile_comprehension(comp, pns, SCOPE_DICT_COMP);
} else {
@@ -2311,34 +2311,34 @@
}
}
-void compile_trailer_paren(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_trailer_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_trailer_paren_helper(comp, pns, false);
}
-void compile_trailer_bracket(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_trailer_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
// object who's index we want is on top of stack
compile_node(comp, pns->nodes[0]); // the index
EMIT(binary_op, RT_BINARY_OP_SUBSCR);
}
-void compile_trailer_period(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_trailer_period(compiler_t *comp, mp_parse_node_struct_t *pns) {
// object who's attribute we want is on top of stack
- EMIT(load_attr, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // attribute to get
+ EMIT(load_attr, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // attribute to get
}
-void compile_subscript_3_helper(compiler_t *comp, py_parse_node_struct_t *pns) {
- assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3); // should always be
- py_parse_node_t pn = pns->nodes[0];
- if (PY_PARSE_NODE_IS_NULL(pn)) {
+void compile_subscript_3_helper(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3); // should always be
+ mp_parse_node_t pn = pns->nodes[0];
+ if (MP_PARSE_NODE_IS_NULL(pn)) {
// [?:]
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(build_slice, 2);
- } else if (PY_PARSE_NODE_IS_STRUCT(pn)) {
- pns = (py_parse_node_struct_t*)pn;
- if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
+ pns = (mp_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
pn = pns->nodes[0];
- if (PY_PARSE_NODE_IS_NULL(pn)) {
+ if (MP_PARSE_NODE_IS_NULL(pn)) {
// [?::]
EMIT(build_slice, 2);
} else {
@@ -2346,12 +2346,12 @@
compile_node(comp, pn);
EMIT(build_slice, 3);
}
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
compile_node(comp, pns->nodes[0]);
- assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
- pns = (py_parse_node_struct_t*)pns->nodes[1];
- assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+ assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
+ pns = (mp_parse_node_struct_t*)pns->nodes[1];
+ assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// [?:x:]
EMIT(build_slice, 2);
} else {
@@ -2371,30 +2371,30 @@
}
}
-void compile_subscript_2(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_subscript_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[0]); // start of slice
- assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
- compile_subscript_3_helper(comp, (py_parse_node_struct_t*)pns->nodes[1]);
+ assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
+ compile_subscript_3_helper(comp, (mp_parse_node_struct_t*)pns->nodes[1]);
}
-void compile_subscript_3(compiler_t *comp, py_parse_node_struct_t *pns) {
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+void compile_subscript_3(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
compile_subscript_3_helper(comp, pns);
}
-void compile_dictorsetmaker_item(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_dictorsetmaker_item(compiler_t *comp, mp_parse_node_struct_t *pns) {
// if this is called then we are compiling a dict key:value pair
compile_node(comp, pns->nodes[1]); // value
compile_node(comp, pns->nodes[0]); // key
}
-void compile_classdef(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_classdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
qstr cname = compile_classdef_helper(comp, pns, comp->scope_cur->emit_options);
// store class object into class name
EMIT(store_id, cname);
}
-void compile_arglist_star(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_arglist_star(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->have_star_arg) {
printf("SyntaxError?: can't have multiple *x\n");
return;
@@ -2403,7 +2403,7 @@
compile_node(comp, pns->nodes[0]);
}
-void compile_arglist_dbl_star(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_arglist_dbl_star(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->have_dbl_star_arg) {
printf("SyntaxError?: can't have multiple **x\n");
return;
@@ -2412,18 +2412,18 @@
compile_node(comp, pns->nodes[0]);
}
-void compile_argument(compiler_t *comp, py_parse_node_struct_t *pns) {
- assert(PY_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
- py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)pns->nodes[1];
- if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_argument_3) {
- if (!PY_PARSE_NODE_IS_ID(pns->nodes[0])) {
+void compile_argument(compiler_t *comp, mp_parse_node_struct_t *pns) {
+ assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
+ mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
+ if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_argument_3) {
+ if (!MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
printf("SyntaxError?: lhs of keyword argument must be an id\n");
return;
}
- EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+ EMIT(load_const_id, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
compile_node(comp, pns2->nodes[0]);
comp->n_arg_keyword += 1;
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_comp_for) {
compile_comprehension(comp, pns, SCOPE_GEN_EXPR);
} else {
// shouldn't happen
@@ -2431,19 +2431,19 @@
}
}
-void compile_yield_expr(compiler_t *comp, py_parse_node_struct_t *pns) {
+void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
if (comp->scope_cur->kind != SCOPE_FUNCTION) {
printf("SyntaxError: 'yield' outside function\n");
return;
}
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(yield_value);
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
- pns = (py_parse_node_struct_t*)pns->nodes[0];
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
+ pns = (mp_parse_node_struct_t*)pns->nodes[0];
compile_node(comp, pns->nodes[0]);
EMIT(get_iter);
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(yield_from);
} else {
compile_node(comp, pns->nodes[0]);
@@ -2451,7 +2451,7 @@
}
}
-typedef void (*compile_function_t)(compiler_t*, py_parse_node_struct_t*);
+typedef void (*compile_function_t)(compiler_t*, mp_parse_node_struct_t*);
static compile_function_t compile_function[] = {
NULL,
#define nc NULL
@@ -2463,20 +2463,20 @@
#undef DEF_RULE
};
-void compile_node(compiler_t *comp, py_parse_node_t pn) {
- if (PY_PARSE_NODE_IS_NULL(pn)) {
+void compile_node(compiler_t *comp, mp_parse_node_t pn) {
+ if (MP_PARSE_NODE_IS_NULL(pn)) {
// pass
- } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
- int arg = PY_PARSE_NODE_LEAF_ARG(pn);
- switch (PY_PARSE_NODE_LEAF_KIND(pn)) {
- case PY_PARSE_NODE_ID: EMIT(load_id, arg); break;
- case PY_PARSE_NODE_SMALL_INT: EMIT(load_const_small_int, arg); break;
- case PY_PARSE_NODE_INTEGER: EMIT(load_const_int, arg); break;
- case PY_PARSE_NODE_DECIMAL: EMIT(load_const_dec, arg); break;
- case PY_PARSE_NODE_STRING: EMIT(load_const_str, arg, false); break;
- case PY_PARSE_NODE_BYTES: EMIT(load_const_str, arg, true); break;
- case PY_PARSE_NODE_TOKEN:
- if (arg == PY_TOKEN_NEWLINE) {
+ } else if (MP_PARSE_NODE_IS_LEAF(pn)) {
+ int arg = MP_PARSE_NODE_LEAF_ARG(pn);
+ switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
+ case MP_PARSE_NODE_ID: EMIT(load_id, arg); break;
+ case MP_PARSE_NODE_SMALL_INT: EMIT(load_const_small_int, arg); break;
+ case MP_PARSE_NODE_INTEGER: EMIT(load_const_int, arg); break;
+ case MP_PARSE_NODE_DECIMAL: EMIT(load_const_dec, arg); break;
+ case MP_PARSE_NODE_STRING: EMIT(load_const_str, arg, false); break;
+ case MP_PARSE_NODE_BYTES: EMIT(load_const_str, arg, true); break;
+ case MP_PARSE_NODE_TOKEN:
+ if (arg == MP_TOKEN_NEWLINE) {
// this can occur when file_input lets through a NEWLINE (eg if file starts with a newline)
// or when single_input lets through a NEWLINE (user enters a blank line)
// do nothing
@@ -2487,11 +2487,11 @@
default: assert(0);
}
} else {
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- compile_function_t f = compile_function[PY_PARSE_NODE_STRUCT_KIND(pns)];
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+ compile_function_t f = compile_function[MP_PARSE_NODE_STRUCT_KIND(pns)];
if (f == NULL) {
- printf("node %u cannot be compiled\n", (uint)PY_PARSE_NODE_STRUCT_KIND(pns));
- py_parse_node_show(pn, 0);
+ printf("node %u cannot be compiled\n", (uint)MP_PARSE_NODE_STRUCT_KIND(pns));
+ mp_parse_node_show(pn, 0);
assert(0);
} else {
f(comp, pns);
@@ -2499,32 +2499,32 @@
}
}
-void compile_scope_func_lambda_param(compiler_t *comp, py_parse_node_t pn, pn_kind_t pn_name, pn_kind_t pn_star, pn_kind_t pn_dbl_star, bool allow_annotations) {
+void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn, pn_kind_t pn_name, pn_kind_t pn_star, pn_kind_t pn_dbl_star, bool allow_annotations) {
// TODO verify that *k and **k are last etc
qstr param_name = 0;
- py_parse_node_t pn_annotation = PY_PARSE_NODE_NULL;
- if (PY_PARSE_NODE_IS_ID(pn)) {
- param_name = PY_PARSE_NODE_LEAF_ARG(pn);
+ mp_parse_node_t pn_annotation = MP_PARSE_NODE_NULL;
+ if (MP_PARSE_NODE_IS_ID(pn)) {
+ param_name = MP_PARSE_NODE_LEAF_ARG(pn);
if (comp->have_bare_star) {
// comes after a bare star, so doesn't count as a parameter
} else {
comp->scope_cur->num_params += 1;
}
} else {
- assert(PY_PARSE_NODE_IS_STRUCT(pn));
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- if (PY_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
- param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ assert(MP_PARSE_NODE_IS_STRUCT(pn));
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
+ param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
//int node_index = 1; unused
if (allow_annotations) {
- if (!PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+ if (!MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
// this parameter has an annotation
pn_annotation = pns->nodes[1];
}
//node_index = 2; unused
}
/* this is obsolete now that num dict/default params are calculated in compile_funcdef_param
- if (!PY_PARSE_NODE_IS_NULL(pns->nodes[node_index])) {
+ if (!MP_PARSE_NODE_IS_NULL(pns->nodes[node_index])) {
// this parameter has a default value
if (comp->have_bare_star) {
comp->scope_cur->num_dict_params += 1;
@@ -2538,29 +2538,29 @@
} else {
comp->scope_cur->num_params += 1;
}
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
- if (PY_PARSE_NODE_IS_NULL(pns->nodes[0])) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
+ if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
// bare star
// TODO see http://www.python.org/dev/peps/pep-3102/
comp->have_bare_star = true;
//assert(comp->scope_cur->num_dict_params == 0);
- } else if (PY_PARSE_NODE_IS_ID(pns->nodes[0])) {
+ } else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
// named star
comp->scope_cur->flags |= SCOPE_FLAG_VARARGS;
- param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
- } else if (allow_annotations && PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)) {
+ param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ } else if (allow_annotations && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)) {
// named star with annotation
comp->scope_cur->flags |= SCOPE_FLAG_VARARGS;
- pns = (py_parse_node_struct_t*)pns->nodes[0];
- param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ pns = (mp_parse_node_struct_t*)pns->nodes[0];
+ param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
pn_annotation = pns->nodes[1];
} else {
// shouldn't happen
assert(0);
}
- } else if (PY_PARSE_NODE_STRUCT_KIND(pns) == pn_dbl_star) {
- param_name = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
- if (allow_annotations && !PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
+ } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_dbl_star) {
+ param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
+ if (allow_annotations && !MP_PARSE_NODE_IS_NULL(pns->nodes[1])) {
// this parameter has an annotation
pn_annotation = pns->nodes[1];
}
@@ -2572,7 +2572,7 @@
}
if (param_name != 0) {
- if (!PY_PARSE_NODE_IS_NULL(pn_annotation)) {
+ if (!MP_PARSE_NODE_IS_NULL(pn_annotation)) {
// TODO this parameter has an annotation
}
bool added;
@@ -2586,17 +2586,17 @@
}
}
-void compile_scope_func_param(compiler_t *comp, py_parse_node_t pn) {
+void compile_scope_func_param(compiler_t *comp, mp_parse_node_t pn) {
compile_scope_func_lambda_param(comp, pn, PN_typedargslist_name, PN_typedargslist_star, PN_typedargslist_dbl_star, true);
}
-void compile_scope_lambda_param(compiler_t *comp, py_parse_node_t pn) {
+void compile_scope_lambda_param(compiler_t *comp, mp_parse_node_t pn) {
compile_scope_func_lambda_param(comp, pn, PN_varargslist_name, PN_varargslist_star, PN_varargslist_dbl_star, false);
}
-void compile_scope_comp_iter(compiler_t *comp, py_parse_node_t pn_iter, py_parse_node_t pn_inner_expr, int l_top, int for_depth) {
+void compile_scope_comp_iter(compiler_t *comp, mp_parse_node_t pn_iter, mp_parse_node_t pn_inner_expr, int l_top, int for_depth) {
tail_recursion:
- if (PY_PARSE_NODE_IS_NULL(pn_iter)) {
+ if (MP_PARSE_NODE_IS_NULL(pn_iter)) {
// no more nested if/for; compile inner expression
compile_node(comp, pn_inner_expr);
if (comp->scope_cur->kind == SCOPE_LIST_COMP) {
@@ -2609,15 +2609,15 @@
EMIT(yield_value);
EMIT(pop_top);
}
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_if)) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_if)) {
// if condition
- py_parse_node_struct_t *pns_comp_if = (py_parse_node_struct_t*)pn_iter;
+ mp_parse_node_struct_t *pns_comp_if = (mp_parse_node_struct_t*)pn_iter;
c_if_cond(comp, pns_comp_if->nodes[0], false, l_top);
pn_iter = pns_comp_if->nodes[1];
goto tail_recursion;
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_for)) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_iter, PN_comp_for)) {
// for loop
- py_parse_node_struct_t *pns_comp_for2 = (py_parse_node_struct_t*)pn_iter;
+ mp_parse_node_struct_t *pns_comp_for2 = (mp_parse_node_struct_t*)pn_iter;
compile_node(comp, pns_comp_for2->nodes[1]);
int l_end2 = comp_next_label(comp);
int l_top2 = comp_next_label(comp);
@@ -2635,37 +2635,37 @@
}
}
-void check_for_doc_string(compiler_t *comp, py_parse_node_t pn) {
+void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
// see http://www.python.org/dev/peps/pep-0257/
// look for the first statement
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
// a statement; fall through
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
// file input; find the first non-newline node
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
- int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+ 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++) {
pn = pns->nodes[i];
- if (!(PY_PARSE_NODE_IS_LEAF(pn) && PY_PARSE_NODE_LEAF_KIND(pn) == PY_PARSE_NODE_TOKEN && PY_PARSE_NODE_LEAF_ARG(pn) == PY_TOKEN_NEWLINE)) {
+ if (!(MP_PARSE_NODE_IS_LEAF(pn) && MP_PARSE_NODE_LEAF_KIND(pn) == MP_PARSE_NODE_TOKEN && MP_PARSE_NODE_LEAF_ARG(pn) == MP_TOKEN_NEWLINE)) {
// not a newline, so this is the first statement; finish search
break;
}
}
// if we didn't find a non-newline then it's okay to fall through; pn will be a newline and so doc-string test below will fail gracefully
- } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
+ } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
// a list of statements; get the first one
- pn = ((py_parse_node_struct_t*)pn)->nodes[0];
+ pn = ((mp_parse_node_struct_t*)pn)->nodes[0];
} else {
return;
}
// check the first statement for a doc string
- if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
- py_parse_node_struct_t* pns = (py_parse_node_struct_t*)pn;
- if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
- int kind = PY_PARSE_NODE_LEAF_KIND(pns->nodes[0]);
- if (kind == PY_PARSE_NODE_STRING) {
+ if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
+ mp_parse_node_struct_t* pns = (mp_parse_node_struct_t*)pn;
+ if (MP_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+ int kind = MP_PARSE_NODE_LEAF_KIND(pns->nodes[0]);
+ if (kind == MP_PARSE_NODE_STRING) {
compile_node(comp, pns->nodes[0]); // a doc string
// store doc string
EMIT(store_id, comp->qstr___doc__);
@@ -2696,12 +2696,12 @@
check_for_doc_string(comp, scope->pn);
}
compile_node(comp, scope->pn);
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(return_value);
} else if (scope->kind == SCOPE_FUNCTION) {
- assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
- assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
+ assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+ assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
// work out number of parameters, keywords and default parameters, and add them to the id_info array
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
@@ -2710,18 +2710,18 @@
apply_to_single_or_list(comp, pns->nodes[1], PN_typedargslist, compile_scope_func_param);
}
- assert(PY_PARSE_NODE_IS_NULL(pns->nodes[2])); // 2 is something...
+ assert(MP_PARSE_NODE_IS_NULL(pns->nodes[2])); // 2 is something...
compile_node(comp, pns->nodes[3]); // 3 is function body
// emit return if it wasn't the last opcode
if (!EMIT(last_emit_was_return_value)) {
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
EMIT(return_value);
}
} else if (scope->kind == SCOPE_LAMBDA) {
- assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
- assert(PY_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
+ assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+ assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
// work out number of parameters, keywords and default parameters, and add them to the id_info array
// must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
@@ -2735,11 +2735,11 @@
} else if (scope->kind == SCOPE_LIST_COMP || scope->kind == SCOPE_DICT_COMP || scope->kind == SCOPE_SET_COMP || scope->kind == SCOPE_GEN_EXPR) {
// a bit of a hack at the moment
- assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
- assert(PY_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
- py_parse_node_struct_t *pns_comp_for = (py_parse_node_struct_t*)pns->nodes[1];
+ assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+ assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
+ assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
+ mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
qstr qstr_arg = qstr_from_str_static(".0");
if (comp->pass == PASS_1) {
@@ -2770,14 +2770,14 @@
EMIT(for_iter_end);
if (scope->kind == SCOPE_GEN_EXPR) {
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
}
EMIT(return_value);
} else {
assert(scope->kind == SCOPE_CLASS);
- assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
- assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
+ assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+ assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
if (comp->pass == PASS_1) {
bool added;
@@ -2795,7 +2795,7 @@
EMIT(store_locals);
EMIT(load_id, comp->qstr___name__);
EMIT(store_id, comp->qstr___module__);
- EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
+ EMIT(load_const_id, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
EMIT(store_id, comp->qstr___qualname__);
check_for_doc_string(comp, pns->nodes[2]);
@@ -2804,7 +2804,7 @@
id_info_t *id = scope_find(scope, comp->qstr___class__);
assert(id != NULL);
if (id->kind == ID_INFO_KIND_LOCAL) {
- EMIT(load_const_tok, PY_TOKEN_KW_NONE);
+ EMIT(load_const_tok, MP_TOKEN_KW_NONE);
} else {
EMIT(load_closure, comp->qstr___class__, 0); // XXX check this is the correct local num
}
@@ -2830,23 +2830,23 @@
}
// get the function definition parse node
- assert(PY_PARSE_NODE_IS_STRUCT(scope->pn));
- py_parse_node_struct_t *pns = (py_parse_node_struct_t*)scope->pn;
- assert(PY_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
+ assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
+ mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+ assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
- //qstr f_id = PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
+ //qstr f_id = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
// parameters are in pns->nodes[1]
if (comp->pass == PASS_2) {
- py_parse_node_t *pn_params;
+ mp_parse_node_t *pn_params;
int n_params = list_get(&pns->nodes[1], PN_typedargslist, &pn_params);
scope->num_params = EMIT_INLINE_ASM(count_params, n_params, pn_params);
}
- assert(PY_PARSE_NODE_IS_NULL(pns->nodes[2])); // type
+ assert(MP_PARSE_NODE_IS_NULL(pns->nodes[2])); // type
- py_parse_node_t pn_body = pns->nodes[3]; // body
- py_parse_node_t *nodes;
+ mp_parse_node_t pn_body = pns->nodes[3]; // body
+ mp_parse_node_t *nodes;
int num = list_get(&pn_body, PN_suite_block_stmts, &nodes);
if (comp->pass == PASS_3) {
@@ -2855,30 +2855,30 @@
}
for (int i = 0; i < num; i++) {
- assert(PY_PARSE_NODE_IS_STRUCT(nodes[i]));
- py_parse_node_struct_t *pns2 = (py_parse_node_struct_t*)nodes[i];
- assert(PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_expr_stmt);
- assert(PY_PARSE_NODE_IS_STRUCT(pns2->nodes[0]));
- assert(PY_PARSE_NODE_IS_NULL(pns2->nodes[1]));
- pns2 = (py_parse_node_struct_t*)pns2->nodes[0];
- assert(PY_PARSE_NODE_STRUCT_KIND(pns2) == PN_power);
- assert(PY_PARSE_NODE_IS_ID(pns2->nodes[0]));
- assert(PY_PARSE_NODE_IS_STRUCT_KIND(pns2->nodes[1], PN_trailer_paren));
- assert(PY_PARSE_NODE_IS_NULL(pns2->nodes[2]));
- qstr op = PY_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
- pns2 = (py_parse_node_struct_t*)pns2->nodes[1]; // PN_trailer_paren
- py_parse_node_t *pn_arg;
+ assert(MP_PARSE_NODE_IS_STRUCT(nodes[i]));
+ mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)nodes[i];
+ assert(MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_expr_stmt);
+ assert(MP_PARSE_NODE_IS_STRUCT(pns2->nodes[0]));
+ assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[1]));
+ pns2 = (mp_parse_node_struct_t*)pns2->nodes[0];
+ assert(MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_power);
+ assert(MP_PARSE_NODE_IS_ID(pns2->nodes[0]));
+ assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns2->nodes[1], PN_trailer_paren));
+ assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[2]));
+ qstr op = MP_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
+ pns2 = (mp_parse_node_struct_t*)pns2->nodes[1]; // PN_trailer_paren
+ mp_parse_node_t *pn_arg;
int n_args = list_get(&pns2->nodes[0], PN_arglist, &pn_arg);
// emit instructions
if (strcmp(qstr_str(op), "label") == 0) {
- if (!(n_args == 1 && PY_PARSE_NODE_IS_ID(pn_arg[0]))) {
+ if (!(n_args == 1 && MP_PARSE_NODE_IS_ID(pn_arg[0]))) {
printf("SyntaxError: inline assembler 'label' requires 1 argument\n");
return;
}
int lab = comp_next_label(comp);
if (pass > PASS_1) {
- EMIT_INLINE_ASM(label, lab, PY_PARSE_NODE_LEAF_ARG(pn_arg[0]));
+ EMIT_INLINE_ASM(label, lab, MP_PARSE_NODE_LEAF_ARG(pn_arg[0]));
}
} else {
if (pass > PASS_1) {
@@ -2975,7 +2975,7 @@
}
}
-bool py_compile(py_parse_node_t pn, bool is_repl) {
+bool mp_compile(mp_parse_node_t pn, bool is_repl) {
compiler_t *comp = m_new(compiler_t, 1);
comp->qstr___class__ = qstr_from_str_static("__class__");