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).

1 files changed, 93 insertions, 93 deletions

diff --git a/py/emitbc.c b/py/emitbc.c
index e1632f37f..a10a3b96e 100644
--- a/py/emitbc.c
+++ b/py/emitbc.c
@@ -6,14 +6,14 @@
 #include <assert.h>
 
 #include "misc.h"
-#include "mpyconfig.h"
+#include "mpconfig.h"
 #include "lexer.h"
 #include "parse.h"
 #include "compile.h"
 #include "scope.h"
-#include "runtime.h"
+#include "runtime0.h"
 #include "emit.h"
-#include "bc.h"
+#include "bc0.h"
 
 struct _emit_t {
     pass_kind_t pass;
@@ -214,55 +214,55 @@ static void emit_bc_label_assign(emit_t *emit, int l) {
 
 static void emit_bc_import_name(emit_t *emit, qstr qstr) {
     emit_pre(emit, -1);
-    emit_write_byte_1_qstr(emit, PYBC_IMPORT_NAME, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_IMPORT_NAME, qstr);
 }
 
 static void emit_bc_import_from(emit_t *emit, qstr qstr) {
     emit_pre(emit, 1);
-    emit_write_byte_1_qstr(emit, PYBC_IMPORT_FROM, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_IMPORT_FROM, qstr);
 }
 
 static void emit_bc_import_star(emit_t *emit) {
     emit_pre(emit, -1);
-    emit_write_byte_1(emit, PYBC_IMPORT_STAR);
+    emit_write_byte_1(emit, MP_BC_IMPORT_STAR);
 }
 
-static void emit_bc_load_const_tok(emit_t *emit, py_token_kind_t tok) {
+static void emit_bc_load_const_tok(emit_t *emit, mp_token_kind_t tok) {
     emit_pre(emit, 1);
     switch (tok) {
-        case PY_TOKEN_KW_FALSE: emit_write_byte_1(emit, PYBC_LOAD_CONST_FALSE); break;
-        case PY_TOKEN_KW_NONE: emit_write_byte_1(emit, PYBC_LOAD_CONST_NONE); break;
-        case PY_TOKEN_KW_TRUE: emit_write_byte_1(emit, PYBC_LOAD_CONST_TRUE); break;
+        case MP_TOKEN_KW_FALSE: emit_write_byte_1(emit, MP_BC_LOAD_CONST_FALSE); break;
+        case MP_TOKEN_KW_NONE: emit_write_byte_1(emit, MP_BC_LOAD_CONST_NONE); break;
+        case MP_TOKEN_KW_TRUE: emit_write_byte_1(emit, MP_BC_LOAD_CONST_TRUE); break;
         default: assert(0);
     }
 }
 
 static void emit_bc_load_const_small_int(emit_t *emit, int arg) {
     emit_pre(emit, 1);
-    emit_write_byte_1_int(emit, PYBC_LOAD_CONST_SMALL_INT, arg);
+    emit_write_byte_1_int(emit, MP_BC_LOAD_CONST_SMALL_INT, arg);
 }
 
 static void emit_bc_load_const_int(emit_t *emit, qstr qstr) {
     emit_pre(emit, 1);
-    emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_INT, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_LOAD_CONST_INT, qstr);
 }
 
 static void emit_bc_load_const_dec(emit_t *emit, qstr qstr) {
     emit_pre(emit, 1);
-    emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_DEC, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr);
 }
 
 static void emit_bc_load_const_id(emit_t *emit, qstr qstr) {
     emit_pre(emit, 1);
-    emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_ID, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_LOAD_CONST_ID, qstr);
 }
 
 static void emit_bc_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
     emit_pre(emit, 1);
     if (bytes) {
-        emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_BYTES, qstr);
+        emit_write_byte_1_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr);
     } else {
-        emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_STRING, qstr);
+        emit_write_byte_1_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr);
     }
 }
 
