From 07ddab529cb0953c473d30795e4dc3c6dfff0d89 Mon Sep 17 00:00:00 2001 From: Damien George Date: Sat, 29 Mar 2014 13:15:08 +0000 Subject: [PATCH] py: Change mp_const_* objects to macros. Addresses issue #388. --- py/builtintables.c | 7 +++++-- py/obj.c | 12 ++++++------ py/obj.h | 23 ++++++++++++++--------- py/objbool.c | 9 +++------ py/objexcept.c | 9 ++++----- py/objfun.c | 2 +- py/objgenerator.c | 2 +- py/objnamedtuple.c | 2 +- py/objnone.c | 5 ++--- py/objslice.c | 5 ++--- py/objstr.c | 2 +- py/objtuple.c | 25 ++++++++++++------------- py/objtype.c | 4 ++-- py/runtime.c | 5 ++--- py/vm.c | 2 +- 15 files changed, 57 insertions(+), 57 deletions(-) diff --git a/py/builtintables.c b/py/builtintables.c index 839d5ba813..ac9eed8d46 100644 --- a/py/builtintables.c +++ b/py/builtintables.c @@ -25,7 +25,7 @@ STATIC const mp_builtin_elem_t builtin_object_table[] = { { MP_QSTR___repl_print__, (mp_obj_t)&mp_builtin___repl_print___obj }, // built-in types - { MP_QSTR_bool, (mp_obj_t)&bool_type }, + { MP_QSTR_bool, (mp_obj_t)&mp_type_bool }, { MP_QSTR_bytes, (mp_obj_t)&bytes_type }, #if MICROPY_ENABLE_FLOAT { MP_QSTR_complex, (mp_obj_t)&mp_type_complex }, @@ -43,13 +43,16 @@ STATIC const mp_builtin_elem_t builtin_object_table[] = { { MP_QSTR_set, (mp_obj_t)&set_type }, { MP_QSTR_str, (mp_obj_t)&str_type }, { MP_QSTR_super, (mp_obj_t)&super_type }, - { MP_QSTR_tuple, (mp_obj_t)&tuple_type }, + { MP_QSTR_tuple, (mp_obj_t)&mp_type_tuple }, { MP_QSTR_type, (mp_obj_t)&mp_type_type }, { MP_QSTR_zip, (mp_obj_t)&zip_type }, { MP_QSTR_classmethod, (mp_obj_t)&mp_type_classmethod }, { MP_QSTR_staticmethod, (mp_obj_t)&mp_type_staticmethod }, + // built-in objects + { MP_QSTR_Ellipsis, (mp_obj_t)&mp_const_ellipsis_obj }, + // built-in user functions { MP_QSTR_abs, (mp_obj_t)&mp_builtin_abs_obj }, { MP_QSTR_all, (mp_obj_t)&mp_builtin_all_obj }, diff --git a/py/obj.c b/py/obj.c index 18f66a2b47..c2cdcdc7e2 100644 --- a/py/obj.c +++ b/py/obj.c @@ -79,11 +79,11 @@ machine_int_t mp_obj_hash(mp_obj_t o_in) { return MP_OBJ_SMALL_INT_VALUE(o_in); } else if (MP_OBJ_IS_STR(o_in)) { return mp_obj_str_get_hash(o_in); - } else if (MP_OBJ_IS_TYPE(o_in, &none_type)) { + } else if (MP_OBJ_IS_TYPE(o_in, &mp_type_NoneType)) { return (machine_int_t)o_in; } else if (MP_OBJ_IS_TYPE(o_in, &fun_native_type) || MP_OBJ_IS_TYPE(o_in, &fun_bc_type)) { return (machine_int_t)o_in; - } else if (MP_OBJ_IS_TYPE(o_in, &tuple_type)) { + } else if (MP_OBJ_IS_TYPE(o_in, &mp_type_tuple)) { return mp_obj_tuple_hash(o_in); // TODO hash class and instances @@ -207,7 +207,7 @@ void mp_obj_get_complex(mp_obj_t arg, mp_float_t *real, mp_float_t *imag) { #endif void mp_obj_get_array(mp_obj_t o, uint *len, mp_obj_t **items) { - if (MP_OBJ_IS_TYPE(o, &tuple_type)) { + if (MP_OBJ_IS_TYPE(o, &mp_type_tuple)) { mp_obj_tuple_get(o, len, items); } else if (MP_OBJ_IS_TYPE(o, &list_type)) { mp_obj_list_get(o, len, items); @@ -217,9 +217,9 @@ void mp_obj_get_array(mp_obj_t o, uint *len, mp_obj_t **items) { } void mp_obj_get_array_fixed_n(mp_obj_t o, uint len, mp_obj_t **items) { - if (MP_OBJ_IS_TYPE(o, &tuple_type) || MP_OBJ_IS_TYPE(o, &list_type)) { + if (MP_OBJ_IS_TYPE(o, &mp_type_tuple) || MP_OBJ_IS_TYPE(o, &list_type)) { uint seq_len; - if (MP_OBJ_IS_TYPE(o, &tuple_type)) { + if (MP_OBJ_IS_TYPE(o, &mp_type_tuple)) { mp_obj_tuple_get(o, &seq_len, items); } else { mp_obj_list_get(o, &seq_len, items); @@ -237,7 +237,7 @@ uint mp_get_index(const mp_obj_type_t *type, machine_uint_t len, mp_obj_t index, int i; if (MP_OBJ_IS_SMALL_INT(index)) { i = MP_OBJ_SMALL_INT_VALUE(index); - } else if (MP_OBJ_IS_TYPE(index, &bool_type)) { + } else if (MP_OBJ_IS_TYPE(index, &mp_type_bool)) { i = (index == mp_const_true ? 1 : 0); } else { nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "%s indices must be integers, not %s", qstr_str(type->name), mp_obj_get_type_str(index))); diff --git a/py/obj.h b/py/obj.h index 500ffbdc04..97d45a7962 100644 --- a/py/obj.h +++ b/py/obj.h @@ -226,12 +226,17 @@ extern const mp_obj_type_t mp_type_ValueError; extern const mp_obj_type_t mp_type_ZeroDivisionError; // Constant objects, globally accessible -extern const mp_obj_t mp_const_none; -extern const mp_obj_t mp_const_false; -extern const mp_obj_t mp_const_true; -extern const mp_obj_t mp_const_empty_tuple; -extern const mp_obj_t mp_const_ellipsis; -extern const mp_obj_t mp_const_GeneratorExit; +// The macros are for convenience only +#define mp_const_none ((mp_obj_t)&mp_const_none_obj) +#define mp_const_false ((mp_obj_t)&mp_const_false_obj) +#define mp_const_true ((mp_obj_t)&mp_const_true_obj) +#define mp_const_empty_tuple ((mp_obj_t)&mp_const_empty_tuple_obj) +extern const struct _mp_obj_none_t mp_const_none_obj; +extern const struct _mp_obj_bool_t mp_const_false_obj; +extern const struct _mp_obj_bool_t mp_const_true_obj; +extern const struct _mp_obj_tuple_t mp_const_empty_tuple_obj; +extern const struct _mp_obj_ellipsis_t mp_const_ellipsis_obj; +extern const struct _mp_obj_exception_t mp_const_GeneratorExit_obj; // General API for objects @@ -298,10 +303,10 @@ mp_obj_t mp_obj_len_maybe(mp_obj_t o_in); /* may return NULL */ extern const mp_obj_type_t mp_type_object; // none -extern const mp_obj_type_t none_type; +extern const mp_obj_type_t mp_type_NoneType; // bool -extern const mp_obj_type_t bool_type; +extern const mp_obj_type_t mp_type_bool; #define MP_BOOL(x) (x ? mp_const_true : mp_const_false) // cell @@ -359,7 +364,7 @@ mp_obj_t mp_obj_complex_binary_op(int op, mp_float_t lhs_real, mp_float_t lhs_im #endif // tuple -extern const mp_obj_type_t tuple_type; +extern const mp_obj_type_t mp_type_tuple; void mp_obj_tuple_get(mp_obj_t self_in, uint *len, mp_obj_t **items); void mp_obj_tuple_del(mp_obj_t self_in); machine_int_t mp_obj_tuple_hash(mp_obj_t self_in); diff --git a/py/objbool.c b/py/objbool.c index 9b4af2a31d..5f17fd6133 100644 --- a/py/objbool.c +++ b/py/objbool.c @@ -43,7 +43,7 @@ STATIC mp_obj_t bool_unary_op(int op, mp_obj_t o_in) { } } -const mp_obj_type_t bool_type = { +const mp_obj_type_t mp_type_bool = { { &mp_type_type }, .name = MP_QSTR_bool, .print = bool_print, @@ -51,8 +51,5 @@ const mp_obj_type_t bool_type = { .unary_op = bool_unary_op, }; -STATIC const mp_obj_bool_t false_obj = {{&bool_type}, false}; -STATIC const mp_obj_bool_t true_obj = {{&bool_type}, true}; - -const mp_obj_t mp_const_false = (mp_obj_t)&false_obj; -const mp_obj_t mp_const_true = (mp_obj_t)&true_obj; +const mp_obj_bool_t mp_const_false_obj = {{&mp_type_bool}, false}; +const mp_obj_bool_t mp_const_true_obj = {{&mp_type_bool}, true}; diff --git a/py/objexcept.c b/py/objexcept.c index d4c4b12492..6f2a3f096e 100644 --- a/py/objexcept.c +++ b/py/objexcept.c @@ -14,7 +14,7 @@ // This is unified class for C-level and Python-level exceptions // Python-level exceptions have empty ->msg and all arguments are in // args tuple. C-level exceptions likely have ->msg set, and args is empty. -typedef struct mp_obj_exception_t { +typedef struct _mp_obj_exception_t { mp_obj_base_t base; mp_obj_t traceback; // a list object, holding (file,line,block) as numbers (not Python objects); a hack for now vstr_t *msg; @@ -24,8 +24,7 @@ typedef struct mp_obj_exception_t { // Instance of GeneratorExit exception - needed by generator.close() // This would belong to objgenerator.c, but to keep mp_obj_exception_t // definition module-private so far, have it here. -STATIC mp_obj_exception_t GeneratorExit_obj = {{&mp_type_GeneratorExit}, MP_OBJ_NULL, NULL, {{&tuple_type}, 0}}; -const mp_obj_t mp_const_GeneratorExit = (mp_obj_t)&GeneratorExit_obj; +const mp_obj_exception_t mp_const_GeneratorExit_obj = {{&mp_type_GeneratorExit}, MP_OBJ_NULL, NULL, {{&mp_type_tuple}, 0}}; STATIC void mp_obj_exception_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind) { mp_obj_exception_t *o = o_in; @@ -61,7 +60,7 @@ STATIC mp_obj_t mp_obj_exception_make_new(mp_obj_t type_in, uint n_args, uint n_ o->base.type = type; o->traceback = MP_OBJ_NULL; o->msg = NULL; - o->args.base.type = &tuple_type; + o->args.base.type = &mp_type_tuple; o->args.len = n_args; memcpy(o->args.items, args, n_args * sizeof(mp_obj_t)); return o; @@ -95,7 +94,7 @@ const mp_obj_type_t mp_type_BaseException = { }; #define MP_DEFINE_EXCEPTION_BASE(base_name) \ -STATIC const mp_obj_tuple_t mp_type_ ## base_name ## _base_tuple = {{&tuple_type}, 1, {(mp_obj_t)&mp_type_ ## base_name}};\ +STATIC const mp_obj_tuple_t mp_type_ ## base_name ## _base_tuple = {{&mp_type_tuple}, 1, {(mp_obj_t)&mp_type_ ## base_name}};\ #define MP_DEFINE_EXCEPTION(exc_name, base_name) \ const mp_obj_type_t mp_type_ ## exc_name = { \ diff --git a/py/objfun.c b/py/objfun.c index e626c152a2..9370716608 100644 --- a/py/objfun.c +++ b/py/objfun.c @@ -373,7 +373,7 @@ STATIC machine_uint_t convert_obj_for_inline_asm(mp_obj_t obj) { // convert float to int (could also pass in float registers) return (machine_int_t)mp_obj_float_get(obj); #endif - } else if (MP_OBJ_IS_TYPE(obj, &tuple_type)) { + } else if (MP_OBJ_IS_TYPE(obj, &mp_type_tuple)) { // pointer to start of tuple (could pass length, but then could use len(x) for that) uint len; mp_obj_t *items; diff --git a/py/objgenerator.c b/py/objgenerator.c index f6c7007a02..a5e2b1a858 100644 --- a/py/objgenerator.c +++ b/py/objgenerator.c @@ -171,7 +171,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(gen_instance_throw_obj, 2, 4, gen_ins STATIC mp_obj_t gen_instance_close(mp_obj_t self_in) { mp_obj_t ret; - switch (mp_obj_gen_resume(self_in, mp_const_none, mp_const_GeneratorExit, &ret)) { + switch (mp_obj_gen_resume(self_in, mp_const_none, (mp_obj_t)&mp_const_GeneratorExit_obj, &ret)) { case MP_VM_RETURN_YIELD: nlr_jump(mp_obj_new_exception_msg(&mp_type_RuntimeError, "generator ignored GeneratorExit")); diff --git a/py/objnamedtuple.c b/py/objnamedtuple.c index 3485301113..a9e6e7d8ae 100644 --- a/py/objnamedtuple.c +++ b/py/objnamedtuple.c @@ -119,7 +119,7 @@ STATIC mp_obj_t namedtuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, co return tuple; } -STATIC const mp_obj_tuple_t namedtuple_base_tuple = {{&tuple_type}, 1, {(mp_obj_t)&tuple_type}}; +STATIC const mp_obj_tuple_t namedtuple_base_tuple = {{&mp_type_tuple}, 1, {(mp_obj_t)&mp_type_tuple}}; mp_obj_t mp_obj_new_namedtuple_type(qstr name, const char *fields) { mp_obj_namedtuple_type_t *o = m_new0(mp_obj_namedtuple_type_t, 1); diff --git a/py/objnone.c b/py/objnone.c index 1ec3d46fd4..3fccd88479 100644 --- a/py/objnone.c +++ b/py/objnone.c @@ -22,12 +22,11 @@ STATIC mp_obj_t none_unary_op(int op, mp_obj_t o_in) { } } -const mp_obj_type_t none_type = { +const mp_obj_type_t mp_type_NoneType = { { &mp_type_type }, .name = MP_QSTR_NoneType, .print = none_print, .unary_op = none_unary_op, }; -STATIC const mp_obj_none_t none_obj = {{&none_type}}; -const mp_obj_t mp_const_none = (mp_obj_t)&none_obj; +const mp_obj_none_t mp_const_none_obj = {{&mp_type_NoneType}}; diff --git a/py/objslice.c b/py/objslice.c index 46cce264a9..0c28d07edb 100644 --- a/py/objslice.c +++ b/py/objslice.c @@ -19,14 +19,13 @@ void ellipsis_print(void (*print)(void *env, const char *fmt, ...), void *env, m print(env, "Ellipsis"); } -const mp_obj_type_t ellipsis_type = { +const mp_obj_type_t mp_type_ellipsis = { { &mp_type_type }, .name = MP_QSTR_Ellipsis, .print = ellipsis_print, }; -STATIC const mp_obj_ellipsis_t ellipsis_obj = {{&ellipsis_type}}; -const mp_obj_t mp_const_ellipsis = (mp_obj_t)&ellipsis_obj; +const mp_obj_ellipsis_t mp_const_ellipsis_obj = {{&mp_type_ellipsis}}; /******************************************************************************/ /* slice object */ diff --git a/py/objstr.c b/py/objstr.c index 6812516b43..cf68e95fe8 100644 --- a/py/objstr.c +++ b/py/objstr.c @@ -309,7 +309,7 @@ STATIC mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) { // process args uint seq_len; mp_obj_t *seq_items; - if (MP_OBJ_IS_TYPE(arg, &tuple_type)) { + if (MP_OBJ_IS_TYPE(arg, &mp_type_tuple)) { mp_obj_tuple_get(arg, &seq_len, &seq_items); } else if (MP_OBJ_IS_TYPE(arg, &list_type)) { mp_obj_list_get(arg, &seq_len, &seq_items); diff --git a/py/objtuple.c b/py/objtuple.c index eb3d8259a6..6f4753afa7 100644 --- a/py/objtuple.c +++ b/py/objtuple.c @@ -42,7 +42,7 @@ STATIC mp_obj_t tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const m case 1: { // 1 argument, an iterable from which we make a new tuple - if (MP_OBJ_IS_TYPE(args[0], &tuple_type)) { + if (MP_OBJ_IS_TYPE(args[0], &mp_type_tuple)) { return args[0]; } @@ -75,8 +75,8 @@ STATIC mp_obj_t tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const m // Don't pass RT_BINARY_OP_NOT_EQUAL here STATIC bool tuple_cmp_helper(int op, mp_obj_t self_in, mp_obj_t another_in) { - assert(MP_OBJ_IS_TYPE(self_in, &tuple_type)); - if (!MP_OBJ_IS_TYPE(another_in, &tuple_type)) { + assert(MP_OBJ_IS_TYPE(self_in, &mp_type_tuple)); + if (!MP_OBJ_IS_TYPE(another_in, &mp_type_tuple)) { return false; } mp_obj_tuple_t *self = self_in; @@ -115,7 +115,7 @@ mp_obj_t tuple_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) { } case RT_BINARY_OP_ADD: { - if (!mp_obj_is_subclass_fast(mp_obj_get_type(rhs), (mp_obj_t)&tuple_type)) { + if (!mp_obj_is_subclass_fast(mp_obj_get_type(rhs), (mp_obj_t)&mp_type_tuple)) { return NULL; } mp_obj_tuple_t *p = rhs; @@ -153,14 +153,14 @@ STATIC mp_obj_t tuple_getiter(mp_obj_t o_in) { } STATIC mp_obj_t tuple_count(mp_obj_t self_in, mp_obj_t value) { - assert(MP_OBJ_IS_TYPE(self_in, &tuple_type)); + assert(MP_OBJ_IS_TYPE(self_in, &mp_type_tuple)); mp_obj_tuple_t *self = self_in; return mp_seq_count_obj(self->items, self->len, value); } STATIC MP_DEFINE_CONST_FUN_OBJ_2(tuple_count_obj, tuple_count); STATIC mp_obj_t tuple_index(uint n_args, const mp_obj_t *args) { - assert(MP_OBJ_IS_TYPE(args[0], &tuple_type)); + assert(MP_OBJ_IS_TYPE(args[0], &mp_type_tuple)); mp_obj_tuple_t *self = args[0]; return mp_seq_index_obj(self->items, self->len, n_args, args); } @@ -173,7 +173,7 @@ STATIC const mp_map_elem_t tuple_locals_dict_table[] = { STATIC MP_DEFINE_CONST_DICT(tuple_locals_dict, tuple_locals_dict_table); -const mp_obj_type_t tuple_type = { +const mp_obj_type_t mp_type_tuple = { { &mp_type_type }, .name = MP_QSTR_tuple, .print = tuple_print, @@ -185,15 +185,14 @@ const mp_obj_type_t tuple_type = { }; // the zero-length tuple -STATIC const mp_obj_tuple_t empty_tuple_obj = {{&tuple_type}, 0}; -const mp_obj_t mp_const_empty_tuple = (mp_obj_t)&empty_tuple_obj; +const mp_obj_tuple_t mp_const_empty_tuple_obj = {{&mp_type_tuple}, 0}; mp_obj_t mp_obj_new_tuple(uint n, const mp_obj_t *items) { if (n == 0) { return mp_const_empty_tuple; } mp_obj_tuple_t *o = m_new_obj_var(mp_obj_tuple_t, mp_obj_t, n); - o->base.type = &tuple_type; + o->base.type = &mp_type_tuple; o->len = n; if (items) { for (int i = 0; i < n; i++) { @@ -204,7 +203,7 @@ mp_obj_t mp_obj_new_tuple(uint n, const mp_obj_t *items) { } void mp_obj_tuple_get(mp_obj_t self_in, uint *len, mp_obj_t **items) { - assert(MP_OBJ_IS_TYPE(self_in, &tuple_type)); + assert(MP_OBJ_IS_TYPE(self_in, &mp_type_tuple)); mp_obj_tuple_t *self = self_in; if (len) { *len = self->len; @@ -215,13 +214,13 @@ void mp_obj_tuple_get(mp_obj_t self_in, uint *len, mp_obj_t **items) { } void mp_obj_tuple_del(mp_obj_t self_in) { - assert(MP_OBJ_IS_TYPE(self_in, &tuple_type)); + assert(MP_OBJ_IS_TYPE(self_in, &mp_type_tuple)); mp_obj_tuple_t *self = self_in; m_del_var(mp_obj_tuple_t, mp_obj_t, self->len, self); } machine_int_t mp_obj_tuple_hash(mp_obj_t self_in) { - assert(MP_OBJ_IS_TYPE(self_in, &tuple_type)); + assert(MP_OBJ_IS_TYPE(self_in, &mp_type_tuple)); mp_obj_tuple_t *self = self_in; // start hash with pointer to empty tuple, to make it fairly unique machine_int_t hash = (machine_int_t)mp_const_empty_tuple; diff --git a/py/objtype.c b/py/objtype.c index 51bc9ca3de..e553d8cf71 100644 --- a/py/objtype.c +++ b/py/objtype.c @@ -348,7 +348,7 @@ const mp_obj_type_t mp_type_type = { }; mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) { - assert(MP_OBJ_IS_TYPE(bases_tuple, &tuple_type)); // Micro Python restriction, for now + assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now assert(MP_OBJ_IS_TYPE(locals_dict, &dict_type)); // Micro Python restriction, for now mp_obj_type_t *o = m_new0(mp_obj_type_t, 1); o->base.type = &mp_type_type; @@ -502,7 +502,7 @@ STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) { if (MP_OBJ_IS_TYPE(classinfo, &mp_type_type)) { len = 1; items = &classinfo; - } else if (MP_OBJ_IS_TYPE(classinfo, &tuple_type)) { + } else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) { mp_obj_tuple_get(classinfo, &len, &items); } else { nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes")); diff --git a/py/runtime.c b/py/runtime.c index 3f637a16f9..4dc1c2ef53 100644 --- a/py/runtime.c +++ b/py/runtime.c @@ -51,7 +51,6 @@ void rt_init(void) { // add some builtins that can't be done in ROM mp_map_add_qstr(map_globals, MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR___main__)); - mp_map_add_qstr(&map_builtins, MP_QSTR_Ellipsis, mp_const_ellipsis); #if MICROPY_CPYTHON_COMPAT // Precreate sys module, so "import sys" didn't throw exceptions. @@ -559,9 +558,9 @@ mp_obj_t rt_store_set(mp_obj_t set, mp_obj_t item) { // unpacked items are stored in reverse order into the array pointed to by items void rt_unpack_sequence(mp_obj_t seq_in, uint num, mp_obj_t *items) { uint seq_len; - if (MP_OBJ_IS_TYPE(seq_in, &tuple_type) || MP_OBJ_IS_TYPE(seq_in, &list_type)) { + if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(seq_in, &list_type)) { mp_obj_t *seq_items; - if (MP_OBJ_IS_TYPE(seq_in, &tuple_type)) { + if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple)) { mp_obj_tuple_get(seq_in, &seq_len, &seq_items); } else { mp_obj_list_get(seq_in, &seq_len, &seq_items); diff --git a/py/vm.c b/py/vm.c index 1a1d345b2a..1f349dea61 100644 --- a/py/vm.c +++ b/py/vm.c @@ -173,7 +173,7 @@ dispatch_loop: break; case MP_BC_LOAD_CONST_ELLIPSIS: - PUSH(mp_const_ellipsis); + PUSH((mp_obj_t)&mp_const_ellipsis_obj); break; case MP_BC_LOAD_CONST_SMALL_INT: {