@@ -275,219 +275,219 @@ static void emit_bc_load_fast(emit_t *emit, qstr qstr, int local_num) {
     assert(local_num >= 0);
     emit_pre(emit, 1);
     switch (local_num) {
-        case 0: emit_write_byte_1(emit, PYBC_LOAD_FAST_0); break;
-        case 1: emit_write_byte_1(emit, PYBC_LOAD_FAST_1); break;
-        case 2: emit_write_byte_1(emit, PYBC_LOAD_FAST_2); break;
-        default: emit_write_byte_1_uint(emit, PYBC_LOAD_FAST_N, local_num); break;
+        case 0: emit_write_byte_1(emit, MP_BC_LOAD_FAST_0); break;
+        case 1: emit_write_byte_1(emit, MP_BC_LOAD_FAST_1); break;
+        case 2: emit_write_byte_1(emit, MP_BC_LOAD_FAST_2); break;
+        default: emit_write_byte_1_uint(emit, MP_BC_LOAD_FAST_N, local_num); break;
     }
 }
 
 static void emit_bc_load_deref(emit_t *emit, qstr qstr, int local_num) {
     emit_pre(emit, 1);
-    emit_write_byte_1_uint(emit, PYBC_LOAD_DEREF, local_num);
+    emit_write_byte_1_uint(emit, MP_BC_LOAD_DEREF, local_num);
 }
 
 static void emit_bc_load_closure(emit_t *emit, qstr qstr, int local_num) {
     emit_pre(emit, 1);
-    emit_write_byte_1_uint(emit, PYBC_LOAD_CLOSURE, local_num);
+    emit_write_byte_1_uint(emit, MP_BC_LOAD_CLOSURE, local_num);
 }
 
 static void emit_bc_load_name(emit_t *emit, qstr qstr) {
     emit_pre(emit, 1);
-    emit_write_byte_1_qstr(emit, PYBC_LOAD_NAME, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_LOAD_NAME, qstr);
 }
 
 static void emit_bc_load_global(emit_t *emit, qstr qstr) {
     emit_pre(emit, 1);
-    emit_write_byte_1_qstr(emit, PYBC_LOAD_GLOBAL, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_LOAD_GLOBAL, qstr);
 }
 
 static void emit_bc_load_attr(emit_t *emit, qstr qstr) {
     emit_pre(emit, 0);
-    emit_write_byte_1_qstr(emit, PYBC_LOAD_ATTR, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_LOAD_ATTR, qstr);
 }
 
 static void emit_bc_load_method(emit_t *emit, qstr qstr) {
     emit_pre(emit, 0);
-    emit_write_byte_1_qstr(emit, PYBC_LOAD_METHOD, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_LOAD_METHOD, qstr);
 }
 
 static void emit_bc_load_build_class(emit_t *emit) {
     emit_pre(emit, 1);
-    emit_write_byte_1(emit, PYBC_LOAD_BUILD_CLASS);
+    emit_write_byte_1(emit, MP_BC_LOAD_BUILD_CLASS);
 }
 
 static void emit_bc_store_fast(emit_t *emit, qstr qstr, int local_num) {
     assert(local_num >= 0);
     emit_pre(emit, -1);
     switch (local_num) {
-        case 0: emit_write_byte_1(emit, PYBC_STORE_FAST_0); break;
-        case 1: emit_write_byte_1(emit, PYBC_STORE_FAST_1); break;
-        case 2: emit_write_byte_1(emit, PYBC_STORE_FAST_2); break;
-        default: emit_write_byte_1_uint(emit, PYBC_STORE_FAST_N, local_num); break;
+        case 0: emit_write_byte_1(emit, MP_BC_STORE_FAST_0); break;
+        case 1: emit_write_byte_1(emit, MP_BC_STORE_FAST_1); break;
+        case 2: emit_write_byte_1(emit, MP_BC_STORE_FAST_2); break;
+        default: emit_write_byte_1_uint(emit, MP_BC_STORE_FAST_N, local_num); break;
     }
 }
 
 static void emit_bc_store_deref(emit_t *emit, qstr qstr, int local_num) {
     emit_pre(emit, -1);
-    emit_write_byte_1_uint(emit, PYBC_STORE_DEREF, local_num);
+    emit_write_byte_1_uint(emit, MP_BC_STORE_DEREF, local_num);
 }
 
 static void emit_bc_store_name(emit_t *emit, qstr qstr) {
     emit_pre(emit, -1);
-    emit_write_byte_1_qstr(emit, PYBC_STORE_NAME, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_STORE_NAME, qstr);
 }
 
 static void emit_bc_store_global(emit_t *emit, qstr qstr) {
     emit_pre(emit, -1);
-    emit_write_byte_1_qstr(emit, PYBC_STORE_GLOBAL, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_STORE_GLOBAL, qstr);
 }
 
 static void emit_bc_store_attr(emit_t *emit, qstr qstr) {
     emit_pre(emit, -2);
-    emit_write_byte_1_qstr(emit, PYBC_STORE_ATTR, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_STORE_ATTR, qstr);
 }
 
 static void emit_bc_store_subscr(emit_t *emit) {
     emit_pre(emit, -3);
-    emit_write_byte_1(emit, PYBC_STORE_SUBSCR);
+    emit_write_byte_1(emit, MP_BC_STORE_SUBSCR);
 }
 
 static void emit_bc_store_locals(emit_t *emit) {
     // not needed
     emit_pre(emit, -1);
-    emit_write_byte_1(emit, PYBC_POP_TOP);
+    emit_write_byte_1(emit, MP_BC_POP_TOP);
 }
 
 static void emit_bc_delete_fast(emit_t *emit, qstr qstr, int local_num) {
     assert(local_num >= 0);
     emit_pre(emit, 0);
-    emit_write_byte_1_uint(emit, PYBC_DELETE_FAST_N, local_num);
+    emit_write_byte_1_uint(emit, MP_BC_DELETE_FAST_N, local_num);
 }
 
 static void emit_bc_delete_deref(emit_t *emit, qstr qstr, int local_num) {
     emit_pre(emit, 0);
-    emit_write_byte_1_qstr(emit, PYBC_DELETE_DEREF, local_num);
+    emit_write_byte_1_qstr(emit, MP_BC_DELETE_DEREF, local_num);
 }
 
 static void emit_bc_delete_name(emit_t *emit, qstr qstr) {
     emit_pre(emit, 0);
-    emit_write_byte_1_qstr(emit, PYBC_DELETE_NAME, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_DELETE_NAME, qstr);
 }
 
 static void emit_bc_delete_global(emit_t *emit, qstr qstr) {
     emit_pre(emit, 0);
-    emit_write_byte_1_qstr(emit, PYBC_DELETE_GLOBAL, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_DELETE_GLOBAL, qstr);
 }
 
 static void emit_bc_delete_attr(emit_t *emit, qstr qstr) {
     emit_pre(emit, -1);
-    emit_write_byte_1_qstr(emit, PYBC_DELETE_ATTR, qstr);
+    emit_write_byte_1_qstr(emit, MP_BC_DELETE_ATTR, qstr);
 }
 
 static void emit_bc_delete_subscr(emit_t *emit) {
     emit_pre(emit, -2);
-    emit_write_byte_1(emit, PYBC_DELETE_SUBSCR);
+    emit_write_byte_1(emit, MP_BC_DELETE_SUBSCR);
 }
 
 static void emit_bc_dup_top(emit_t *emit) {
     emit_pre(emit, 1);
-    emit_write_byte_1(emit, PYBC_DUP_TOP);
+    emit_write_byte_1(emit, MP_BC_DUP_TOP);
 }
 
 static void emit_bc_dup_top_two(emit_t *emit) {
     emit_pre(emit, 2);
-    emit_write_byte_1(emit, PYBC_DUP_TOP_TWO);
+    emit_write_byte_1(emit, MP_BC_DUP_TOP_TWO);
 }
 
 static void emit_bc_pop_top(emit_t *emit) {
     emit_pre(emit, -1);
-    emit_write_byte_1(emit, PYBC_POP_TOP);
+    emit_write_byte_1(emit, MP_BC_POP_TOP);
 }
 
 static void emit_bc_rot_two(emit_t *emit) {
     emit_pre(emit, 0);
-    emit_write_byte_1(emit, PYBC_ROT_TWO);
+    emit_write_byte_1(emit, MP_BC_ROT_TWO);
 }
 
 static void emit_bc_rot_three(emit_t *emit) {
     emit_pre(emit, 0);
-    emit_write_byte_1(emit, PYBC_ROT_THREE);
+    emit_write_byte_1(emit, MP_BC_ROT_THREE);
 }
 
 static void emit_bc_jump(emit_t *emit, int label) {
     emit_pre(emit, 0);
-    emit_write_byte_1_signed_label(emit, PYBC_JUMP, label);
+    emit_write_byte_1_signed_label(emit, MP_BC_JUMP, label);
 }
 
 static void emit_bc_pop_jump_if_true(emit_t *emit, int label) {
     emit_pre(emit, -1);
-    emit_write_byte_1_signed_label(emit, PYBC_POP_JUMP_IF_TRUE, label);
+    emit_write_byte_1_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label);
 }
 
 static void emit_bc_pop_jump_if_false(emit_t *emit, int label) {
     emit_pre(emit, -1);
-    emit_write_byte_1_signed_label(emit, PYBC_POP_JUMP_IF_FALSE, label);
+    emit_write_byte_1_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label);
 }
 
 static void emit_bc_jump_if_true_or_pop(emit_t *emit, int label) {
     emit_pre(emit, -1);
-    emit_write_byte_1_signed_label(emit, PYBC_JUMP_IF_TRUE_OR_POP, label);
+    emit_write_byte_1_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label);
 }
 
 static void emit_bc_jump_if_false_or_pop(emit_t *emit, int label) {
     emit_pre(emit, -1);
-    emit_write_byte_1_signed_label(emit, PYBC_JUMP_IF_FALSE_OR_POP, label);
+    emit_write_byte_1_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label);
 }
 
 static void emit_bc_setup_loop(emit_t *emit, int label) {
     emit_pre(emit, 0);
-    emit_write_byte_1_unsigned_label(emit, PYBC_SETUP_LOOP, label);
+    emit_write_byte_1_unsigned_label(emit, MP_BC_SETUP_LOOP, label);
 }
 
 static void emit_bc_break_loop(emit_t *emit, int label) {
     emit_pre(emit, 0);
-    emit_write_byte_1_unsigned_label(emit, PYBC_BREAK_LOOP, label);
+    emit_write_byte_1_unsigned_label(emit, MP_BC_BREAK_LOOP, label);
 }
 
 static void emit_bc_continue_loop(emit_t *emit, int label) {
     emit_pre(emit, 0);
-    emit_write_byte_1_unsigned_label(emit, PYBC_CONTINUE_LOOP, label);
+    emit_write_byte_1_unsigned_label(emit, MP_BC_CONTINUE_LOOP, label);
 }
 
 static void emit_bc_setup_with(emit_t *emit, int label) {
     emit_pre(emit, 7);
-    emit_write_byte_1_unsigned_label(emit, PYBC_SETUP_WITH, label);
+    emit_write_byte_1_unsigned_label(emit, MP_BC_SETUP_WITH, label);
 }
 
 static void emit_bc_with_cleanup(emit_t *emit) {
     emit_pre(emit, -7);
-    emit_write_byte_1(emit, PYBC_WITH_CLEANUP);
+    emit_write_byte_1(emit, MP_BC_WITH_CLEANUP);
 }
 
 static void emit_bc_setup_except(emit_t *emit, int label) {
     emit_pre(emit, 6);
-    emit_write_byte_1_unsigned_label(emit, PYBC_SETUP_EXCEPT, label);
+    emit_write_byte_1_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label);
 }
 
 static void emit_bc_setup_finally(emit_t *emit, int label) {
     emit_pre(emit, 6);
-    emit_write_byte_1_unsigned_label(emit, PYBC_SETUP_FINALLY, label);
+    emit_write_byte_1_unsigned_label(emit, MP_BC_SETUP_FINALLY, label);
 }
 
 static void emit_bc_end_finally(emit_t *emit) {
     emit_pre(emit, -1);
-    emit_write_byte_1(emit, PYBC_END_FINALLY);
+    emit_write_byte_1(emit, MP_BC_END_FINALLY);
 }
 
 static void emit_bc_get_iter(emit_t *emit) {
     emit_pre(emit, 0);
-    emit_write_byte_1(emit, PYBC_GET_ITER);
+    emit_write_byte_1(emit, MP_BC_GET_ITER);
 }
 
 static void emit_bc_for_iter(emit_t *emit, int label) {
     emit_pre(emit, 1);
-    emit_write_byte_1_unsigned_label(emit, PYBC_FOR_ITER, label);
+    emit_write_byte_1_unsigned_label(emit, MP_BC_FOR_ITER, label);
 }
 
 static void emit_bc_for_iter_end(emit_t *emit) {
@@ -496,104 +496,104 @@ static void emit_bc_for_iter_end(emit_t *emit) {
 
 static void emit_bc_pop_block(emit_t *emit) {
     emit_pre(emit, 0);
-    emit_write_byte_1(emit, PYBC_POP_BLOCK);
+    emit_write_byte_1(emit, MP_BC_POP_BLOCK);
 }
 
 static void emit_bc_pop_except(emit_t *emit) {
     emit_pre(emit, 0);
-    emit_write_byte_1(emit, PYBC_POP_EXCEPT);
+    emit_write_byte_1(emit, MP_BC_POP_EXCEPT);
 }
 
 static void emit_bc_unary_op(emit_t *emit, rt_unary_op_t op) {
     emit_pre(emit, 0);
-    emit_write_byte_1_byte(emit, PYBC_UNARY_OP, op);
+    emit_write_byte_1_byte(emit, MP_BC_UNARY_OP, op);
 }
 
 static void emit_bc_binary_op(emit_t *emit, rt_binary_op_t op) {
     emit_pre(emit, -1);
-    emit_write_byte_1_byte(emit, PYBC_BINARY_OP, op);
+    emit_write_byte_1_byte(emit, MP_BC_BINARY_OP, op);
 }
 
 static void emit_bc_compare_op(emit_t *emit, rt_compare_op_t op) {
     emit_pre(emit, -1);
-    emit_write_byte_1_byte(emit, PYBC_COMPARE_OP, op);
+    emit_write_byte_1_byte(emit, MP_BC_COMPARE_OP, op);
 }
 
 static void emit_bc_build_tuple(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_pre(emit, 1 - n_args);
-    emit_write_byte_1_uint(emit, PYBC_BUILD_TUPLE, n_args);
+    emit_write_byte_1_uint(emit, MP_BC_BUILD_TUPLE, n_args);
 }
 
 static void emit_bc_build_list(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_pre(emit, 1 - n_args);
-    emit_write_byte_1_uint(emit, PYBC_BUILD_LIST, n_args);
+    emit_write_byte_1_uint(emit, MP_BC_BUILD_LIST, n_args);
 }
 
 static void emit_bc_list_append(emit_t *emit, int list_stack_index) {
     assert(list_stack_index >= 0);
     emit_pre(emit, -1);
-    emit_write_byte_1_uint(emit, PYBC_LIST_APPEND, list_stack_index);
+    emit_write_byte_1_uint(emit, MP_BC_LIST_APPEND, list_stack_index);
 }
 
 static void emit_bc_build_map(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_pre(emit, 1);
-    emit_write_byte_1_uint(emit, PYBC_BUILD_MAP, n_args);
+    emit_write_byte_1_uint(emit, MP_BC_BUILD_MAP, n_args);
 }
 
 static void emit_bc_store_map(emit_t *emit) {
     emit_pre(emit, -2);
-    emit_write_byte_1(emit, PYBC_STORE_MAP);
+    emit_write_byte_1(emit, MP_BC_STORE_MAP);
 }
 
 static void emit_bc_map_add(emit_t *emit, int map_stack_index) {
     assert(map_stack_index >= 0);
     emit_pre(emit, -2);
-    emit_write_byte_1_uint(emit, PYBC_MAP_ADD, map_stack_index);
+    emit_write_byte_1_uint(emit, MP_BC_MAP_ADD, map_stack_index);
 }
 
 static void emit_bc_build_set(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_pre(emit, 1 - n_args);
-    emit_write_byte_1_uint(emit, PYBC_BUILD_SET, n_args);
+    emit_write_byte_1_uint(emit, MP_BC_BUILD_SET, n_args);
 }
 
 static void emit_bc_set_add(emit_t *emit, int set_stack_index) {
     assert(set_stack_index >= 0);
     emit_pre(emit, -1);
-    emit_write_byte_1_uint(emit, PYBC_SET_ADD, set_stack_index);
+    emit_write_byte_1_uint(emit, MP_BC_SET_ADD, set_stack_index);
 }
 
 static void emit_bc_build_slice(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_pre(emit, 1 - n_args);
-    emit_write_byte_1_uint(emit, PYBC_BUILD_SLICE, n_args);
+    emit_write_byte_1_uint(emit, MP_BC_BUILD_SLICE, n_args);
 }
 
 static void emit_bc_unpack_sequence(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_pre(emit, -1 + n_args);
-    emit_write_byte_1_uint(emit, PYBC_UNPACK_SEQUENCE, n_args);
+    emit_write_byte_1_uint(emit, MP_BC_UNPACK_SEQUENCE, n_args);
 }
 
 static void emit_bc_unpack_ex(emit_t *emit, int n_left, int n_right) {
     assert(n_left >=0 && n_right >= 0);
     emit_pre(emit, -1 + n_left + n_right + 1);
-    emit_write_byte_1_uint(emit, PYBC_UNPACK_EX, n_left | (n_right << 8));
+    emit_write_byte_1_uint(emit, MP_BC_UNPACK_EX, n_left | (n_right << 8));
 }
 
 static void emit_bc_make_function(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
     assert(n_default_params == 0 && n_dict_params == 0);
     emit_pre(emit, 1);
-    emit_write_byte_1_uint(emit, PYBC_MAKE_FUNCTION, scope->unique_code_id);
+    emit_write_byte_1_uint(emit, MP_BC_MAKE_FUNCTION, scope->unique_code_id);
 }
 
 static void emit_bc_make_closure(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
     assert(n_default_params == 0 && n_dict_params == 0);
     emit_pre(emit, 0);
-    emit_write_byte_1_uint(emit, PYBC_MAKE_CLOSURE, scope->unique_code_id);
+    emit_write_byte_1_uint(emit, MP_BC_MAKE_CLOSURE, scope->unique_code_id);
 }
 
 static void emit_bc_call_function(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
@@ -608,15 +608,15 @@ static void emit_bc_call_function(emit_t *emit, int n_positional, int n_keyword,
     int op;
     if (have_star_arg) {
         if (have_dbl_star_arg) {
-            op = PYBC_CALL_FUNCTION_VAR_KW;
+            op = MP_BC_CALL_FUNCTION_VAR_KW;
         } else {
-            op = PYBC_CALL_FUNCTION_VAR;
+            op = MP_BC_CALL_FUNCTION_VAR;
         }
     } else {
         if (have_dbl_star_arg) {
-            op = PYBC_CALL_FUNCTION_KW;
+            op = MP_BC_CALL_FUNCTION_KW;
         } else {
-            op = PYBC_CALL_FUNCTION;
+            op = MP_BC_CALL_FUNCTION;
         }
     }
     emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints
@@ -634,15 +634,15 @@ static void emit_bc_call_method(emit_t *emit, int n_positional, int n_keyword, b
     int op;
     if (have_star_arg) {
         if (have_dbl_star_arg) {
-            op = PYBC_CALL_METHOD_VAR_KW;
+            op = MP_BC_CALL_METHOD_VAR_KW;
         } else {
-            op = PYBC_CALL_METHOD_VAR;
+            op = MP_BC_CALL_METHOD_VAR;
         }
     } else {
         if (have_dbl_star_arg) {
-            op = PYBC_CALL_METHOD_KW;
+            op = MP_BC_CALL_METHOD_KW;
         } else {
-            op = PYBC_CALL_METHOD;
+            op = MP_BC_CALL_METHOD;
         }
     }
     emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints
@@ -651,13 +651,13 @@ static void emit_bc_call_method(emit_t *emit, int n_positional, int n_keyword, b
 static void emit_bc_return_value(emit_t *emit) {
     emit_pre(emit, -1);
     emit->last_emit_was_return_value = true;
-    emit_write_byte_1(emit, PYBC_RETURN_VALUE);
+    emit_write_byte_1(emit, MP_BC_RETURN_VALUE);
 }
 
 static void emit_bc_raise_varargs(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_pre(emit, -n_args);
-    emit_write_byte_1_uint(emit, PYBC_RAISE_VARARGS, n_args);
+    emit_write_byte_1_uint(emit, MP_BC_RAISE_VARARGS, n_args);
 }
 
 static void emit_bc_yield_value(emit_t *emit) {
@@ -665,7 +665,7 @@ static void emit_bc_yield_value(emit_t *emit) {
     if (emit->pass == PASS_2) {
         emit->scope->flags |= SCOPE_FLAG_GENERATOR;
     }
-    emit_write_byte_1(emit, PYBC_YIELD_VALUE);
+    emit_write_byte_1(emit, MP_BC_YIELD_VALUE);
 }
 
 static void emit_bc_yield_from(emit_t *emit) {
@@ -673,7 +673,7 @@ static void emit_bc_yield_from(emit_t *emit) {
     if (emit->pass == PASS_2) {
         emit->scope->flags |= SCOPE_FLAG_GENERATOR;
     }
-    emit_write_byte_1(emit, PYBC_YIELD_FROM);
+    emit_write_byte_1(emit, MP_BC_YIELD_FROM);
 }
 
 const emit_method_table_t emit_bc_method_table = {