diff --git a/py/builtin.c b/py/builtin.c
index 6d3fc9029ffc02d070bab476c5bf0936ac3613c9..a8a7009708c33daf0ac8f391134dcb3e3dead350 100644
--- a/py/builtin.c
+++ b/py/builtin.c
@@ -22,15 +22,15 @@ STATIC mp_obj_t mp_builtin___build_class__(uint n_args, const mp_obj_t *args) {
assert(2 <= n_args);
// we differ from CPython: we set the new __locals__ object here
- mp_map_t *old_locals = rt_locals_get();
+ mp_map_t *old_locals = mp_locals_get();
mp_obj_t class_locals = mp_obj_new_dict(0);
- rt_locals_set(mp_obj_dict_get_map(class_locals));
+ mp_locals_set(mp_obj_dict_get_map(class_locals));
// call the class code
- mp_obj_t cell = rt_call_function_1(args[0], (mp_obj_t)0xdeadbeef);
+ mp_obj_t cell = mp_call_function_1(args[0], (mp_obj_t)0xdeadbeef);
// restore old __locals__ object
- rt_locals_set(old_locals);
+ mp_locals_set(old_locals);
// get the class type (meta object) from the base objects
mp_obj_t meta;
@@ -49,7 +49,7 @@ STATIC mp_obj_t mp_builtin___build_class__(uint n_args, const mp_obj_t *args) {
meta_args[0] = args[1]; // class name
meta_args[1] = mp_obj_new_tuple(n_args - 2, args + 2); // tuple of bases
meta_args[2] = class_locals; // dict of members
- mp_obj_t new_class = rt_call_function_n_kw(meta, 3, 0, meta_args);
+ mp_obj_t new_class = mp_call_function_n_kw(meta, 3, 0, meta_args);
// store into cell if neede
if (cell != mp_const_none) {
@@ -101,10 +101,10 @@ mp_obj_t mp_builtin_abs(mp_obj_t o_in) {
MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_abs_obj, mp_builtin_abs);
STATIC mp_obj_t mp_builtin_all(mp_obj_t o_in) {
- mp_obj_t iterable = rt_getiter(o_in);
+ mp_obj_t iterable = mp_getiter(o_in);
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
- if (!rt_is_true(item)) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
+ if (!mp_obj_is_true(item)) {
return mp_const_false;
}
}
@@ -114,10 +114,10 @@ STATIC mp_obj_t mp_builtin_all(mp_obj_t o_in) {
MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_all_obj, mp_builtin_all);
STATIC mp_obj_t mp_builtin_any(mp_obj_t o_in) {
- mp_obj_t iterable = rt_getiter(o_in);
+ mp_obj_t iterable = mp_getiter(o_in);
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
- if (rt_is_true(item)) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
+ if (mp_obj_is_true(item)) {
return mp_const_true;
}
}
@@ -154,7 +154,7 @@ STATIC mp_obj_t mp_builtin_dir(uint n_args, const mp_obj_t *args) {
mp_map_t *map = NULL;
if (n_args == 0) {
// make a list of names in the local name space
- map = rt_locals_get();
+ map = mp_locals_get();
} else { // n_args == 1
// make a list of names in the given object
if (MP_OBJ_IS_TYPE(args[0], &mp_type_module)) {
@@ -193,7 +193,7 @@ STATIC mp_obj_t mp_builtin_divmod(mp_obj_t o1_in, mp_obj_t o2_in) {
mp_obj_t args[2];
args[0] = MP_OBJ_NEW_SMALL_INT(i1 / i2);
args[1] = MP_OBJ_NEW_SMALL_INT(i1 % i2);
- return rt_build_tuple(2, args);
+ return mp_build_tuple(2, args);
} else {
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "unsupported operand type(s) for divmod(): '%s' and '%s'", mp_obj_get_type_str(o1_in), mp_obj_get_type_str(o2_in)));
}
@@ -209,7 +209,7 @@ STATIC mp_obj_t mp_builtin_hash(mp_obj_t o_in) {
MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_hash_obj, mp_builtin_hash);
STATIC mp_obj_t mp_builtin_iter(mp_obj_t o_in) {
- return rt_getiter(o_in);
+ return mp_getiter(o_in);
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_iter_obj, mp_builtin_iter);
@@ -228,10 +228,10 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_len_obj, mp_builtin_len);
STATIC mp_obj_t mp_builtin_max(uint n_args, const mp_obj_t *args) {
if (n_args == 1) {
// given an iterable
- mp_obj_t iterable = rt_getiter(args[0]);
+ mp_obj_t iterable = mp_getiter(args[0]);
mp_obj_t max_obj = NULL;
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (max_obj == NULL || mp_obj_less(max_obj, item)) {
max_obj = item;
}
@@ -257,10 +257,10 @@ MP_DEFINE_CONST_FUN_OBJ_VAR(mp_builtin_max_obj, 1, mp_builtin_max);
STATIC mp_obj_t mp_builtin_min(uint n_args, const mp_obj_t *args) {
if (n_args == 1) {
// given an iterable
- mp_obj_t iterable = rt_getiter(args[0]);
+ mp_obj_t iterable = mp_getiter(args[0]);
mp_obj_t min_obj = NULL;
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (min_obj == NULL || mp_obj_less(item, min_obj)) {
min_obj = item;
}
@@ -284,7 +284,7 @@ STATIC mp_obj_t mp_builtin_min(uint n_args, const mp_obj_t *args) {
MP_DEFINE_CONST_FUN_OBJ_VAR(mp_builtin_min_obj, 1, mp_builtin_min);
STATIC mp_obj_t mp_builtin_next(mp_obj_t o) {
- mp_obj_t ret = rt_iternext_allow_raise(o);
+ mp_obj_t ret = mp_iternext_allow_raise(o);
if (ret == MP_OBJ_NULL) {
nlr_jump(mp_obj_new_exception(&mp_type_StopIteration));
} else {
@@ -311,8 +311,8 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_ord_obj, mp_builtin_ord);
STATIC mp_obj_t mp_builtin_pow(uint n_args, const mp_obj_t *args) {
assert(2 <= n_args && n_args <= 3);
switch (n_args) {
- case 2: return rt_binary_op(RT_BINARY_OP_POWER, args[0], args[1]);
- default: return rt_binary_op(RT_BINARY_OP_MODULO, rt_binary_op(RT_BINARY_OP_POWER, args[0], args[1]), args[2]); // TODO optimise...
+ case 2: return mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]);
+ default: return mp_binary_op(MP_BINARY_OP_MODULO, mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]), args[2]); // TODO optimise...
}
}
@@ -359,10 +359,10 @@ STATIC mp_obj_t mp_builtin_sum(uint n_args, const mp_obj_t *args) {
case 1: value = mp_obj_new_int(0); break;
default: value = args[1]; break;
}
- mp_obj_t iterable = rt_getiter(args[0]);
+ mp_obj_t iterable = mp_getiter(args[0]);
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
- value = rt_binary_op(RT_BINARY_OP_ADD, value, item);
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
+ value = mp_binary_op(MP_BINARY_OP_ADD, value, item);
}
return value;
}
@@ -391,7 +391,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_id_obj, mp_builtin_id);
STATIC mp_obj_t mp_builtin_getattr(mp_obj_t o_in, mp_obj_t attr) {
assert(MP_OBJ_IS_QSTR(attr));
- return rt_load_attr(o_in, MP_OBJ_QSTR_VALUE(attr));
+ return mp_load_attr(o_in, MP_OBJ_QSTR_VALUE(attr));
}
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_getattr_obj, mp_builtin_getattr);
diff --git a/py/builtinevex.c b/py/builtinevex.c
index d658db0adfb79ec61eb871c1aed3f8d09c293e7e..92550a79655623a96f5e1f2e1987ce23a08384e8 100644
--- a/py/builtinevex.c
+++ b/py/builtinevex.c
@@ -43,7 +43,7 @@ STATIC mp_obj_t parse_compile_execute(mp_obj_t o_in, mp_parse_input_kind_t parse
}
// complied successfully, execute it
- return rt_call_function_0(module_fun);
+ return mp_call_function_0(module_fun);
}
STATIC mp_obj_t mp_builtin_eval(mp_obj_t o_in) {
@@ -55,8 +55,8 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_eval_obj, mp_builtin_eval);
STATIC mp_obj_t mp_builtin_exec(uint n_args, const mp_obj_t *args) {
// Unconditional getting/setting assumes that these operations
// are cheap, which is the case when this comment was written.
- mp_map_t *old_globals = rt_globals_get();
- mp_map_t *old_locals = rt_locals_get();
+ mp_map_t *old_globals = mp_globals_get();
+ mp_map_t *old_locals = mp_locals_get();
if (n_args > 1) {
mp_obj_t globals = args[1];
mp_obj_t locals;
@@ -65,13 +65,13 @@ STATIC mp_obj_t mp_builtin_exec(uint n_args, const mp_obj_t *args) {
} else {
locals = globals;
}
- rt_globals_set(mp_obj_dict_get_map(globals));
- rt_locals_set(mp_obj_dict_get_map(locals));
+ mp_globals_set(mp_obj_dict_get_map(globals));
+ mp_locals_set(mp_obj_dict_get_map(locals));
}
mp_obj_t res = parse_compile_execute(args[0], MP_PARSE_FILE_INPUT);
// TODO if the above call throws an exception, then we never get to reset the globals/locals
- rt_globals_set(old_globals);
- rt_locals_set(old_locals);
+ mp_globals_set(old_globals);
+ mp_locals_set(old_locals);
return res;
}
diff --git a/py/builtinimport.c b/py/builtinimport.c
index 882b128df1f3822b12e59323519f1bd12a12ce43..4ba1d146a600f25ba673d88ee28c14e5cb29bba4 100644
--- a/py/builtinimport.c
+++ b/py/builtinimport.c
@@ -22,7 +22,7 @@
#define PATH_SEP_CHAR '/'
-mp_obj_t sys_path;
+mp_obj_t mp_sys_path;
mp_import_stat_t stat_dir_or_file(vstr_t *path) {
//printf("stat %s\n", vstr_str(path));
@@ -42,12 +42,12 @@ mp_import_stat_t find_file(const char *file_str, uint file_len, vstr_t *dest) {
// extract the list of paths
uint path_num = 0;
mp_obj_t *path_items;
- if (sys_path != MP_OBJ_NULL) {
- mp_obj_list_get(sys_path, &path_num, &path_items);
+ if (mp_sys_path != MP_OBJ_NULL) {
+ mp_obj_list_get(mp_sys_path, &path_num, &path_items);
}
if (path_num == 0) {
- // sys_path is empty, so just use the given file name
+ // mp_sys_path is empty, so just use the given file name
vstr_add_strn(dest, file_str, file_len);
return stat_dir_or_file(dest);
} else {
@@ -84,12 +84,12 @@ void do_load(mp_obj_t module_obj, vstr_t *file) {
qstr source_name = mp_lexer_source_name(lex);
// save the old context
- mp_map_t *old_locals = rt_locals_get();
- mp_map_t *old_globals = rt_globals_get();
+ mp_map_t *old_locals = mp_locals_get();
+ mp_map_t *old_globals = mp_globals_get();
// set the new context
- rt_locals_set(mp_obj_module_get_globals(module_obj));
- rt_globals_set(mp_obj_module_get_globals(module_obj));
+ mp_locals_set(mp_obj_module_get_globals(module_obj));
+ mp_globals_set(mp_obj_module_get_globals(module_obj));
// parse the imported script
mp_parse_error_kind_t parse_error_kind;
@@ -98,8 +98,8 @@ void do_load(mp_obj_t module_obj, vstr_t *file) {
if (pn == MP_PARSE_NODE_NULL) {
// parse error; clean up and raise exception
- rt_locals_set(old_locals);
- rt_globals_set(old_globals);
+ mp_locals_set(old_locals);
+ mp_globals_set(old_globals);
nlr_jump(mp_parse_make_exception(parse_error_kind));
}
@@ -109,24 +109,24 @@ void do_load(mp_obj_t module_obj, vstr_t *file) {
if (module_fun == mp_const_none) {
// TODO handle compile error correctly
- rt_locals_set(old_locals);
- rt_globals_set(old_globals);
+ mp_locals_set(old_locals);
+ mp_globals_set(old_globals);
return;
}
// complied successfully, execute it
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
- rt_call_function_0(module_fun);
+ mp_call_function_0(module_fun);
nlr_pop();
} else {
// exception; restore context and re-raise same exception
- rt_locals_set(old_locals);
- rt_globals_set(old_globals);
+ mp_locals_set(old_locals);
+ mp_globals_set(old_globals);
nlr_jump(nlr.ret_val);
}
- rt_locals_set(old_locals);
- rt_globals_set(old_globals);
+ mp_locals_set(old_locals);
+ mp_globals_set(old_globals);
}
mp_obj_t mp_builtin___import__(uint n_args, mp_obj_t *args) {
@@ -228,7 +228,7 @@ mp_obj_t mp_builtin___import__(uint n_args, mp_obj_t *args) {
}
if (outer_module_obj != MP_OBJ_NULL) {
qstr s = qstr_from_strn(mod_str + last, i - last);
- rt_store_attr(outer_module_obj, s, module_obj);
+ mp_store_attr(outer_module_obj, s, module_obj);
}
outer_module_obj = module_obj;
if (top_module_obj == MP_OBJ_NULL) {
diff --git a/py/compile.c b/py/compile.c
index f475979d114bc00c52389b8de9a1eb94d6c193f2..b32bc7e69c2ee7b12f8daa0689236052cd6781a9 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -602,7 +602,7 @@ void c_assign_power(compiler_t *comp, mp_parse_node_struct_t *pns, assign_kind_t
compile_node(comp, pns1->nodes[0]);
if (assign_kind == ASSIGN_AUG_LOAD) {
EMIT(dup_top_two);
- EMIT_ARG(binary_op, RT_BINARY_OP_SUBSCR);
+ EMIT_ARG(binary_op, MP_BINARY_OP_SUBSCR);
} else {
EMIT(store_subscr);
}
@@ -1531,7 +1531,7 @@ void compile_for_stmt_optimised_range(compiler_t *comp, mp_parse_node_t pn_var,
// compile: var += step
c_assign(comp, pn_var, ASSIGN_AUG_LOAD);
compile_node(comp, pn_step);
- EMIT_ARG(binary_op, RT_BINARY_OP_INPLACE_ADD);
+ EMIT_ARG(binary_op, MP_BINARY_OP_INPLACE_ADD);
c_assign(comp, pn_var, ASSIGN_AUG_STORE);
EMIT_ARG(label_assign, entry_label);
@@ -1541,9 +1541,9 @@ void compile_for_stmt_optimised_range(compiler_t *comp, mp_parse_node_t pn_var,
compile_node(comp, pn_end);
assert(MP_PARSE_NODE_IS_SMALL_INT(pn_step));
if (MP_PARSE_NODE_LEAF_SMALL_INT(pn_step) >= 0) {
- EMIT_ARG(binary_op, RT_BINARY_OP_LESS);
+ EMIT_ARG(binary_op, MP_BINARY_OP_LESS);
} else {
- EMIT_ARG(binary_op, RT_BINARY_OP_MORE);
+ EMIT_ARG(binary_op, MP_BINARY_OP_MORE);
}
EMIT_ARG(pop_jump_if_true, top_label);
@@ -1680,7 +1680,7 @@ void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_except,
}
EMIT(dup_top);
compile_node(comp, pns_exception_expr);
- EMIT_ARG(binary_op, RT_BINARY_OP_EXCEPTION_MATCH);
+ EMIT_ARG(binary_op, MP_BINARY_OP_EXCEPTION_MATCH);
EMIT_ARG(pop_jump_if_false, end_finally_label);
}
@@ -1848,21 +1848,21 @@ void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
compile_node(comp, pns1->nodes[1]); // rhs
assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
- rt_binary_op_t op;
+ mp_binary_op_t op;
switch (MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0])) {
- case MP_TOKEN_DEL_PIPE_EQUAL: op = RT_BINARY_OP_INPLACE_OR; break;
- case MP_TOKEN_DEL_CARET_EQUAL: op = RT_BINARY_OP_INPLACE_XOR; break;
- case MP_TOKEN_DEL_AMPERSAND_EQUAL: op = RT_BINARY_OP_INPLACE_AND; break;
- case MP_TOKEN_DEL_DBL_LESS_EQUAL: op = RT_BINARY_OP_INPLACE_LSHIFT; break;
- case MP_TOKEN_DEL_DBL_MORE_EQUAL: op = RT_BINARY_OP_INPLACE_RSHIFT; break;
- case MP_TOKEN_DEL_PLUS_EQUAL: op = RT_BINARY_OP_INPLACE_ADD; break;
- case MP_TOKEN_DEL_MINUS_EQUAL: op = RT_BINARY_OP_INPLACE_SUBTRACT; break;
- case MP_TOKEN_DEL_STAR_EQUAL: op = RT_BINARY_OP_INPLACE_MULTIPLY; break;
- case MP_TOKEN_DEL_DBL_SLASH_EQUAL: op = RT_BINARY_OP_INPLACE_FLOOR_DIVIDE; break;
- case MP_TOKEN_DEL_SLASH_EQUAL: op = RT_BINARY_OP_INPLACE_TRUE_DIVIDE; break;
- case MP_TOKEN_DEL_PERCENT_EQUAL: op = RT_BINARY_OP_INPLACE_MODULO; break;
- case MP_TOKEN_DEL_DBL_STAR_EQUAL: op = RT_BINARY_OP_INPLACE_POWER; break;
- default: assert(0); op = RT_BINARY_OP_INPLACE_OR; // shouldn't happen
+ case MP_TOKEN_DEL_PIPE_EQUAL: op = MP_BINARY_OP_INPLACE_OR; break;
+ case MP_TOKEN_DEL_CARET_EQUAL: op = MP_BINARY_OP_INPLACE_XOR; break;
+ case MP_TOKEN_DEL_AMPERSAND_EQUAL: op = MP_BINARY_OP_INPLACE_AND; break;
+ case MP_TOKEN_DEL_DBL_LESS_EQUAL: op = MP_BINARY_OP_INPLACE_LSHIFT; break;
+ case MP_TOKEN_DEL_DBL_MORE_EQUAL: op = MP_BINARY_OP_INPLACE_RSHIFT; break;
+ case MP_TOKEN_DEL_PLUS_EQUAL: op = MP_BINARY_OP_INPLACE_ADD; break;
+ case MP_TOKEN_DEL_MINUS_EQUAL: op = MP_BINARY_OP_INPLACE_SUBTRACT; break;
+ case MP_TOKEN_DEL_STAR_EQUAL: op = MP_BINARY_OP_INPLACE_MULTIPLY; break;
+ case MP_TOKEN_DEL_DBL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_FLOOR_DIVIDE; break;
+ case MP_TOKEN_DEL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_TRUE_DIVIDE; break;
+ case MP_TOKEN_DEL_PERCENT_EQUAL: op = MP_BINARY_OP_INPLACE_MODULO; break;
+ case MP_TOKEN_DEL_DBL_STAR_EQUAL: op = MP_BINARY_OP_INPLACE_POWER; break;
+ default: assert(0); op = MP_BINARY_OP_INPLACE_OR; // shouldn't happen
}
EMIT_ARG(binary_op, op);
c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
@@ -1919,7 +1919,7 @@ void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
}
}
-void c_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns, rt_binary_op_t binary_op) {
+void c_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns, mp_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) {
@@ -1989,7 +1989,7 @@ void compile_and_test(compiler_t *comp, mp_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_ARG(unary_op, RT_UNARY_OP_NOT);
+ EMIT_ARG(unary_op, MP_UNARY_OP_NOT);
}
void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
@@ -2008,28 +2008,28 @@ void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
EMIT(rot_three);
}
if (MP_PARSE_NODE_IS_TOKEN(pns->nodes[i])) {
- rt_binary_op_t op;
+ mp_binary_op_t op;
switch (MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])) {
- case MP_TOKEN_OP_LESS: op = RT_BINARY_OP_LESS; break;
- case MP_TOKEN_OP_MORE: op = RT_BINARY_OP_MORE; break;
- case MP_TOKEN_OP_DBL_EQUAL: op = RT_BINARY_OP_EQUAL; break;
- case MP_TOKEN_OP_LESS_EQUAL: op = RT_BINARY_OP_LESS_EQUAL; break;
- case MP_TOKEN_OP_MORE_EQUAL: op = RT_BINARY_OP_MORE_EQUAL; break;
- case MP_TOKEN_OP_NOT_EQUAL: op = RT_BINARY_OP_NOT_EQUAL; break;
- case MP_TOKEN_KW_IN: op = RT_BINARY_OP_IN; break;
- default: assert(0); op = RT_BINARY_OP_LESS; // shouldn't happen
+ case MP_TOKEN_OP_LESS: op = MP_BINARY_OP_LESS; break;
+ case MP_TOKEN_OP_MORE: op = MP_BINARY_OP_MORE; break;
+ case MP_TOKEN_OP_DBL_EQUAL: op = MP_BINARY_OP_EQUAL; break;
+ case MP_TOKEN_OP_LESS_EQUAL: op = MP_BINARY_OP_LESS_EQUAL; break;
+ case MP_TOKEN_OP_MORE_EQUAL: op = MP_BINARY_OP_MORE_EQUAL; break;
+ case MP_TOKEN_OP_NOT_EQUAL: op = MP_BINARY_OP_NOT_EQUAL; break;
+ case MP_TOKEN_KW_IN: op = MP_BINARY_OP_IN; break;
+ default: assert(0); op = MP_BINARY_OP_LESS; // shouldn't happen
}
EMIT_ARG(binary_op, op);
} 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_ARG(binary_op, RT_BINARY_OP_NOT_IN);
+ EMIT_ARG(binary_op, MP_BINARY_OP_NOT_IN);
} else if (kind == PN_comp_op_is) {
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[0])) {
- EMIT_ARG(binary_op, RT_BINARY_OP_IS);
+ EMIT_ARG(binary_op, MP_BINARY_OP_IS);
} else {
- EMIT_ARG(binary_op, RT_BINARY_OP_IS_NOT);
+ EMIT_ARG(binary_op, MP_BINARY_OP_IS_NOT);
}
} else {
// shouldn't happen
@@ -2062,15 +2062,15 @@ void compile_star_expr(compiler_t *comp, mp_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);
+ c_binary_op(comp, pns, MP_BINARY_OP_OR);
}
void compile_xor_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
- c_binary_op(comp, pns, RT_BINARY_OP_XOR);
+ c_binary_op(comp, pns, MP_BINARY_OP_XOR);
}
void compile_and_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
- c_binary_op(comp, pns, RT_BINARY_OP_AND);
+ c_binary_op(comp, pns, MP_BINARY_OP_AND);
}
void compile_shift_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
@@ -2079,9 +2079,9 @@ void compile_shift_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_LESS)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_LSHIFT);
+ EMIT_ARG(binary_op, MP_BINARY_OP_LSHIFT);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_MORE)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_RSHIFT);
+ EMIT_ARG(binary_op, MP_BINARY_OP_RSHIFT);
} else {
// shouldn't happen
assert(0);
@@ -2095,9 +2095,9 @@ void compile_arith_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PLUS)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_ADD);
+ EMIT_ARG(binary_op, MP_BINARY_OP_ADD);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_MINUS)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_SUBTRACT);
+ EMIT_ARG(binary_op, MP_BINARY_OP_SUBTRACT);
} else {
// shouldn't happen
assert(0);
@@ -2111,13 +2111,13 @@ void compile_term(compiler_t *comp, mp_parse_node_struct_t *pns) {
for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_STAR)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_MULTIPLY);
+ EMIT_ARG(binary_op, MP_BINARY_OP_MULTIPLY);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_SLASH)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_FLOOR_DIVIDE);
+ EMIT_ARG(binary_op, MP_BINARY_OP_FLOOR_DIVIDE);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_SLASH)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_TRUE_DIVIDE);
+ EMIT_ARG(binary_op, MP_BINARY_OP_TRUE_DIVIDE);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PERCENT)) {
- EMIT_ARG(binary_op, RT_BINARY_OP_MODULO);
+ EMIT_ARG(binary_op, MP_BINARY_OP_MODULO);
} else {
// shouldn't happen
assert(0);
@@ -2128,11 +2128,11 @@ void compile_term(compiler_t *comp, mp_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 (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_PLUS)) {
- EMIT_ARG(unary_op, RT_UNARY_OP_POSITIVE);
+ EMIT_ARG(unary_op, MP_UNARY_OP_POSITIVE);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_MINUS)) {
- EMIT_ARG(unary_op, RT_UNARY_OP_NEGATIVE);
+ EMIT_ARG(unary_op, MP_UNARY_OP_NEGATIVE);
} else if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_TILDE)) {
- EMIT_ARG(unary_op, RT_UNARY_OP_INVERT);
+ EMIT_ARG(unary_op, MP_UNARY_OP_INVERT);
} else {
// shouldn't happen
assert(0);
@@ -2219,7 +2219,7 @@ void compile_power_trailers(compiler_t *comp, mp_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_ARG(binary_op, RT_BINARY_OP_POWER);
+ EMIT_ARG(binary_op, MP_BINARY_OP_POWER);
}
void compile_atom_string(compiler_t *comp, mp_parse_node_struct_t *pns) {
@@ -2444,7 +2444,7 @@ void compile_trailer_paren(compiler_t *comp, mp_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_ARG(binary_op, RT_BINARY_OP_SUBSCR);
+ EMIT_ARG(binary_op, MP_BINARY_OP_SUBSCR);
}
void compile_trailer_period(compiler_t *comp, mp_parse_node_struct_t *pns) {
@@ -3317,7 +3317,7 @@ mp_obj_t mp_compile(mp_parse_node_t pn, qstr source_file, bool is_repl) {
#else
// return function that executes the outer module
// we can free the unique_code slot because no-one has reference to this unique_code_id anymore
- return rt_make_function_from_id(unique_code_id, true, MP_OBJ_NULL);
+ return mp_make_function_from_id(unique_code_id, true, MP_OBJ_NULL);
#endif
}
}
diff --git a/py/emit.h b/py/emit.h
index 26149983b089416c296a1c6a3a8c0fdafb076ec4..26672ab6840522a1b4797603f03fc73b3202236f 100644
--- a/py/emit.h
+++ b/py/emit.h
@@ -84,8 +84,8 @@ typedef struct _emit_method_table_t {
void (*for_iter_end)(emit_t *emit);
void (*pop_block)(emit_t *emit);
void (*pop_except)(emit_t *emit);
- void (*unary_op)(emit_t *emit, rt_unary_op_t op);
- void (*binary_op)(emit_t *emit, rt_binary_op_t op);
+ void (*unary_op)(emit_t *emit, mp_unary_op_t op);
+ void (*binary_op)(emit_t *emit, mp_binary_op_t op);
void (*build_tuple)(emit_t *emit, int n_args);
void (*build_list)(emit_t *emit, int n_args);
void (*list_append)(emit_t *emit, int list_stack_index);
diff --git a/py/emitbc.c b/py/emitbc.c
index 43b2d36d44036afdb99079562006722b731eabca..0db1aaad88de9ad0220d1126a89b6a8bf9c3d097 100644
--- a/py/emitbc.c
+++ b/py/emitbc.c
@@ -632,10 +632,10 @@ STATIC void emit_bc_pop_except(emit_t *emit) {
emit_write_byte_code_byte(emit, MP_BC_POP_EXCEPT);
}
-STATIC void emit_bc_unary_op(emit_t *emit, rt_unary_op_t op) {
- if (op == RT_UNARY_OP_NOT) {
+STATIC void emit_bc_unary_op(emit_t *emit, mp_unary_op_t op) {
+ if (op == MP_UNARY_OP_NOT) {
emit_bc_pre(emit, 0);
- emit_write_byte_code_byte_byte(emit, MP_BC_UNARY_OP, RT_UNARY_OP_BOOL);
+ emit_write_byte_code_byte_byte(emit, MP_BC_UNARY_OP, MP_UNARY_OP_BOOL);
emit_bc_pre(emit, 0);
emit_write_byte_code_byte(emit, MP_BC_NOT);
} else {
@@ -644,14 +644,14 @@ STATIC void emit_bc_unary_op(emit_t *emit, rt_unary_op_t op) {
}
}
-STATIC void emit_bc_binary_op(emit_t *emit, rt_binary_op_t op) {
+STATIC void emit_bc_binary_op(emit_t *emit, mp_binary_op_t op) {
bool invert = false;
- if (op == RT_BINARY_OP_NOT_IN) {
+ if (op == MP_BINARY_OP_NOT_IN) {
invert = true;
- op = RT_BINARY_OP_IN;
- } else if (op == RT_BINARY_OP_IS_NOT) {
+ op = MP_BINARY_OP_IN;
+ } else if (op == MP_BINARY_OP_IS_NOT) {
invert = true;
- op = RT_BINARY_OP_IS;
+ op = MP_BINARY_OP_IS;
}
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_byte(emit, MP_BC_BINARY_OP, op);
diff --git a/py/emitcpy.c b/py/emitcpy.c
index afd5a5af944528a23e3c29784b1c052d2c32058d..aa6bad9d6599e961cd11ac4852724c3b28820613 100644
--- a/py/emitcpy.c
+++ b/py/emitcpy.c
@@ -541,21 +541,21 @@ STATIC void emit_cpy_pop_except(emit_t *emit) {
}
}
-STATIC void emit_cpy_unary_op(emit_t *emit, rt_unary_op_t op) {
+STATIC void emit_cpy_unary_op(emit_t *emit, mp_unary_op_t op) {
emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) {
switch (op) {
- case RT_UNARY_OP_POSITIVE: printf("UNARY_POSITIVE\n"); break;
- case RT_UNARY_OP_NEGATIVE: printf("UNARY_NEGATIVE\n"); break;
- case RT_UNARY_OP_INVERT: printf("UNARY_INVERT\n"); break;
- case RT_UNARY_OP_NOT: printf("UNARY_NOT\n"); break;
+ case MP_UNARY_OP_POSITIVE: printf("UNARY_POSITIVE\n"); break;
+ case MP_UNARY_OP_NEGATIVE: printf("UNARY_NEGATIVE\n"); break;
+ case MP_UNARY_OP_INVERT: printf("UNARY_INVERT\n"); break;
+ case MP_UNARY_OP_NOT: printf("UNARY_NOT\n"); break;
default: assert(0);
}
}
}
-STATIC void emit_cpy_binary_op(emit_t *emit, rt_binary_op_t op) {
- if (op <= RT_BINARY_OP_INPLACE_POWER) {
+STATIC void emit_cpy_binary_op(emit_t *emit, mp_binary_op_t op) {
+ if (op <= MP_BINARY_OP_INPLACE_POWER) {
// CPython uses a byte code for each binary op
emit_pre(emit, -1, 1);
} else {
@@ -564,42 +564,42 @@ STATIC void emit_cpy_binary_op(emit_t *emit, rt_binary_op_t op) {
}
if (emit->pass == PASS_3) {
switch (op) {
- case RT_BINARY_OP_SUBSCR: printf("BINARY_SUBSCR\n"); break;
- case RT_BINARY_OP_OR: printf("BINARY_OR\n"); break;
- case RT_BINARY_OP_XOR: printf("BINARY_XOR\n"); break;
- case RT_BINARY_OP_AND: printf("BINARY_AND\n"); break;
- case RT_BINARY_OP_LSHIFT: printf("BINARY_LSHIFT\n"); break;
- case RT_BINARY_OP_RSHIFT: printf("BINARY_RSHIFT\n"); break;
- case RT_BINARY_OP_ADD: printf("BINARY_ADD\n"); break;
- case RT_BINARY_OP_SUBTRACT: printf("BINARY_SUBTRACT\n"); break;
- case RT_BINARY_OP_MULTIPLY: printf("BINARY_MULTIPLY\n"); break;
- case RT_BINARY_OP_FLOOR_DIVIDE: printf("BINARY_FLOOR_DIVIDE\n"); break;
- case RT_BINARY_OP_TRUE_DIVIDE: printf("BINARY_TRUE_DIVIDE\n"); break;
- case RT_BINARY_OP_MODULO: printf("BINARY_MODULO\n"); break;
- case RT_BINARY_OP_POWER: printf("BINARY_POWER\n"); break;
- case RT_BINARY_OP_INPLACE_OR: printf("INPLACE_OR\n"); break;
- case RT_BINARY_OP_INPLACE_XOR: printf("INPLACE_XOR\n"); break;
- case RT_BINARY_OP_INPLACE_AND: printf("INPLACE_AND\n"); break;
- case RT_BINARY_OP_INPLACE_LSHIFT: printf("INPLACE_LSHIFT\n"); break;
- case RT_BINARY_OP_INPLACE_RSHIFT: printf("INPLACE_RSHIFT\n"); break;
- case RT_BINARY_OP_INPLACE_ADD: printf("INPLACE_ADD\n"); break;
- case RT_BINARY_OP_INPLACE_SUBTRACT: printf("INPLACE_SUBTRACT\n"); break;
- case RT_BINARY_OP_INPLACE_MULTIPLY: printf("INPLACE_MULTIPLY\n"); break;
- case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: printf("INPLACE_FLOOR_DIVIDE\n"); break;
- case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: printf("INPLACE_TRUE_DIVIDE\n"); break;
- case RT_BINARY_OP_INPLACE_MODULO: printf("INPLACE_MODULO\n"); break;
- case RT_BINARY_OP_INPLACE_POWER: printf("INPLACE_POWER\n"); break;
- case RT_BINARY_OP_LESS: printf("COMPARE_OP <\n"); break;
- case RT_BINARY_OP_MORE: printf("COMPARE_OP >\n"); break;
- case RT_BINARY_OP_EQUAL: printf("COMPARE_OP ==\n"); break;
- case RT_BINARY_OP_LESS_EQUAL: printf("COMPARE_OP <=\n"); break;
- case RT_BINARY_OP_MORE_EQUAL: printf("COMPARE_OP >=\n"); break;
- case RT_BINARY_OP_NOT_EQUAL: printf("COMPARE_OP !=\n"); break;
- case RT_BINARY_OP_IN: printf("COMPARE_OP in\n"); break;
- case RT_BINARY_OP_IS: printf("COMPARE_OP is\n"); break;
- case RT_BINARY_OP_EXCEPTION_MATCH: printf("COMPARE_OP exception match\n"); break;
- case RT_BINARY_OP_NOT_IN: printf("COMPARE_OP not in\n"); break;
- case RT_BINARY_OP_IS_NOT: printf("COMPARE_OP is not\n"); break;
+ case MP_BINARY_OP_SUBSCR: printf("BINARY_SUBSCR\n"); break;
+ case MP_BINARY_OP_OR: printf("BINARY_OR\n"); break;
+ case MP_BINARY_OP_XOR: printf("BINARY_XOR\n"); break;
+ case MP_BINARY_OP_AND: printf("BINARY_AND\n"); break;
+ case MP_BINARY_OP_LSHIFT: printf("BINARY_LSHIFT\n"); break;
+ case MP_BINARY_OP_RSHIFT: printf("BINARY_RSHIFT\n"); break;
+ case MP_BINARY_OP_ADD: printf("BINARY_ADD\n"); break;
+ case MP_BINARY_OP_SUBTRACT: printf("BINARY_SUBTRACT\n"); break;
+ case MP_BINARY_OP_MULTIPLY: printf("BINARY_MULTIPLY\n"); break;
+ case MP_BINARY_OP_FLOOR_DIVIDE: printf("BINARY_FLOOR_DIVIDE\n"); break;
+ case MP_BINARY_OP_TRUE_DIVIDE: printf("BINARY_TRUE_DIVIDE\n"); break;
+ case MP_BINARY_OP_MODULO: printf("BINARY_MODULO\n"); break;
+ case MP_BINARY_OP_POWER: printf("BINARY_POWER\n"); break;
+ case MP_BINARY_OP_INPLACE_OR: printf("INPLACE_OR\n"); break;
+ case MP_BINARY_OP_INPLACE_XOR: printf("INPLACE_XOR\n"); break;
+ case MP_BINARY_OP_INPLACE_AND: printf("INPLACE_AND\n"); break;
+ case MP_BINARY_OP_INPLACE_LSHIFT: printf("INPLACE_LSHIFT\n"); break;
+ case MP_BINARY_OP_INPLACE_RSHIFT: printf("INPLACE_RSHIFT\n"); break;
+ case MP_BINARY_OP_INPLACE_ADD: printf("INPLACE_ADD\n"); break;
+ case MP_BINARY_OP_INPLACE_SUBTRACT: printf("INPLACE_SUBTRACT\n"); break;
+ case MP_BINARY_OP_INPLACE_MULTIPLY: printf("INPLACE_MULTIPLY\n"); break;
+ case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: printf("INPLACE_FLOOR_DIVIDE\n"); break;
+ case MP_BINARY_OP_INPLACE_TRUE_DIVIDE: printf("INPLACE_TRUE_DIVIDE\n"); break;
+ case MP_BINARY_OP_INPLACE_MODULO: printf("INPLACE_MODULO\n"); break;
+ case MP_BINARY_OP_INPLACE_POWER: printf("INPLACE_POWER\n"); break;
+ case MP_BINARY_OP_LESS: printf("COMPARE_OP <\n"); break;
+ case MP_BINARY_OP_MORE: printf("COMPARE_OP >\n"); break;
+ case MP_BINARY_OP_EQUAL: printf("COMPARE_OP ==\n"); break;
+ case MP_BINARY_OP_LESS_EQUAL: printf("COMPARE_OP <=\n"); break;
+ case MP_BINARY_OP_MORE_EQUAL: printf("COMPARE_OP >=\n"); break;
+ case MP_BINARY_OP_NOT_EQUAL: printf("COMPARE_OP !=\n"); break;
+ case MP_BINARY_OP_IN: printf("COMPARE_OP in\n"); break;
+ case MP_BINARY_OP_IS: printf("COMPARE_OP is\n"); break;
+ case MP_BINARY_OP_EXCEPTION_MATCH: printf("COMPARE_OP exception match\n"); break;
+ case MP_BINARY_OP_NOT_IN: printf("COMPARE_OP not in\n"); break;
+ case MP_BINARY_OP_IS_NOT: printf("COMPARE_OP is not\n"); break;
default: assert(0);
}
}
diff --git a/py/emitglue.c b/py/emitglue.c
index 47b1791eb7b59ca2dcb83695ab512795fe1b373f..73304de27ad99bfce27a5fd371d9c80ee34b842d 100644
--- a/py/emitglue.c
+++ b/py/emitglue.c
@@ -190,7 +190,7 @@ void mp_emit_glue_assign_inline_asm_code(uint unique_code_id, void *fun, uint le
#endif
}
-mp_obj_t rt_make_function_from_id(uint unique_code_id, bool free_unique_code, mp_obj_t def_args) {
+mp_obj_t mp_make_function_from_id(uint unique_code_id, bool free_unique_code, mp_obj_t def_args) {
DEBUG_OP_printf("make_function_from_id %d\n", unique_code_id);
if (unique_code_id >= unique_codes_total) {
// illegal code id
@@ -205,7 +205,7 @@ mp_obj_t rt_make_function_from_id(uint unique_code_id, bool free_unique_code, mp
fun = mp_obj_new_fun_bc(c->scope_flags, c->arg_names, c->n_args, def_args, c->u_byte.code);
break;
case MP_CODE_NATIVE:
- fun = rt_make_function_n(c->n_args, c->u_native.fun);
+ fun = mp_make_function_n(c->n_args, c->u_native.fun);
break;
case MP_CODE_INLINE_ASM:
fun = mp_obj_new_fun_asm(c->n_args, c->u_inline_asm.fun);
@@ -231,10 +231,10 @@ mp_obj_t rt_make_function_from_id(uint unique_code_id, bool free_unique_code, mp
return fun;
}
-mp_obj_t rt_make_closure_from_id(uint unique_code_id, mp_obj_t closure_tuple, mp_obj_t def_args) {
+mp_obj_t mp_make_closure_from_id(uint unique_code_id, mp_obj_t closure_tuple, mp_obj_t def_args) {
DEBUG_OP_printf("make_closure_from_id %d\n", unique_code_id);
// make function object
- mp_obj_t ffun = rt_make_function_from_id(unique_code_id, false, def_args);
+ mp_obj_t ffun = mp_make_function_from_id(unique_code_id, false, def_args);
// wrap function in closure object
return mp_obj_new_closure(ffun, closure_tuple);
}
diff --git a/py/emitnative.c b/py/emitnative.c
index da581155377551d235b425158468f175acb5f284..5e61c45b5c0be57460b5254b20693c8f9f9d0f3b 100644
--- a/py/emitnative.c
+++ b/py/emitnative.c
@@ -251,7 +251,7 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
}
}
- asm_thumb_mov_reg_i32(emit->as, REG_R7, (machine_uint_t)rt_fun_table);
+ asm_thumb_mov_reg_i32(emit->as, REG_R7, (machine_uint_t)mp_fun_table);
#endif
}
@@ -512,33 +512,33 @@ STATIC void emit_get_stack_pointer_to_reg_for_push(emit_t *emit, int reg_dest, i
adjust_stack(emit, n_push);
}
-STATIC void emit_call(emit_t *emit, rt_fun_kind_t fun_kind, void *fun) {
+STATIC void emit_call(emit_t *emit, mp_fun_kind_t fun_kind, void *fun) {
need_reg_all(emit);
#if N_X64
asm_x64_call_ind(emit->as, fun, REG_RAX);
#elif N_THUMB
- asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3);
+ asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
#endif
}
-STATIC void emit_call_with_imm_arg(emit_t *emit, rt_fun_kind_t fun_kind, void *fun, machine_int_t arg_val, int arg_reg) {
+STATIC void emit_call_with_imm_arg(emit_t *emit, mp_fun_kind_t fun_kind, void *fun, machine_int_t arg_val, int arg_reg) {
need_reg_all(emit);
ASM_MOV_IMM_TO_REG(arg_val, arg_reg);
#if N_X64
asm_x64_call_ind(emit->as, fun, REG_RAX);
#elif N_THUMB
- asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3);
+ asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
#endif
}
-STATIC void emit_call_with_2_imm_args(emit_t *emit, rt_fun_kind_t fun_kind, void *fun, machine_int_t arg_val1, int arg_reg1, machine_int_t arg_val2, int arg_reg2) {
+STATIC void emit_call_with_2_imm_args(emit_t *emit, mp_fun_kind_t fun_kind, void *fun, machine_int_t arg_val1, int arg_reg1, machine_int_t arg_val2, int arg_reg2) {
need_reg_all(emit);
ASM_MOV_IMM_TO_REG(arg_val1, arg_reg1);
ASM_MOV_IMM_TO_REG(arg_val2, arg_reg2);
#if N_X64
asm_x64_call_ind(emit->as, fun, REG_RAX);
#elif N_THUMB
- asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3);
+ asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
#endif
}
@@ -633,7 +633,7 @@ STATIC void emit_native_load_const_int(emit_t *emit, qstr qstr) {
STATIC void emit_native_load_const_dec(emit_t *emit, qstr qstr) {
// for viper, a float/complex is just a Python object
emit_native_pre(emit);
- emit_call_with_imm_arg(emit, RT_F_LOAD_CONST_DEC, rt_load_const_dec, qstr, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_DEC, mp_load_const_dec, qstr, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
@@ -642,7 +642,7 @@ STATIC void emit_native_load_const_id(emit_t *emit, qstr qstr) {
if (emit->do_viper_types) {
assert(0);
} else {
- emit_call_with_imm_arg(emit, RT_F_LOAD_CONST_STR, rt_load_const_str, qstr, REG_ARG_1); // TODO
+ emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_STR, mp_load_const_str, qstr, REG_ARG_1); // TODO
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
}
@@ -655,7 +655,7 @@ STATIC void emit_native_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
assert(0);
emit_post_push_imm(emit, VTYPE_PTR, (machine_uint_t)qstr_str(qstr));
} else {
- emit_call_with_imm_arg(emit, RT_F_LOAD_CONST_STR, rt_load_const_str, qstr, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_STR, mp_load_const_str, qstr, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
}
@@ -707,13 +707,13 @@ STATIC void emit_native_load_closure(emit_t *emit, qstr qstr, int local_num) {
STATIC void emit_native_load_name(emit_t *emit, qstr qstr) {
emit_native_pre(emit);
- emit_call_with_imm_arg(emit, RT_F_LOAD_NAME, rt_load_name, qstr, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_LOAD_NAME, mp_load_name, qstr, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
STATIC void emit_native_load_global(emit_t *emit, qstr qstr) {
emit_native_pre(emit);
- emit_call_with_imm_arg(emit, RT_F_LOAD_GLOBAL, rt_load_global, qstr, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_LOAD_GLOBAL, mp_load_global, qstr, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
@@ -721,11 +721,11 @@ STATIC void emit_native_load_attr(emit_t *emit, qstr qstr) {
// depends on type of subject:
// - integer, function, pointer to integers: error
// - pointer to structure: get member, quite easy
- // - Python object: call rt_load_attr, and needs to be typed to convert result
+ // - Python object: call mp_load_attr, and needs to be typed to convert result
vtype_kind_t vtype_base;
emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
assert(vtype_base == VTYPE_PYOBJ);
- emit_call_with_imm_arg(emit, RT_F_LOAD_ATTR, rt_load_attr, qstr, REG_ARG_2); // arg2 = attribute name
+ emit_call_with_imm_arg(emit, MP_F_LOAD_ATTR, mp_load_attr, qstr, REG_ARG_2); // arg2 = attribute name
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
@@ -734,12 +734,12 @@ STATIC void emit_native_load_method(emit_t *emit, qstr qstr) {
emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
assert(vtype_base == VTYPE_PYOBJ);
emit_get_stack_pointer_to_reg_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr
- emit_call_with_imm_arg(emit, RT_F_LOAD_METHOD, rt_load_method, qstr, REG_ARG_2); // arg2 = method name
+ emit_call_with_imm_arg(emit, MP_F_LOAD_METHOD, mp_load_method, qstr, REG_ARG_2); // arg2 = method name
}
STATIC void emit_native_load_build_class(emit_t *emit) {
emit_native_pre(emit);
- emit_call(emit, RT_F_LOAD_BUILD_CLASS, rt_load_build_class);
+ emit_call(emit, MP_F_LOAD_BUILD_CLASS, mp_load_build_class);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
@@ -783,11 +783,11 @@ STATIC void emit_native_store_deref(emit_t *emit, qstr qstr, int local_num) {
}
STATIC void emit_native_store_name(emit_t *emit, qstr qstr) {
- // rt_store_name, but needs conversion of object (maybe have rt_viper_store_name(obj, type))
+ // mp_store_name, but needs conversion of object (maybe have mp_viper_store_name(obj, type))
vtype_kind_t vtype;
emit_pre_pop_reg(emit, &vtype, REG_ARG_2);
assert(vtype == VTYPE_PYOBJ);
- emit_call_with_imm_arg(emit, RT_F_STORE_NAME, rt_store_name, qstr, REG_ARG_1); // arg1 = name
+ emit_call_with_imm_arg(emit, MP_F_STORE_NAME, mp_store_name, qstr, REG_ARG_1); // arg1 = name
emit_post(emit);
}
@@ -801,7 +801,7 @@ STATIC void emit_native_store_attr(emit_t *emit, qstr qstr) {
emit_pre_pop_reg_reg(emit, &vtype_base, REG_ARG_1, &vtype_val, REG_ARG_3); // arg1 = base, arg3 = value
assert(vtype_base == VTYPE_PYOBJ);
assert(vtype_val == VTYPE_PYOBJ);
- emit_call_with_imm_arg(emit, RT_F_STORE_ATTR, rt_store_attr, qstr, REG_ARG_2); // arg2 = attribute name
+ emit_call_with_imm_arg(emit, MP_F_STORE_ATTR, mp_store_attr, qstr, REG_ARG_2); // arg2 = attribute name
emit_post(emit);
}
@@ -815,7 +815,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
assert(vtype_index == VTYPE_PYOBJ);
assert(vtype_base == VTYPE_PYOBJ);
assert(vtype_value == VTYPE_PYOBJ);
- emit_call(emit, RT_F_STORE_SUBSCR, rt_store_subscr);
+ emit_call(emit, MP_F_STORE_SUBSCR, mp_store_subscr);
}
STATIC void emit_native_store_locals(emit_t *emit) {
@@ -838,13 +838,13 @@ STATIC void emit_native_delete_deref(emit_t *emit, qstr qstr, int local_num) {
STATIC void emit_native_delete_name(emit_t *emit, qstr qstr) {
// not implemented
- // use rt_delete_name
+ // use mp_delete_name
assert(0);
}
STATIC void emit_native_delete_global(emit_t *emit, qstr qstr) {
// not implemented
- // use rt_delete_global
+ // use mp_delete_global
assert(0);
}
@@ -904,7 +904,7 @@ STATIC void emit_native_pop_jump_pre_helper(emit_t *emit, int label) {
emit_pre_pop_reg(emit, &vtype, REG_RET);
} else if (vtype == VTYPE_PYOBJ) {
emit_pre_pop_reg(emit, &vtype, REG_ARG_1);
- emit_call(emit, RT_F_IS_TRUE, rt_is_true);
+ emit_call(emit, MP_F_OBJ_IS_TRUE, mp_obj_is_true);
} else {
printf("ViperTypeError: expecting a bool or pyobj, got %d\n", vtype);
assert(0);
@@ -977,7 +977,7 @@ STATIC void emit_native_get_iter(emit_t *emit) {
vtype_kind_t vtype;
emit_pre_pop_reg(emit, &vtype, REG_ARG_1);
assert(vtype == VTYPE_PYOBJ);
- emit_call(emit, RT_F_GETITER, rt_getiter);
+ emit_call(emit, MP_F_GETITER, mp_getiter);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
@@ -986,7 +986,7 @@ STATIC void emit_native_for_iter(emit_t *emit, int label) {
vtype_kind_t vtype;
emit_access_stack(emit, 1, &vtype, REG_ARG_1);
assert(vtype == VTYPE_PYOBJ);
- emit_call(emit, RT_F_ITERNEXT, rt_iternext);
+ emit_call(emit, MP_F_ITERNEXT, mp_iternext);
ASM_MOV_IMM_TO_REG((machine_uint_t)MP_OBJ_NULL, REG_TEMP1);
#if N_X64
asm_x64_cmp_r64_with_r64(emit->as, REG_RET, REG_TEMP1);
@@ -1014,26 +1014,26 @@ STATIC void emit_native_pop_except(emit_t *emit) {
assert(0);
}
-STATIC void emit_native_unary_op(emit_t *emit, rt_unary_op_t op) {
+STATIC void emit_native_unary_op(emit_t *emit, mp_unary_op_t op) {
vtype_kind_t vtype;
emit_pre_pop_reg(emit, &vtype, REG_ARG_2);
assert(vtype == VTYPE_PYOBJ);
- emit_call_with_imm_arg(emit, RT_F_UNARY_OP, rt_unary_op, op, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_UNARY_OP, mp_unary_op, op, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
-STATIC void emit_native_binary_op(emit_t *emit, rt_binary_op_t op) {
+STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
vtype_kind_t vtype_lhs, vtype_rhs;
emit_pre_pop_reg_reg(emit, &vtype_rhs, REG_ARG_3, &vtype_lhs, REG_ARG_2);
if (vtype_lhs == VTYPE_INT && vtype_rhs == VTYPE_INT) {
- if (op == RT_BINARY_OP_ADD || op == RT_BINARY_OP_INPLACE_ADD) {
+ if (op == MP_BINARY_OP_ADD || op == MP_BINARY_OP_INPLACE_ADD) {
#if N_X64
asm_x64_add_r64_to_r64(emit->as, REG_ARG_3, REG_ARG_2);
#elif N_THUMB
asm_thumb_add_reg_reg_reg(emit->as, REG_ARG_2, REG_ARG_2, REG_ARG_3);
#endif
emit_post_push_reg(emit, VTYPE_INT, REG_ARG_2);
- } else if (op == RT_BINARY_OP_LESS) {
+ } else if (op == MP_BINARY_OP_LESS) {
#if N_X64
asm_x64_xor_r64_to_r64(emit->as, REG_RET, REG_RET);
asm_x64_cmp_r64_with_r64(emit->as, REG_ARG_3, REG_ARG_2);
@@ -1050,7 +1050,7 @@ STATIC void emit_native_binary_op(emit_t *emit, rt_binary_op_t op) {
assert(0);
}
} else if (vtype_lhs == VTYPE_PYOBJ && vtype_rhs == VTYPE_PYOBJ) {
- emit_call_with_imm_arg(emit, RT_F_BINARY_OP, rt_binary_op, op, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_BINARY_OP, mp_binary_op, op, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
} else {
printf("ViperTypeError: can't do binary op between types %d and %d\n", vtype_lhs, vtype_rhs);
@@ -1063,14 +1063,14 @@ STATIC void emit_native_build_tuple(emit_t *emit, int n_args) {
// if wrapped in byte_array, or something, allocates memory and fills it
emit_native_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items
- emit_call_with_imm_arg(emit, RT_F_BUILD_TUPLE, rt_build_tuple, n_args, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_BUILD_TUPLE, mp_build_tuple, n_args, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new tuple
}
STATIC void emit_native_build_list(emit_t *emit, int n_args) {
emit_native_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items
- emit_call_with_imm_arg(emit, RT_F_BUILD_LIST, rt_build_list, n_args, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_BUILD_LIST, mp_build_list, n_args, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new list
}
@@ -1081,13 +1081,13 @@ STATIC void emit_native_list_append(emit_t *emit, int list_index) {
emit_access_stack(emit, list_index, &vtype_list, REG_ARG_1);
assert(vtype_list == VTYPE_PYOBJ);
assert(vtype_item == VTYPE_PYOBJ);
- emit_call(emit, RT_F_LIST_APPEND, rt_list_append);
+ emit_call(emit, MP_F_LIST_APPEND, mp_list_append);
emit_post(emit);
}
STATIC void emit_native_build_map(emit_t *emit, int n_args) {
emit_native_pre(emit);
- emit_call_with_imm_arg(emit, RT_F_BUILD_MAP, rt_build_map, n_args, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_BUILD_MAP, mp_build_map, n_args, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new map
}
@@ -1097,7 +1097,7 @@ STATIC void emit_native_store_map(emit_t *emit) {
assert(vtype_key == VTYPE_PYOBJ);
assert(vtype_value == VTYPE_PYOBJ);
assert(vtype_map == VTYPE_PYOBJ);
- emit_call(emit, RT_F_STORE_MAP, rt_store_map);
+ emit_call(emit, MP_F_STORE_MAP, mp_store_map);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // map
}
@@ -1109,14 +1109,14 @@ STATIC void emit_native_map_add(emit_t *emit, int map_index) {
assert(vtype_map == VTYPE_PYOBJ);
assert(vtype_key == VTYPE_PYOBJ);
assert(vtype_value == VTYPE_PYOBJ);
- emit_call(emit, RT_F_STORE_MAP, rt_store_map);
+ emit_call(emit, MP_F_STORE_MAP, mp_store_map);
emit_post(emit);
}
STATIC void emit_native_build_set(emit_t *emit, int n_args) {
emit_native_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items
- emit_call_with_imm_arg(emit, RT_F_BUILD_SET, rt_build_set, n_args, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_BUILD_SET, mp_build_set, n_args, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new set
}
@@ -1127,7 +1127,7 @@ STATIC void emit_native_set_add(emit_t *emit, int set_index) {
emit_access_stack(emit, set_index, &vtype_set, REG_ARG_1);
assert(vtype_set == VTYPE_PYOBJ);
assert(vtype_item == VTYPE_PYOBJ);
- emit_call(emit, RT_F_STORE_SET, rt_store_set);
+ emit_call(emit, MP_F_STORE_SET, mp_store_set);
emit_post(emit);
}
@@ -1146,7 +1146,7 @@ STATIC void emit_native_make_function(emit_t *emit, scope_t *scope, int n_dict_p
// call runtime, with type info for args, or don't support dict/default params, or only support Python objects for them
assert(n_default_params == 0 && n_dict_params == 0);
emit_native_pre(emit);
- emit_call_with_imm_arg(emit, RT_F_MAKE_FUNCTION_FROM_ID, rt_make_function_from_id, scope->unique_code_id, REG_ARG_1);
+ emit_call_with_imm_arg(emit, MP_F_MAKE_FUNCTION_FROM_ID, mp_make_function_from_id, scope->unique_code_id, REG_ARG_1);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
@@ -1165,20 +1165,20 @@ STATIC void emit_native_call_function(emit_t *emit, int n_positional, int n_keyw
vtype_kind_t vtype_fun;
emit_pre_pop_reg(emit, &vtype_fun, REG_ARG_1); // the function
assert(vtype_fun == VTYPE_PYOBJ);
- emit_call(emit, RT_F_CALL_FUNCTION_0, rt_call_function_0);
+ emit_call(emit, MP_F_CALL_FUNCTION_0, mp_call_function_0);
} else if (n_positional == 1) {
vtype_kind_t vtype_fun, vtype_arg1;
emit_pre_pop_reg_reg(emit, &vtype_arg1, REG_ARG_2, &vtype_fun, REG_ARG_1); // the single argument, the function
assert(vtype_fun == VTYPE_PYOBJ);
assert(vtype_arg1 == VTYPE_PYOBJ);
- emit_call(emit, RT_F_CALL_FUNCTION_1, rt_call_function_1);
+ emit_call(emit, MP_F_CALL_FUNCTION_1, mp_call_function_1);
} else if (n_positional == 2) {
vtype_kind_t vtype_fun, vtype_arg1, vtype_arg2;
emit_pre_pop_reg_reg_reg(emit, &vtype_arg2, REG_ARG_3, &vtype_arg1, REG_ARG_2, &vtype_fun, REG_ARG_1); // the second argument, the first argument, the function
assert(vtype_fun == VTYPE_PYOBJ);
assert(vtype_arg1 == VTYPE_PYOBJ);
assert(vtype_arg2 == VTYPE_PYOBJ);
- emit_call(emit, RT_F_CALL_FUNCTION_2, rt_call_function_2);
+ emit_call(emit, MP_F_CALL_FUNCTION_2, mp_call_function_2);
} else {
*/
@@ -1189,7 +1189,7 @@ STATIC void emit_native_call_function(emit_t *emit, int n_positional, int n_keyw
vtype_kind_t vtype_fun;
emit_pre_pop_reg(emit, &vtype_fun, REG_ARG_1); // the function
assert(vtype_fun == VTYPE_PYOBJ);
- emit_call_with_imm_arg(emit, RT_F_CALL_FUNCTION_N_KW_FOR_NATIVE, rt_call_function_n_kw_for_native, n_positional, REG_ARG_2);
+ emit_call_with_imm_arg(emit, MP_F_CALL_FUNCTION_N_KW_FOR_NATIVE, mp_call_function_n_kw_for_native, n_positional, REG_ARG_2);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
@@ -1202,20 +1202,20 @@ STATIC void emit_native_call_method(emit_t *emit, int n_positional, int n_keywor
emit_pre_pop_reg_reg(emit, &vtype_self, REG_ARG_2, &vtype_meth, REG_ARG_1); // the self object (or NULL), the method
assert(vtype_meth == VTYPE_PYOBJ);
assert(vtype_self == VTYPE_PYOBJ);
- emit_call(emit, RT_F_CALL_METHOD_1, rt_call_method_1);
+ emit_call(emit, MP_F_CALL_METHOD_1, mp_call_method_1);
} else if (n_positional == 1) {
vtype_kind_t vtype_meth, vtype_self, vtype_arg1;
emit_pre_pop_reg_reg_reg(emit, &vtype_arg1, REG_ARG_3, &vtype_self, REG_ARG_2, &vtype_meth, REG_ARG_1); // the first argument, the self object (or NULL), the method
assert(vtype_meth == VTYPE_PYOBJ);
assert(vtype_self == VTYPE_PYOBJ);
assert(vtype_arg1 == VTYPE_PYOBJ);
- emit_call(emit, RT_F_CALL_METHOD_2, rt_call_method_2);
+ emit_call(emit, MP_F_CALL_METHOD_2, mp_call_method_2);
} else {
*/
emit_native_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_3, n_positional + 2); // pointer to items, including meth and self
- emit_call_with_2_imm_args(emit, RT_F_CALL_METHOD_N_KW, rt_call_method_n_kw, n_positional, REG_ARG_1, n_keyword, REG_ARG_2);
+ emit_call_with_2_imm_args(emit, MP_F_CALL_METHOD_N_KW, mp_call_method_n_kw, n_positional, REG_ARG_1, n_keyword, REG_ARG_2);
emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}
diff --git a/py/obj.c b/py/obj.c
index 109676b879db50392397ddb75dc5c7b6682b1787..d6fa3743067c2cdadc8c78790ed932dcb1a14d73 100644
--- a/py/obj.c
+++ b/py/obj.c
@@ -67,6 +67,39 @@ void mp_obj_print_exception(mp_obj_t exc) {
printf("\n");
}
+int mp_obj_is_true(mp_obj_t arg) {
+ if (arg == mp_const_false) {
+ return 0;
+ } else if (arg == mp_const_true) {
+ return 1;
+ } else if (arg == mp_const_none) {
+ return 0;
+ } else if (MP_OBJ_IS_SMALL_INT(arg)) {
+ if (MP_OBJ_SMALL_INT_VALUE(arg) == 0) {
+ return 0;
+ } else {
+ return 1;
+ }
+ } else {
+ mp_obj_type_t *type = mp_obj_get_type(arg);
+ if (type->unary_op != NULL) {
+ mp_obj_t result = type->unary_op(MP_UNARY_OP_BOOL, arg);
+ if (result != MP_OBJ_NULL) {
+ return result == mp_const_true;
+ }
+ }
+
+ mp_obj_t len = mp_obj_len_maybe(arg);
+ if (len != MP_OBJ_NULL) {
+ // obj has a length, truth determined if len != 0
+ return len != MP_OBJ_NEW_SMALL_INT(0);
+ } else {
+ // any other obj is true per Python semantics
+ return 1;
+ }
+ }
+}
+
bool mp_obj_is_callable(mp_obj_t o_in) {
return mp_obj_get_type(o_in)->call != NULL;
}
@@ -121,7 +154,7 @@ bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2) {
// If o2 is long int, dispatch to its virtual methods
mp_obj_base_t *o = o2;
if (o->type->binary_op != NULL) {
- mp_obj_t r = o->type->binary_op(RT_BINARY_OP_EQUAL, o2, o1);
+ mp_obj_t r = o->type->binary_op(MP_BINARY_OP_EQUAL, o2, o1);
return r == mp_const_true ? true : false;
}
}
@@ -132,7 +165,7 @@ bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2) {
} else {
mp_obj_base_t *o = o1;
if (o->type->binary_op != NULL) {
- mp_obj_t r = o->type->binary_op(RT_BINARY_OP_EQUAL, o1, o2);
+ mp_obj_t r = o->type->binary_op(MP_BINARY_OP_EQUAL, o1, o2);
if (r != MP_OBJ_NULL) {
return r == mp_const_true ? true : false;
}
@@ -271,7 +304,7 @@ mp_obj_t mp_obj_len_maybe(mp_obj_t o_in) {
} else {
mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->unary_op != NULL) {
- return type->unary_op(RT_UNARY_OP_LEN, o_in);
+ return type->unary_op(MP_UNARY_OP_LEN, o_in);
} else {
return MP_OBJ_NULL;
}
diff --git a/py/obj.h b/py/obj.h
index a8cde462a993e1b0c9f8970469d1e43bdeff81e8..6e334e1c882958c41abaa2b6d08881a0ebdb6a86 100644
--- a/py/obj.h
+++ b/py/obj.h
@@ -308,6 +308,7 @@ void mp_obj_print_helper(void (*print)(void *env, const char *fmt, ...), void *e
void mp_obj_print(mp_obj_t o, mp_print_kind_t kind);
void mp_obj_print_exception(mp_obj_t exc);
+int mp_obj_is_true(mp_obj_t arg);
bool mp_obj_is_callable(mp_obj_t o_in);
machine_int_t mp_obj_hash(mp_obj_t o_in);
bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2);
diff --git a/py/objarray.c b/py/objarray.c
index eed21d9463b37d19fd5b60cd6ea31bc77b457366..3251ce969ba55774e6a819ab516fba428a660299 100644
--- a/py/objarray.c
+++ b/py/objarray.c
@@ -61,10 +61,10 @@ STATIC mp_obj_t array_construct(char typecode, mp_obj_t initializer) {
mp_obj_array_t *array = array_new(typecode, len);
- mp_obj_t iterable = rt_getiter(initializer);
+ mp_obj_t iterable = mp_getiter(initializer);
mp_obj_t item;
int i = 0;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (len == 0) {
array_append(array, item);
} else {
@@ -99,8 +99,8 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_bytearray_obj, mp_builtin_bytearray);
STATIC mp_obj_t array_unary_op(int op, mp_obj_t o_in) {
mp_obj_array_t *o = o_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(o->len != 0);
- case RT_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(o->len);
+ case MP_UNARY_OP_BOOL: return MP_BOOL(o->len != 0);
+ case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(o->len);
default: return MP_OBJ_NULL; // op not supported
}
}
@@ -108,7 +108,7 @@ STATIC mp_obj_t array_unary_op(int op, mp_obj_t o_in) {
STATIC mp_obj_t array_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_array_t *o = lhs;
switch (op) {
- case RT_BINARY_OP_SUBSCR:
+ case MP_BINARY_OP_SUBSCR:
{
uint index = mp_get_index(o->base.type, o->len, rhs, false);
return mp_binary_get_val(o->typecode, o->items, index);
diff --git a/py/objbool.c b/py/objbool.c
index 5f17fd61334e83969489e99b3c2bb49be8d1b88b..6afb6e950dad7e570b5a80acd88ccfd598da080c 100644
--- a/py/objbool.c
+++ b/py/objbool.c
@@ -26,7 +26,7 @@ STATIC mp_obj_t bool_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp
switch (n_args) {
case 0: return mp_const_false;
- case 1: if (rt_is_true(args[0])) { return mp_const_true; } else { return mp_const_false; }
+ case 1: if (mp_obj_is_true(args[0])) { return mp_const_true; } else { return mp_const_false; }
default: nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "bool takes at most 1 argument, %d given", n_args));
}
}
@@ -34,10 +34,10 @@ STATIC mp_obj_t bool_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp
STATIC mp_obj_t bool_unary_op(int op, mp_obj_t o_in) {
machine_int_t value = ((mp_obj_bool_t*)o_in)->value;
switch (op) {
- case RT_UNARY_OP_BOOL: return o_in;
- case RT_UNARY_OP_POSITIVE: return MP_OBJ_NEW_SMALL_INT(value);
- case RT_UNARY_OP_NEGATIVE: return MP_OBJ_NEW_SMALL_INT(-value);
- case RT_UNARY_OP_INVERT:
+ case MP_UNARY_OP_BOOL: return o_in;
+ case MP_UNARY_OP_POSITIVE: return MP_OBJ_NEW_SMALL_INT(value);
+ case MP_UNARY_OP_NEGATIVE: return MP_OBJ_NEW_SMALL_INT(-value);
+ case MP_UNARY_OP_INVERT:
default: // no other cases
return MP_OBJ_NEW_SMALL_INT(~value);
}
diff --git a/py/objboundmeth.c b/py/objboundmeth.c
index 1b9ac61f24a0b5a3fff24117c37a112946c33417..55b75e42cd5d7f6f1995b19eaef1d2f9599ef78d 100644
--- a/py/objboundmeth.c
+++ b/py/objboundmeth.c
@@ -24,13 +24,13 @@ mp_obj_t bound_meth_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_
mp_obj_t args2[5];
args2[0] = self->self;
memcpy(args2 + 1, args, n_total * sizeof(mp_obj_t));
- return rt_call_function_n_kw(self->meth, n_args + 1, n_kw, &args2[0]);
+ return mp_call_function_n_kw(self->meth, n_args + 1, n_kw, &args2[0]);
} else {
// use heap to allocate temporary args array
mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_total);
args2[0] = self->self;
memcpy(args2 + 1, args, n_total * sizeof(mp_obj_t));
- mp_obj_t res = rt_call_function_n_kw(self->meth, n_args + 1, n_kw, &args2[0]);
+ mp_obj_t res = mp_call_function_n_kw(self->meth, n_args + 1, n_kw, &args2[0]);
m_del(mp_obj_t, args2, 1 + n_total);
return res;
}
diff --git a/py/objclosure.c b/py/objclosure.c
index cd8129e24f996c1c57541716c7c0833e67214097..9b4a3f893326640aad24a6ced54b362aa7b56ba3 100644
--- a/py/objclosure.c
+++ b/py/objclosure.c
@@ -25,13 +25,13 @@ mp_obj_t closure_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *
mp_obj_t args2[5];
memcpy(args2, self->closed, self->n_closed * sizeof(mp_obj_t));
memcpy(args2 + self->n_closed, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
- return rt_call_function_n_kw(self->fun, self->n_closed + n_args, n_kw, args2);
+ return mp_call_function_n_kw(self->fun, self->n_closed + n_args, n_kw, args2);
} else {
// use heap to allocate temporary args array
mp_obj_t *args2 = m_new(mp_obj_t, n_total);
memcpy(args2, self->closed, self->n_closed * sizeof(mp_obj_t));
memcpy(args2 + self->n_closed, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
- mp_obj_t res = rt_call_function_n_kw(self->fun, self->n_closed + n_args, n_kw, args2);
+ mp_obj_t res = mp_call_function_n_kw(self->fun, self->n_closed + n_args, n_kw, args2);
m_del(mp_obj_t, args2, n_total);
return res;
}
diff --git a/py/objcomplex.c b/py/objcomplex.c
index c2b9d4910467da3f8d1ec0a004ec72acb587b38f..afda721cfc5284179eff61255a84875b680273ac 100644
--- a/py/objcomplex.c
+++ b/py/objcomplex.c
@@ -94,9 +94,9 @@ STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const
STATIC mp_obj_t complex_unary_op(int op, mp_obj_t o_in) {
mp_obj_complex_t *o = o_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(o->real != 0 || o->imag != 0);
- case RT_UNARY_OP_POSITIVE: return o_in;
- case RT_UNARY_OP_NEGATIVE: return mp_obj_new_complex(-o->real, -o->imag);
+ case MP_UNARY_OP_BOOL: return MP_BOOL(o->real != 0 || o->imag != 0);
+ case MP_UNARY_OP_POSITIVE: return o_in;
+ case MP_UNARY_OP_NEGATIVE: return mp_obj_new_complex(-o->real, -o->imag);
default: return MP_OBJ_NULL; // op not supported
}
}
@@ -134,18 +134,18 @@ mp_obj_t mp_obj_complex_binary_op(int op, mp_float_t lhs_real, mp_float_t lhs_im
mp_float_t rhs_real, rhs_imag;
mp_obj_get_complex(rhs_in, &rhs_real, &rhs_imag); // can be any type, this function will convert to float (if possible)
switch (op) {
- case RT_BINARY_OP_ADD:
- case RT_BINARY_OP_INPLACE_ADD:
+ case MP_BINARY_OP_ADD:
+ case MP_BINARY_OP_INPLACE_ADD:
lhs_real += rhs_real;
lhs_imag += rhs_imag;
break;
- case RT_BINARY_OP_SUBTRACT:
- case RT_BINARY_OP_INPLACE_SUBTRACT:
+ case MP_BINARY_OP_SUBTRACT:
+ case MP_BINARY_OP_INPLACE_SUBTRACT:
lhs_real -= rhs_real;
lhs_imag -= rhs_imag;
break;
- case RT_BINARY_OP_MULTIPLY:
- case RT_BINARY_OP_INPLACE_MULTIPLY:
+ case MP_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_INPLACE_MULTIPLY:
{
mp_float_t real = lhs_real * rhs_real - lhs_imag * rhs_imag;
lhs_imag = lhs_real * rhs_imag + lhs_imag * rhs_real;
@@ -153,12 +153,12 @@ mp_obj_t mp_obj_complex_binary_op(int op, mp_float_t lhs_real, mp_float_t lhs_im
break;
}
/* TODO floor(?) the value
- case RT_BINARY_OP_FLOOR_DIVIDE:
- case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break;
+ case MP_BINARY_OP_FLOOR_DIVIDE:
+ case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break;
*/
/* TODO
- case RT_BINARY_OP_TRUE_DIVIDE:
- case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: val = lhs_val / rhs_val; break;
+ case MP_BINARY_OP_TRUE_DIVIDE:
+ case MP_BINARY_OP_INPLACE_TRUE_DIVIDE: val = lhs_val / rhs_val; break;
*/
return NULL; // op not supported
}
diff --git a/py/objdict.c b/py/objdict.c
index 6a1e8e08a39c1b94fe2282874d9b4363d3365b2c..cb8e9d3e65f454e2ce4ab36f175427e7a2552bb1 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -34,14 +34,14 @@ STATIC void dict_print(void (*print)(void *env, const char *fmt, ...), void *env
STATIC mp_obj_t dict_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// TODO create from an iterable!
- return rt_build_map(0);
+ return mp_build_map(0);
}
STATIC mp_obj_t dict_unary_op(int op, mp_obj_t self_in) {
mp_obj_dict_t *self = self_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(self->map.used != 0);
- case RT_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT((machine_int_t)self->map.used);
+ case MP_UNARY_OP_BOOL: return MP_BOOL(self->map.used != 0);
+ case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT((machine_int_t)self->map.used);
default: return MP_OBJ_NULL; // op not supported for None
}
}
@@ -49,7 +49,7 @@ STATIC mp_obj_t dict_unary_op(int op, mp_obj_t self_in) {
STATIC mp_obj_t dict_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
mp_obj_dict_t *o = lhs_in;
switch (op) {
- case RT_BINARY_OP_SUBSCR:
+ case MP_BINARY_OP_SUBSCR:
{
// dict load
mp_map_elem_t *elem = mp_map_lookup(&o->map, rhs_in, MP_MAP_LOOKUP);
@@ -59,7 +59,7 @@ STATIC mp_obj_t dict_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
return elem->value;
}
}
- case RT_BINARY_OP_IN:
+ case MP_BINARY_OP_IN:
{
mp_map_elem_t *elem = mp_map_lookup(&o->map, rhs_in, MP_MAP_LOOKUP);
return MP_BOOL(elem != NULL);
@@ -149,7 +149,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(dict_copy_obj, dict_copy);
// this is a classmethod
STATIC mp_obj_t dict_fromkeys(uint n_args, const mp_obj_t *args) {
assert(2 <= n_args && n_args <= 3);
- mp_obj_t iter = rt_getiter(args[1]);
+ mp_obj_t iter = mp_getiter(args[1]);
mp_obj_t len = mp_obj_len_maybe(iter);
mp_obj_t value = mp_const_none;
mp_obj_t next = NULL;
@@ -166,7 +166,7 @@ STATIC mp_obj_t dict_fromkeys(uint n_args, const mp_obj_t *args) {
self = mp_obj_new_dict(MP_OBJ_SMALL_INT_VALUE(len));
}
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
mp_map_lookup(&self->map, next, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
}
@@ -259,13 +259,13 @@ STATIC mp_obj_t dict_update(mp_obj_t self_in, mp_obj_t iterable) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_dict));
mp_obj_dict_t *self = self_in;
/* TODO: check for the "keys" method */
- mp_obj_t iter = rt_getiter(iterable);
+ mp_obj_t iter = mp_getiter(iterable);
mp_obj_t next = NULL;
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
- mp_obj_t inneriter = rt_getiter(next);
- mp_obj_t key = rt_iternext(inneriter);
- mp_obj_t value = rt_iternext(inneriter);
- mp_obj_t stop = rt_iternext(inneriter);
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
+ mp_obj_t inneriter = mp_getiter(next);
+ mp_obj_t key = mp_iternext(inneriter);
+ mp_obj_t value = mp_iternext(inneriter);
+ mp_obj_t stop = mp_iternext(inneriter);
if (key == MP_OBJ_NULL
|| value == MP_OBJ_NULL
|| stop != MP_OBJ_NULL) {
@@ -372,7 +372,7 @@ STATIC mp_obj_t dict_view_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
/* only supported for the 'keys' kind until sets and dicts are refactored */
mp_obj_dict_view_t *o = lhs_in;
if (o->kind != MP_DICT_VIEW_KEYS) return NULL;
- if (op != RT_BINARY_OP_IN) return NULL;
+ if (op != MP_BINARY_OP_IN) return NULL;
return dict_binary_op(op, o->dict, rhs_in);
}
diff --git a/py/objenumerate.c b/py/objenumerate.c
index aaeb254e82486db86e6667a4120f763d72852953..23a3f7036ab9a9944062fab6efcb765c99e003ed 100644
--- a/py/objenumerate.c
+++ b/py/objenumerate.c
@@ -21,7 +21,7 @@ STATIC mp_obj_t enumerate_make_new(mp_obj_t type_in, uint n_args, uint n_kw, con
assert(n_args > 0);
mp_obj_enumerate_t *o = m_new_obj(mp_obj_enumerate_t);
o->base.type = &mp_type_enumerate;
- o->iter = rt_getiter(args[0]);
+ o->iter = mp_getiter(args[0]);
o->cur = n_args > 1 ? mp_obj_get_int(args[1]) : 0;
return o;
}
@@ -37,7 +37,7 @@ const mp_obj_type_t mp_type_enumerate = {
STATIC mp_obj_t enumerate_iternext(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_enumerate));
mp_obj_enumerate_t *self = self_in;
- mp_obj_t next = rt_iternext(self->iter);
+ mp_obj_t next = mp_iternext(self->iter);
if (next == MP_OBJ_NULL) {
return MP_OBJ_NULL;
} else {
diff --git a/py/objexcept.c b/py/objexcept.c
index afcaa1c6d8fd0a2ef6f6f57efd1350b5c0848f2b..7dd5c7ac39e8659c340bfa4d7252ffe85383af7e 100644
--- a/py/objexcept.c
+++ b/py/objexcept.c
@@ -244,7 +244,7 @@ bool mp_obj_is_exception_instance(mp_obj_t self_in) {
// exception type.
bool mp_obj_exception_match(mp_obj_t exc, const mp_obj_type_t *exc_type) {
// TODO: move implementation from RT_BINARY_OP_EXCEPTION_MATCH here.
- return rt_binary_op(RT_BINARY_OP_EXCEPTION_MATCH, exc, (mp_obj_t)exc_type) == mp_const_true;
+ return mp_binary_op(MP_BINARY_OP_EXCEPTION_MATCH, exc, (mp_obj_t)exc_type) == mp_const_true;
}
void mp_obj_exception_clear_traceback(mp_obj_t self_in) {
diff --git a/py/objfilter.c b/py/objfilter.c
index 7780940a46cf809857545351722db45c75410a66..466c982206ad7223f94e3c04eebe0e3dabef6f7c 100644
--- a/py/objfilter.c
+++ b/py/objfilter.c
@@ -22,7 +22,7 @@ STATIC mp_obj_t filter_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const
mp_obj_filter_t *o = m_new_obj(mp_obj_filter_t);
o->base.type = &mp_type_filter;
o->fun = args[0];
- o->iter = rt_getiter(args[1]);
+ o->iter = mp_getiter(args[1]);
return o;
}
@@ -30,14 +30,14 @@ STATIC mp_obj_t filter_iternext(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_filter));
mp_obj_filter_t *self = self_in;
mp_obj_t next;
- while ((next = rt_iternext(self->iter)) != MP_OBJ_NULL) {
+ while ((next = mp_iternext(self->iter)) != MP_OBJ_NULL) {
mp_obj_t val;
if (self->fun != mp_const_none) {
- val = rt_call_function_n_kw(self->fun, 1, 0, &next);
+ val = mp_call_function_n_kw(self->fun, 1, 0, &next);
} else {
val = next;
}
- if (rt_is_true(val)) {
+ if (mp_obj_is_true(val)) {
return next;
}
}
diff --git a/py/objfloat.c b/py/objfloat.c
index c4567c4a38d16cfee079f8595b8d2d397203c16d..babc0c479b0adf833c364a363d1e1c61cce4586c 100644
--- a/py/objfloat.c
+++ b/py/objfloat.c
@@ -56,9 +56,9 @@ STATIC mp_obj_t float_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const m
STATIC mp_obj_t float_unary_op(int op, mp_obj_t o_in) {
mp_obj_float_t *o = o_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(o->value != 0);
- case RT_UNARY_OP_POSITIVE: return o_in;
- case RT_UNARY_OP_NEGATIVE: return mp_obj_new_float(-o->value);
+ case MP_UNARY_OP_BOOL: return MP_BOOL(o->value != 0);
+ case MP_UNARY_OP_POSITIVE: return o_in;
+ case MP_UNARY_OP_NEGATIVE: return mp_obj_new_float(-o->value);
default: return NULL; // op not supported
}
}
@@ -97,27 +97,27 @@ mp_float_t mp_obj_float_get(mp_obj_t self_in) {
mp_obj_t mp_obj_float_binary_op(int op, mp_float_t lhs_val, mp_obj_t rhs_in) {
mp_float_t rhs_val = mp_obj_get_float(rhs_in); // can be any type, this function will convert to float (if possible)
switch (op) {
- case RT_BINARY_OP_ADD:
- case RT_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
- case RT_BINARY_OP_SUBTRACT:
- case RT_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
- case RT_BINARY_OP_MULTIPLY:
- case RT_BINARY_OP_INPLACE_MULTIPLY: lhs_val *= rhs_val; break;
+ case MP_BINARY_OP_ADD:
+ case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
+ case MP_BINARY_OP_SUBTRACT:
+ case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
+ case MP_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_INPLACE_MULTIPLY: lhs_val *= rhs_val; break;
/* TODO floor(?) the value
- case RT_BINARY_OP_FLOOR_DIVIDE:
- case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break;
+ case MP_BINARY_OP_FLOOR_DIVIDE:
+ case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break;
*/
- case RT_BINARY_OP_TRUE_DIVIDE:
- case RT_BINARY_OP_INPLACE_TRUE_DIVIDE:
+ case MP_BINARY_OP_TRUE_DIVIDE:
+ case MP_BINARY_OP_INPLACE_TRUE_DIVIDE:
lhs_val /= rhs_val;
if (isinf(lhs_val)){ // check for division by zero
nlr_jump(mp_obj_new_exception_msg(&mp_type_ZeroDivisionError, "float division by zero"));
}
break;
- case RT_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val);
- case RT_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val);
- case RT_BINARY_OP_LESS_EQUAL: return MP_BOOL(lhs_val <= rhs_val);
- case RT_BINARY_OP_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val);
+ case MP_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val);
+ case MP_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val);
+ case MP_BINARY_OP_LESS_EQUAL: return MP_BOOL(lhs_val <= rhs_val);
+ case MP_BINARY_OP_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val);
return NULL; // op not supported
}
diff --git a/py/objfun.c b/py/objfun.c
index 2a497a66694a7784a800473aabcf765ed227ac38..d4fa7592f76d7ecafca381833d09f6312f9ab3c2 100644
--- a/py/objfun.c
+++ b/py/objfun.c
@@ -26,10 +26,10 @@
// mp_obj_fun_native_t defined in obj.h
STATIC void check_nargs(mp_obj_fun_native_t *self, int n_args, int n_kw) {
- rt_check_nargs(n_args, self->n_args_min, self->n_args_max, n_kw, self->is_kw);
+ mp_check_nargs(n_args, self->n_args_min, self->n_args_max, n_kw, self->is_kw);
}
-void rt_check_nargs(int n_args, machine_uint_t n_args_min, machine_uint_t n_args_max, int n_kw, bool is_kw) {
+void mp_check_nargs(int n_args, machine_uint_t n_args_min, machine_uint_t n_args_max, int n_kw, bool is_kw) {
if (n_kw && !is_kw) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError,
"function does not take keyword arguments"));
@@ -106,7 +106,7 @@ const mp_obj_type_t mp_type_fun_native = {
};
// fun must have the correct signature for n_args fixed arguments
-mp_obj_t rt_make_function_n(int n_args, void *fun) {
+mp_obj_t mp_make_function_n(int n_args, void *fun) {
mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
o->base.type = &mp_type_fun_native;
o->is_kw = false;
@@ -116,7 +116,7 @@ mp_obj_t rt_make_function_n(int n_args, void *fun) {
return o;
}
-mp_obj_t rt_make_function_var(int n_args_min, mp_fun_var_t fun) {
+mp_obj_t mp_make_function_var(int n_args_min, mp_fun_var_t fun) {
mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
o->base.type = &mp_type_fun_native;
o->is_kw = false;
@@ -127,7 +127,7 @@ mp_obj_t rt_make_function_var(int n_args_min, mp_fun_var_t fun) {
}
// min and max are inclusive
-mp_obj_t rt_make_function_var_between(int n_args_min, int n_args_max, mp_fun_var_t fun) {
+mp_obj_t mp_make_function_var_between(int n_args_min, int n_args_max, mp_fun_var_t fun) {
mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
o->base.type = &mp_type_fun_native;
o->is_kw = false;
@@ -278,14 +278,14 @@ continue2:;
}
}
- mp_map_t *old_globals = rt_globals_get();
- rt_globals_set(self->globals);
+ mp_map_t *old_globals = mp_globals_get();
+ mp_globals_set(self->globals);
mp_obj_t result;
DEBUG_printf("Calling: args=%p, n_args=%d, extra_args=%p, n_extra_args=%d\n", args, n_args, extra_args, n_extra_args);
dump_args(args, n_args);
dump_args(extra_args, n_extra_args);
mp_vm_return_kind_t vm_return_kind = mp_execute_byte_code(self->bytecode, args, n_args, extra_args, n_extra_args, &result);
- rt_globals_set(old_globals);
+ mp_globals_set(old_globals);
if (vm_return_kind == MP_VM_RETURN_NORMAL) {
return result;
@@ -319,7 +319,7 @@ mp_obj_t mp_obj_new_fun_bc(uint scope_flags, qstr *args, uint n_args, mp_obj_t d
}
mp_obj_fun_bc_t *o = m_new_obj_var(mp_obj_fun_bc_t, mp_obj_t, n_extra_args);
o->base.type = &mp_type_fun_bc;
- o->globals = rt_globals_get();
+ o->globals = mp_globals_get();
o->args = args;
o->n_args = n_args;
o->n_def_args = n_def_args;
diff --git a/py/objgenerator.c b/py/objgenerator.c
index 1c81b2e51a585b2a3579abd21a93e77591429d17..ce02e6f3abbd3ffe2b0e8d8f875aed602c886c12 100644
--- a/py/objgenerator.c
+++ b/py/objgenerator.c
@@ -162,7 +162,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(gen_instance_send_obj, gen_instance_send);
STATIC mp_obj_t gen_instance_close(mp_obj_t self_in);
STATIC mp_obj_t gen_instance_throw(uint n_args, const mp_obj_t *args) {
mp_obj_t exc = (n_args == 2) ? args[1] : args[2];
- exc = rt_make_raise_obj(exc);
+ exc = mp_make_raise_obj(exc);
if (mp_obj_is_subclass_fast(mp_obj_get_type(exc), &mp_type_GeneratorExit)) {
// Throwing GeneratorExit is equivalent of calling close aka
// GeneratorExit should be handled specially
diff --git a/py/objgetitemiter.c b/py/objgetitemiter.c
index fff3f3807f6d5d1797be79a535a564a3b58cd711..09235640a8e558419ebfd1ca57607dc4c6bf5a66 100644
--- a/py/objgetitemiter.c
+++ b/py/objgetitemiter.c
@@ -19,7 +19,7 @@ STATIC mp_obj_t it_iternext(mp_obj_t self_in) {
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
// try to get next item
- mp_obj_t value = rt_call_method_n_kw(1, 0, self->args);
+ mp_obj_t value = mp_call_method_n_kw(1, 0, self->args);
self->args[2] = MP_OBJ_NEW_SMALL_INT(MP_OBJ_SMALL_INT_VALUE(self->args[2]) + 1);
nlr_pop();
return value;
@@ -41,7 +41,7 @@ STATIC const mp_obj_type_t it_type = {
.iternext = it_iternext
};
-// args are those returned from rt_load_method_maybe (ie either an attribute or a method)
+// args are those returned from mp_load_method_maybe (ie either an attribute or a method)
mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args) {
mp_obj_getitem_iter_t *o = m_new_obj(mp_obj_getitem_iter_t);
o->base.type = &it_type;
diff --git a/py/objint_longlong.c b/py/objint_longlong.c
index 3a8d3eaa86dd9942ca65031ff72752507258d0de..e64cc6734f8a8a22919bf53a49310fad86614a79 100644
--- a/py/objint_longlong.c
+++ b/py/objint_longlong.c
@@ -32,10 +32,10 @@ void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj
mp_obj_t int_unary_op(int op, mp_obj_t o_in) {
mp_obj_int_t *o = o_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(o->val != 0);
- case RT_UNARY_OP_POSITIVE: return o_in;
- case RT_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val);
- case RT_UNARY_OP_INVERT: return mp_obj_new_int_from_ll(~o->val);
+ case MP_UNARY_OP_BOOL: return MP_BOOL(o->val != 0);
+ case MP_UNARY_OP_POSITIVE: return o_in;
+ case MP_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val);
+ case MP_UNARY_OP_INVERT: return mp_obj_new_int_from_ll(~o->val);
default: return NULL; // op not supported
}
}
@@ -61,50 +61,50 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
}
switch (op) {
- case RT_BINARY_OP_ADD:
- case RT_BINARY_OP_INPLACE_ADD:
+ case MP_BINARY_OP_ADD:
+ case MP_BINARY_OP_INPLACE_ADD:
return mp_obj_new_int_from_ll(lhs_val + rhs_val);
- case RT_BINARY_OP_SUBTRACT:
- case RT_BINARY_OP_INPLACE_SUBTRACT:
+ case MP_BINARY_OP_SUBTRACT:
+ case MP_BINARY_OP_INPLACE_SUBTRACT:
return mp_obj_new_int_from_ll(lhs_val - rhs_val);
- case RT_BINARY_OP_MULTIPLY:
- case RT_BINARY_OP_INPLACE_MULTIPLY:
+ case MP_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_INPLACE_MULTIPLY:
return mp_obj_new_int_from_ll(lhs_val * rhs_val);
- case RT_BINARY_OP_FLOOR_DIVIDE:
- case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE:
+ case MP_BINARY_OP_FLOOR_DIVIDE:
+ case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
return mp_obj_new_int_from_ll(lhs_val / rhs_val);
- case RT_BINARY_OP_MODULO:
- case RT_BINARY_OP_INPLACE_MODULO:
+ case MP_BINARY_OP_MODULO:
+ case MP_BINARY_OP_INPLACE_MODULO:
return mp_obj_new_int_from_ll(lhs_val % rhs_val);
- case RT_BINARY_OP_AND:
- case RT_BINARY_OP_INPLACE_AND:
+ case MP_BINARY_OP_AND:
+ case MP_BINARY_OP_INPLACE_AND:
return mp_obj_new_int_from_ll(lhs_val & rhs_val);
- case RT_BINARY_OP_OR:
- case RT_BINARY_OP_INPLACE_OR:
+ case MP_BINARY_OP_OR:
+ case MP_BINARY_OP_INPLACE_OR:
return mp_obj_new_int_from_ll(lhs_val | rhs_val);
- case RT_BINARY_OP_XOR:
- case RT_BINARY_OP_INPLACE_XOR:
+ case MP_BINARY_OP_XOR:
+ case MP_BINARY_OP_INPLACE_XOR:
return mp_obj_new_int_from_ll(lhs_val ^ rhs_val);
- case RT_BINARY_OP_LSHIFT:
- case RT_BINARY_OP_INPLACE_LSHIFT:
+ case MP_BINARY_OP_LSHIFT:
+ case MP_BINARY_OP_INPLACE_LSHIFT:
return mp_obj_new_int_from_ll(lhs_val << (int)rhs_val);
- case RT_BINARY_OP_RSHIFT:
- case RT_BINARY_OP_INPLACE_RSHIFT:
+ case MP_BINARY_OP_RSHIFT:
+ case MP_BINARY_OP_INPLACE_RSHIFT:
return mp_obj_new_int_from_ll(lhs_val >> (int)rhs_val);
- case RT_BINARY_OP_LESS:
+ case MP_BINARY_OP_LESS:
return MP_BOOL(lhs_val < rhs_val);
- case RT_BINARY_OP_MORE:
+ case MP_BINARY_OP_MORE:
return MP_BOOL(lhs_val > rhs_val);
- case RT_BINARY_OP_LESS_EQUAL:
+ case MP_BINARY_OP_LESS_EQUAL:
return MP_BOOL(lhs_val <= rhs_val);
- case RT_BINARY_OP_MORE_EQUAL:
+ case MP_BINARY_OP_MORE_EQUAL:
return MP_BOOL(lhs_val >= rhs_val);
- case RT_BINARY_OP_EQUAL:
+ case MP_BINARY_OP_EQUAL:
return MP_BOOL(lhs_val == rhs_val);
- case RT_BINARY_OP_NOT_EQUAL:
+ case MP_BINARY_OP_NOT_EQUAL:
return MP_BOOL(lhs_val != rhs_val);
default:
diff --git a/py/objint_mpz.c b/py/objint_mpz.c
index 75bb1c11003b160deb37cf3a3b83d71acc2a530d..7f12fbcd0f6ff5bbad9f1990e112c19aac601f38 100644
--- a/py/objint_mpz.c
+++ b/py/objint_mpz.c
@@ -36,10 +36,10 @@ void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj
mp_obj_t int_unary_op(int op, mp_obj_t o_in) {
mp_obj_int_t *o = o_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(!mpz_is_zero(&o->mpz));
- case RT_UNARY_OP_POSITIVE: return o_in;
- case RT_UNARY_OP_NEGATIVE: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_neg_inpl(&o2->mpz, &o->mpz); return o2; }
- case RT_UNARY_OP_INVERT: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_not_inpl(&o2->mpz, &o->mpz); return o2; }
+ case MP_UNARY_OP_BOOL: return MP_BOOL(!mpz_is_zero(&o->mpz));
+ case MP_UNARY_OP_POSITIVE: return o_in;
+ case MP_UNARY_OP_NEGATIVE: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_neg_inpl(&o2->mpz, &o->mpz); return o2; }
+ case MP_UNARY_OP_INVERT: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_not_inpl(&o2->mpz, &o->mpz); return o2; }
default: return NULL; // op not supported
}
}
@@ -61,7 +61,7 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
return MP_OBJ_NULL;
}
- // if rhs is small int, then lhs was not (otherwise rt_binary_op handles it)
+ // if rhs is small int, then lhs was not (otherwise mp_binary_op handles it)
if (MP_OBJ_IS_SMALL_INT(rhs_in)) {
mpz_init_fixed_from_int(&z_int, z_int_dig, MPZ_NUM_DIG_FOR_INT, MP_OBJ_SMALL_INT_VALUE(rhs_in));
zrhs = &z_int;
@@ -80,30 +80,30 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
if (0) {
#if MICROPY_ENABLE_FLOAT
- } else if (op == RT_BINARY_OP_TRUE_DIVIDE || op == RT_BINARY_OP_INPLACE_TRUE_DIVIDE) {
+ } else if (op == MP_BINARY_OP_TRUE_DIVIDE || op == MP_BINARY_OP_INPLACE_TRUE_DIVIDE) {
mp_float_t flhs = mpz_as_float(zlhs);
mp_float_t frhs = mpz_as_float(zrhs);
return mp_obj_new_float(flhs / frhs);
#endif
- } else if (op <= RT_BINARY_OP_INPLACE_POWER) {
+ } else if (op <= MP_BINARY_OP_INPLACE_POWER) {
mp_obj_int_t *res = mp_obj_int_new_mpz();
switch (op) {
- case RT_BINARY_OP_ADD:
- case RT_BINARY_OP_INPLACE_ADD:
+ case MP_BINARY_OP_ADD:
+ case MP_BINARY_OP_INPLACE_ADD:
mpz_add_inpl(&res->mpz, zlhs, zrhs);
break;
- case RT_BINARY_OP_SUBTRACT:
- case RT_BINARY_OP_INPLACE_SUBTRACT:
+ case MP_BINARY_OP_SUBTRACT:
+ case MP_BINARY_OP_INPLACE_SUBTRACT:
mpz_sub_inpl(&res->mpz, zlhs, zrhs);
break;
- case RT_BINARY_OP_MULTIPLY:
- case RT_BINARY_OP_INPLACE_MULTIPLY:
+ case MP_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_INPLACE_MULTIPLY:
mpz_mul_inpl(&res->mpz, zlhs, zrhs);
break;
- case RT_BINARY_OP_FLOOR_DIVIDE:
- case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: {
+ case MP_BINARY_OP_FLOOR_DIVIDE:
+ case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: {
mpz_t rem; mpz_init_zero(&rem);
mpz_divmod_inpl(&res->mpz, &rem, zlhs, zrhs);
if (zlhs->neg != zrhs->neg) {
@@ -115,8 +115,8 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
mpz_deinit(&rem);
break;
}
- case RT_BINARY_OP_MODULO:
- case RT_BINARY_OP_INPLACE_MODULO: {
+ case MP_BINARY_OP_MODULO:
+ case MP_BINARY_OP_INPLACE_MODULO: {
mpz_t quo; mpz_init_zero(&quo);
mpz_divmod_inpl(&quo, &res->mpz, zlhs, zrhs);
mpz_deinit(&quo);
@@ -127,29 +127,29 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
break;
}
- case RT_BINARY_OP_AND:
- case RT_BINARY_OP_INPLACE_AND:
+ case MP_BINARY_OP_AND:
+ case MP_BINARY_OP_INPLACE_AND:
mpz_and_inpl(&res->mpz, zlhs, zrhs);
break;
- case RT_BINARY_OP_OR:
- case RT_BINARY_OP_INPLACE_OR:
+ case MP_BINARY_OP_OR:
+ case MP_BINARY_OP_INPLACE_OR:
mpz_or_inpl(&res->mpz, zlhs, zrhs);
break;
- case RT_BINARY_OP_XOR:
- case RT_BINARY_OP_INPLACE_XOR:
+ case MP_BINARY_OP_XOR:
+ case MP_BINARY_OP_INPLACE_XOR:
mpz_xor_inpl(&res->mpz, zlhs, zrhs);
break;
- case RT_BINARY_OP_LSHIFT:
- case RT_BINARY_OP_INPLACE_LSHIFT:
- case RT_BINARY_OP_RSHIFT:
- case RT_BINARY_OP_INPLACE_RSHIFT: {
+ case MP_BINARY_OP_LSHIFT:
+ case MP_BINARY_OP_INPLACE_LSHIFT:
+ case MP_BINARY_OP_RSHIFT:
+ case MP_BINARY_OP_INPLACE_RSHIFT: {
// TODO check conversion overflow
machine_int_t irhs = mpz_as_int(zrhs);
if (irhs < 0) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count"));
}
- if (op == RT_BINARY_OP_LSHIFT || op == RT_BINARY_OP_INPLACE_LSHIFT) {
+ if (op == MP_BINARY_OP_LSHIFT || op == MP_BINARY_OP_INPLACE_LSHIFT) {
mpz_shl_inpl(&res->mpz, zlhs, irhs);
} else {
mpz_shr_inpl(&res->mpz, zlhs, irhs);
@@ -157,8 +157,8 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
break;
}
- case RT_BINARY_OP_POWER:
- case RT_BINARY_OP_INPLACE_POWER:
+ case MP_BINARY_OP_POWER:
+ case MP_BINARY_OP_INPLACE_POWER:
mpz_pow_inpl(&res->mpz, zlhs, zrhs);
break;
@@ -171,17 +171,17 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
} else {
int cmp = mpz_cmp(zlhs, zrhs);
switch (op) {
- case RT_BINARY_OP_LESS:
+ case MP_BINARY_OP_LESS:
return MP_BOOL(cmp < 0);
- case RT_BINARY_OP_MORE:
+ case MP_BINARY_OP_MORE:
return MP_BOOL(cmp > 0);
- case RT_BINARY_OP_LESS_EQUAL:
+ case MP_BINARY_OP_LESS_EQUAL:
return MP_BOOL(cmp <= 0);
- case RT_BINARY_OP_MORE_EQUAL:
+ case MP_BINARY_OP_MORE_EQUAL:
return MP_BOOL(cmp >= 0);
- case RT_BINARY_OP_EQUAL:
+ case MP_BINARY_OP_EQUAL:
return MP_BOOL(cmp == 0);
- case RT_BINARY_OP_NOT_EQUAL:
+ case MP_BINARY_OP_NOT_EQUAL:
return MP_BOOL(cmp != 0);
default:
diff --git a/py/objlist.c b/py/objlist.c
index 27b2a913d860b71ef0b5731fbe55589997853216..c2feb0131985d5488e2a724b0fc7135435fd84a2 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -50,10 +50,10 @@ STATIC mp_obj_t list_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp
case 1:
{
// make list from iterable
- mp_obj_t iterable = rt_getiter(args[0]);
+ mp_obj_t iterable = mp_getiter(args[0]);
mp_obj_t list = mp_obj_new_list(0, NULL);
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
mp_obj_list_append(list, item);
}
return list;
@@ -65,7 +65,7 @@ STATIC mp_obj_t list_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp
return NULL;
}
-// Don't pass RT_BINARY_OP_NOT_EQUAL here
+// Don't pass MP_BINARY_OP_NOT_EQUAL here
STATIC bool list_cmp_helper(int op, mp_obj_t self_in, mp_obj_t another_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
if (!MP_OBJ_IS_TYPE(another_in, &mp_type_list)) {
@@ -80,8 +80,8 @@ STATIC bool list_cmp_helper(int op, mp_obj_t self_in, mp_obj_t another_in) {
STATIC mp_obj_t list_unary_op(int op, mp_obj_t self_in) {
mp_obj_list_t *self = self_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(self->len != 0);
- case RT_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
+ case MP_UNARY_OP_BOOL: return MP_BOOL(self->len != 0);
+ case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
default: return MP_OBJ_NULL; // op not supported for None
}
}
@@ -89,7 +89,7 @@ STATIC mp_obj_t list_unary_op(int op, mp_obj_t self_in) {
STATIC mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_list_t *o = lhs;
switch (op) {
- case RT_BINARY_OP_SUBSCR:
+ case MP_BINARY_OP_SUBSCR:
{
#if MICROPY_ENABLE_SLICE
if (MP_OBJ_IS_TYPE(rhs, &mp_type_slice)) {
@@ -105,7 +105,7 @@ STATIC mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
uint index = mp_get_index(o->base.type, o->len, rhs, false);
return o->items[index];
}
- case RT_BINARY_OP_ADD:
+ case MP_BINARY_OP_ADD:
{
if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) {
return NULL;
@@ -115,7 +115,7 @@ STATIC mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
m_seq_cat(s->items, o->items, o->len, p->items, p->len, mp_obj_t);
return s;
}
- case RT_BINARY_OP_INPLACE_ADD:
+ case MP_BINARY_OP_INPLACE_ADD:
{
if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) {
return NULL;
@@ -123,7 +123,7 @@ STATIC mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
list_extend(lhs, rhs);
return o;
}
- case RT_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_MULTIPLY:
{
if (!MP_OBJ_IS_SMALL_INT(rhs)) {
return NULL;
@@ -133,14 +133,14 @@ STATIC mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items);
return s;
}
- case RT_BINARY_OP_EQUAL:
- case RT_BINARY_OP_LESS:
- case RT_BINARY_OP_LESS_EQUAL:
- case RT_BINARY_OP_MORE:
- case RT_BINARY_OP_MORE_EQUAL:
+ case MP_BINARY_OP_EQUAL:
+ case MP_BINARY_OP_LESS:
+ case MP_BINARY_OP_LESS_EQUAL:
+ case MP_BINARY_OP_MORE:
+ case MP_BINARY_OP_MORE_EQUAL:
return MP_BOOL(list_cmp_helper(op, lhs, rhs));
- case RT_BINARY_OP_NOT_EQUAL:
- return MP_BOOL(!list_cmp_helper(RT_BINARY_OP_EQUAL, lhs, rhs));
+ case MP_BINARY_OP_NOT_EQUAL:
+ return MP_BOOL(!list_cmp_helper(MP_BINARY_OP_EQUAL, lhs, rhs));
default:
// op not supported
@@ -201,14 +201,14 @@ STATIC mp_obj_t list_pop(uint n_args, const mp_obj_t *args) {
// TODO make this conform to CPython's definition of sort
STATIC void mp_quicksort(mp_obj_t *head, mp_obj_t *tail, mp_obj_t key_fn, bool reversed) {
- int op = reversed ? RT_BINARY_OP_MORE : RT_BINARY_OP_LESS;
+ int op = reversed ? MP_BINARY_OP_MORE : MP_BINARY_OP_LESS;
while (head < tail) {
mp_obj_t *h = head - 1;
mp_obj_t *t = tail;
- mp_obj_t v = key_fn == NULL ? tail[0] : rt_call_function_1(key_fn, tail[0]); // get pivot using key_fn
+ mp_obj_t v = key_fn == NULL ? tail[0] : mp_call_function_1(key_fn, tail[0]); // get pivot using key_fn
for (;;) {
- do ++h; while (rt_binary_op(op, key_fn == NULL ? h[0] : rt_call_function_1(key_fn, h[0]), v) == mp_const_true);
- do --t; while (h < t && rt_binary_op(op, v, key_fn == NULL ? t[0] : rt_call_function_1(key_fn, t[0])) == mp_const_true);
+ do ++h; while (mp_binary_op(op, key_fn == NULL ? h[0] : mp_call_function_1(key_fn, h[0]), v) == mp_const_true);
+ do --t; while (h < t && mp_binary_op(op, v, key_fn == NULL ? t[0] : mp_call_function_1(key_fn, t[0])) == mp_const_true);
if (h >= t) break;
mp_obj_t x = h[0];
h[0] = t[0];
@@ -235,7 +235,7 @@ mp_obj_t mp_obj_list_sort(uint n_args, const mp_obj_t *args, mp_map_t *kwargs) {
mp_map_elem_t *reverse = mp_map_lookup(kwargs, MP_OBJ_NEW_QSTR(MP_QSTR_reverse), MP_MAP_LOOKUP);
mp_quicksort(self->items, self->items + self->len - 1,
keyfun ? keyfun->value : NULL,
- reverse && reverse->value ? rt_is_true(reverse->value) : false);
+ reverse && reverse->value ? mp_obj_is_true(reverse->value) : false);
}
return mp_const_none; // return None, as per CPython
}
diff --git a/py/objmap.c b/py/objmap.c
index efed6c93b00096ccf6a6a8a2f869e217b643874a..923ca861b33c3b9d8d8fcb4effdba4c3743eedb4 100644
--- a/py/objmap.c
+++ b/py/objmap.c
@@ -25,7 +25,7 @@ STATIC mp_obj_t map_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_
o->n_iters = n_args - 1;
o->fun = args[0];
for (int i = 0; i < n_args - 1; i++) {
- o->iters[i] = rt_getiter(args[i + 1]);
+ o->iters[i] = mp_getiter(args[i + 1]);
}
return o;
}
@@ -40,14 +40,14 @@ STATIC mp_obj_t map_iternext(mp_obj_t self_in) {
mp_obj_t *nextses = m_new(mp_obj_t, self->n_iters);
for (int i = 0; i < self->n_iters; i++) {
- mp_obj_t next = rt_iternext(self->iters[i]);
+ mp_obj_t next = mp_iternext(self->iters[i]);
if (next == MP_OBJ_NULL) {
m_del(mp_obj_t, nextses, self->n_iters);
return MP_OBJ_NULL;
}
nextses[i] = next;
}
- return rt_call_function_n_kw(self->fun, self->n_iters, 0, nextses);
+ return mp_call_function_n_kw(self->fun, self->n_iters, 0, nextses);
}
const mp_obj_type_t mp_type_map = {
diff --git a/py/objnone.c b/py/objnone.c
index 3fccd88479a447581f3dfeddcad292d5d3b4be9b..c79c8189ae696eee05fec4821a6e81700108e71c 100644
--- a/py/objnone.c
+++ b/py/objnone.c
@@ -17,7 +17,7 @@ STATIC void none_print(void (*print)(void *env, const char *fmt, ...), void *env
STATIC mp_obj_t none_unary_op(int op, mp_obj_t o_in) {
switch (op) {
- case RT_UNARY_OP_BOOL: return mp_const_false;
+ case MP_UNARY_OP_BOOL: return mp_const_false;
default: return MP_OBJ_NULL; // op not supported for None
}
}
diff --git a/py/objset.c b/py/objset.c
index 763c17f317bffd188ddd4ada3091456f8438ff23..9b0ac2b10723e2da4fe8b3b35a88692d4270142e 100644
--- a/py/objset.c
+++ b/py/objset.c
@@ -57,9 +57,9 @@ STATIC mp_obj_t set_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_
{
// 1 argument, an iterable from which we make a new set
mp_obj_t set = mp_obj_new_set(0, NULL);
- mp_obj_t iterable = rt_getiter(args[0]);
+ mp_obj_t iterable = mp_getiter(args[0]);
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
mp_obj_set_store(set, item);
}
return set;
@@ -160,9 +160,9 @@ STATIC mp_obj_t set_diff_int(int n_args, const mp_obj_t *args, bool update) {
if (self == other) {
set_clear(self);
} else {
- mp_obj_t iter = rt_getiter(other);
+ mp_obj_t iter = mp_getiter(other);
mp_obj_t next;
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
set_discard(self, next);
}
}
@@ -191,9 +191,9 @@ STATIC mp_obj_t set_intersect_int(mp_obj_t self_in, mp_obj_t other, bool update)
mp_obj_set_t *self = self_in;
mp_obj_set_t *out = mp_obj_new_set(0, NULL);
- mp_obj_t iter = rt_getiter(other);
+ mp_obj_t iter = mp_getiter(other);
mp_obj_t next;
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) {
set_add(out, next);
}
@@ -223,9 +223,9 @@ STATIC mp_obj_t set_isdisjoint(mp_obj_t self_in, mp_obj_t other) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_set));
mp_obj_set_t *self = self_in;
- mp_obj_t iter = rt_getiter(other);
+ mp_obj_t iter = mp_getiter(other);
mp_obj_t next;
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) {
return mp_const_false;
}
@@ -330,9 +330,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(set_remove_obj, set_remove);
STATIC mp_obj_t set_symmetric_difference_update(mp_obj_t self_in, mp_obj_t other_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_set));
mp_obj_set_t *self = self_in;
- mp_obj_t iter = rt_getiter(other_in);
+ mp_obj_t iter = mp_getiter(other_in);
mp_obj_t next;
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
mp_set_lookup(&self->set, next, MP_MAP_LOOKUP_REMOVE_IF_FOUND | MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
}
return mp_const_none;
@@ -348,9 +348,9 @@ STATIC mp_obj_t set_symmetric_difference(mp_obj_t self_in, mp_obj_t other_in) {
STATIC MP_DEFINE_CONST_FUN_OBJ_2(set_symmetric_difference_obj, set_symmetric_difference);
STATIC void set_update_int(mp_obj_set_t *self, mp_obj_t other_in) {
- mp_obj_t iter = rt_getiter(other_in);
+ mp_obj_t iter = mp_getiter(other_in);
mp_obj_t next;
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
mp_set_lookup(&self->set, next, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
}
}
@@ -379,35 +379,35 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(set_union_obj, set_union);
STATIC mp_obj_t set_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_t args[] = {lhs, rhs};
switch (op) {
- case RT_BINARY_OP_OR:
+ case MP_BINARY_OP_OR:
return set_union(lhs, rhs);
- case RT_BINARY_OP_XOR:
+ case MP_BINARY_OP_XOR:
return set_symmetric_difference(lhs, rhs);
- case RT_BINARY_OP_AND:
+ case MP_BINARY_OP_AND:
return set_intersect(lhs, rhs);
- case RT_BINARY_OP_SUBTRACT:
+ case MP_BINARY_OP_SUBTRACT:
return set_diff(2, args);
- case RT_BINARY_OP_INPLACE_OR:
+ case MP_BINARY_OP_INPLACE_OR:
return set_union(lhs, rhs);
- case RT_BINARY_OP_INPLACE_XOR:
+ case MP_BINARY_OP_INPLACE_XOR:
return set_symmetric_difference(lhs, rhs);
- case RT_BINARY_OP_INPLACE_AND:
+ case MP_BINARY_OP_INPLACE_AND:
return set_intersect(lhs, rhs);
- case RT_BINARY_OP_INPLACE_SUBTRACT:
+ case MP_BINARY_OP_INPLACE_SUBTRACT:
return set_diff(2, args);
- case RT_BINARY_OP_LESS:
+ case MP_BINARY_OP_LESS:
return set_issubset_proper(lhs, rhs);
- case RT_BINARY_OP_MORE:
+ case MP_BINARY_OP_MORE:
return set_issuperset_proper(lhs, rhs);
- case RT_BINARY_OP_EQUAL:
+ case MP_BINARY_OP_EQUAL:
return set_equal(lhs, rhs);
- case RT_BINARY_OP_LESS_EQUAL:
+ case MP_BINARY_OP_LESS_EQUAL:
return set_issubset(lhs, rhs);
- case RT_BINARY_OP_MORE_EQUAL:
+ case MP_BINARY_OP_MORE_EQUAL:
return set_issuperset(lhs, rhs);
- case RT_BINARY_OP_NOT_EQUAL:
+ case MP_BINARY_OP_NOT_EQUAL:
return MP_BOOL(set_equal(lhs, rhs) == mp_const_false);
- case RT_BINARY_OP_IN:
+ case MP_BINARY_OP_IN:
{
mp_obj_set_t *o = lhs;
mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP);
diff --git a/py/objstr.c b/py/objstr.c
index 9c72584173f60a58a6962419f416148c5002d2f4..d02924c506583153cbad87194e3f612946281cfd 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -160,9 +160,9 @@ STATIC mp_obj_t bytes_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const m
o = mp_obj_str_builder_start(&mp_type_bytes, len, &data);
}
- mp_obj_t iterable = rt_getiter(args[0]);
+ mp_obj_t iterable = mp_getiter(args[0]);
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (len == -1) {
vstr_add_char(vstr, MP_OBJ_SMALL_INT_VALUE(item));
} else {
@@ -215,7 +215,7 @@ STATIC const byte *find_subbytes(const byte *haystack, machine_uint_t hlen, cons
STATIC mp_obj_t str_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
GET_STR_DATA_LEN(lhs_in, lhs_data, lhs_len);
switch (op) {
- case RT_BINARY_OP_SUBSCR:
+ case MP_BINARY_OP_SUBSCR:
// TODO: need predicate to check for int-like type (bools are such for example)
// ["no", "yes"][1 == 2] is common idiom
if (MP_OBJ_IS_SMALL_INT(rhs_in)) {
@@ -239,8 +239,8 @@ STATIC mp_obj_t str_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "index must be int"));
}
- case RT_BINARY_OP_ADD:
- case RT_BINARY_OP_INPLACE_ADD:
+ case MP_BINARY_OP_ADD:
+ case MP_BINARY_OP_INPLACE_ADD:
if (MP_OBJ_IS_STR(rhs_in)) {
// add 2 strings
@@ -264,7 +264,7 @@ STATIC mp_obj_t str_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
}
break;
- case RT_BINARY_OP_IN:
+ case MP_BINARY_OP_IN:
/* NOTE `a in b` is `b.__contains__(a)` */
if (MP_OBJ_IS_STR(rhs_in)) {
GET_STR_DATA_LEN(rhs_in, rhs_data, rhs_len);
@@ -272,7 +272,7 @@ STATIC mp_obj_t str_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
}
break;
- case RT_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_MULTIPLY:
{
if (!MP_OBJ_IS_SMALL_INT(rhs_in)) {
return NULL;
@@ -284,13 +284,13 @@ STATIC mp_obj_t str_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
return mp_obj_str_builder_end(s);
}
- // These 2 are never passed here, dealt with as a special case in rt_binary_op().
- //case RT_BINARY_OP_EQUAL:
- //case RT_BINARY_OP_NOT_EQUAL:
- case RT_BINARY_OP_LESS:
- case RT_BINARY_OP_LESS_EQUAL:
- case RT_BINARY_OP_MORE:
- case RT_BINARY_OP_MORE_EQUAL:
+ // These 2 are never passed here, dealt with as a special case in mp_binary_op().
+ //case MP_BINARY_OP_EQUAL:
+ //case MP_BINARY_OP_NOT_EQUAL:
+ case MP_BINARY_OP_LESS:
+ case MP_BINARY_OP_LESS_EQUAL:
+ case MP_BINARY_OP_MORE:
+ case MP_BINARY_OP_MORE_EQUAL:
if (MP_OBJ_IS_STR(rhs_in)) {
GET_STR_DATA_LEN(rhs_in, rhs_data, rhs_len);
return MP_BOOL(mp_seq_cmp_bytes(op, lhs_data, lhs_len, rhs_data, rhs_len));
@@ -373,7 +373,7 @@ STATIC mp_obj_t str_split(uint n_args, const mp_obj_t *args) {
while (s < top && splits != 0) {
start = s;
while (s < top && !is_ws(*s)) s++;
- rt_list_append(res, mp_obj_new_str(start, s - start, false));
+ mp_list_append(res, mp_obj_new_str(start, s - start, false));
if (s >= top) {
break;
}
@@ -384,7 +384,7 @@ STATIC mp_obj_t str_split(uint n_args, const mp_obj_t *args) {
}
if (s < top) {
- rt_list_append(res, mp_obj_new_str(s, top - s, false));
+ mp_list_append(res, mp_obj_new_str(s, top - s, false));
}
return res;
diff --git a/py/objtuple.c b/py/objtuple.c
index d8c36021b56cf129a56708bf03e5789272b72dbb..faa355e5bdce1c3ffc4366e7c44ec2e822b6901c 100644
--- a/py/objtuple.c
+++ b/py/objtuple.c
@@ -39,8 +39,7 @@ STATIC mp_obj_t tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const m
// return a empty tuple
return mp_const_empty_tuple;
- case 1:
- {
+ case 1: {
// 1 argument, an iterable from which we make a new tuple
if (MP_OBJ_IS_TYPE(args[0], &mp_type_tuple)) {
return args[0];
@@ -52,9 +51,9 @@ STATIC mp_obj_t tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const m
uint len = 0;
mp_obj_t *items = m_new(mp_obj_t, alloc);
- mp_obj_t iterable = rt_getiter(args[0]);
+ mp_obj_t iterable = mp_getiter(args[0]);
mp_obj_t item;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (len >= alloc) {
items = m_renew(mp_obj_t, items, alloc, alloc * 2);
alloc *= 2;
@@ -73,7 +72,7 @@ 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
+// Don't pass MP_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, &mp_type_tuple));
if (!MP_OBJ_IS_TYPE(another_in, &mp_type_tuple)) {
@@ -88,8 +87,8 @@ STATIC bool tuple_cmp_helper(int op, mp_obj_t self_in, mp_obj_t another_in) {
mp_obj_t tuple_unary_op(int op, mp_obj_t self_in) {
mp_obj_tuple_t *self = self_in;
switch (op) {
- case RT_UNARY_OP_BOOL: return MP_BOOL(self->len != 0);
- case RT_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
+ case MP_UNARY_OP_BOOL: return MP_BOOL(self->len != 0);
+ case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
default: return MP_OBJ_NULL; // op not supported for None
}
}
@@ -97,7 +96,7 @@ mp_obj_t tuple_unary_op(int op, mp_obj_t self_in) {
mp_obj_t tuple_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_tuple_t *o = lhs;
switch (op) {
- case RT_BINARY_OP_SUBSCR:
+ case MP_BINARY_OP_SUBSCR:
{
#if MICROPY_ENABLE_SLICE
if (MP_OBJ_IS_TYPE(rhs, &mp_type_slice)) {
@@ -113,7 +112,7 @@ mp_obj_t tuple_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
uint index = mp_get_index(o->base.type, o->len, rhs, false);
return o->items[index];
}
- case RT_BINARY_OP_ADD:
+ case MP_BINARY_OP_ADD:
{
if (!mp_obj_is_subclass_fast(mp_obj_get_type(rhs), (mp_obj_t)&mp_type_tuple)) {
return NULL;
@@ -123,7 +122,7 @@ mp_obj_t tuple_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
m_seq_cat(s->items, o->items, o->len, p->items, p->len, mp_obj_t);
return s;
}
- case RT_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_MULTIPLY:
{
if (!MP_OBJ_IS_SMALL_INT(rhs)) {
return NULL;
@@ -133,14 +132,14 @@ mp_obj_t tuple_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items);
return s;
}
- case RT_BINARY_OP_EQUAL:
- case RT_BINARY_OP_LESS:
- case RT_BINARY_OP_LESS_EQUAL:
- case RT_BINARY_OP_MORE:
- case RT_BINARY_OP_MORE_EQUAL:
+ case MP_BINARY_OP_EQUAL:
+ case MP_BINARY_OP_LESS:
+ case MP_BINARY_OP_LESS_EQUAL:
+ case MP_BINARY_OP_MORE:
+ case MP_BINARY_OP_MORE_EQUAL:
return MP_BOOL(tuple_cmp_helper(op, lhs, rhs));
- case RT_BINARY_OP_NOT_EQUAL:
- return MP_BOOL(!tuple_cmp_helper(RT_BINARY_OP_EQUAL, lhs, rhs));
+ case MP_BINARY_OP_NOT_EQUAL:
+ return MP_BOOL(!tuple_cmp_helper(MP_BINARY_OP_EQUAL, lhs, rhs));
default:
// op not supported
diff --git a/py/objtype.c b/py/objtype.c
index 513dc7ab2e25c7f4128071ee3dcd0a4b9d82eb41..05d39b1217b1a6e3ec4236fbbd54f83577fee577 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -76,7 +76,7 @@ STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *en
}
if (member != MP_OBJ_NULL) {
- mp_obj_t r = rt_call_function_1(member, self_in);
+ mp_obj_t r = mp_call_function_1(member, self_in);
mp_obj_print_helper(print, env, r, PRINT_STR);
return;
}
@@ -98,12 +98,12 @@ STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const m
// call __init__ function
mp_obj_t init_ret;
if (n_args == 0 && n_kw == 0) {
- init_ret = rt_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o);
+ init_ret = mp_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o);
} else {
mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw);
args2[0] = o;
memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
- init_ret = rt_call_function_n_kw(init_fn, n_args + 1, n_kw, args2);
+ init_ret = mp_call_function_n_kw(init_fn, n_args + 1, n_kw, args2);
m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
}
if (init_ret != mp_const_none) {
@@ -121,12 +121,12 @@ STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const m
}
STATIC const qstr unary_op_method_name[] = {
- [RT_UNARY_OP_BOOL] = MP_QSTR___bool__,
- [RT_UNARY_OP_LEN] = MP_QSTR___len__,
- //[RT_UNARY_OP_POSITIVE,
- //[RT_UNARY_OP_NEGATIVE,
- //[RT_UNARY_OP_INVERT,
- [RT_UNARY_OP_NOT] = MP_QSTR_, // don't need to implement this, used to make sure array has full size
+ [MP_UNARY_OP_BOOL] = MP_QSTR___bool__,
+ [MP_UNARY_OP_LEN] = MP_QSTR___len__,
+ //[MP_UNARY_OP_POSITIVE,
+ //[MP_UNARY_OP_NEGATIVE,
+ //[MP_UNARY_OP_INVERT,
+ [MP_UNARY_OP_NOT] = MP_QSTR_, // don't need to implement this, used to make sure array has full size
};
STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
@@ -137,51 +137,51 @@ STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
}
mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name);
if (member != MP_OBJ_NULL) {
- return rt_call_function_1(member, self_in);
+ return mp_call_function_1(member, self_in);
} else {
return MP_OBJ_NULL;
}
}
STATIC const qstr binary_op_method_name[] = {
- [RT_BINARY_OP_SUBSCR] = MP_QSTR___getitem__,
+ [MP_BINARY_OP_SUBSCR] = MP_QSTR___getitem__,
/*
- RT_BINARY_OP_OR,
- RT_BINARY_OP_XOR,
- RT_BINARY_OP_AND,
- RT_BINARY_OP_LSHIFT,
- RT_BINARY_OP_RSHIFT,
+ MP_BINARY_OP_OR,
+ MP_BINARY_OP_XOR,
+ MP_BINARY_OP_AND,
+ MP_BINARY_OP_LSHIFT,
+ MP_BINARY_OP_RSHIFT,
*/
- [RT_BINARY_OP_ADD] = MP_QSTR___add__,
- [RT_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
+ [MP_BINARY_OP_ADD] = MP_QSTR___add__,
+ [MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
/*
- RT_BINARY_OP_MULTIPLY,
- RT_BINARY_OP_FLOOR_DIVIDE,
- RT_BINARY_OP_TRUE_DIVIDE,
- RT_BINARY_OP_MODULO,
- RT_BINARY_OP_POWER,
- RT_BINARY_OP_INPLACE_OR,
- RT_BINARY_OP_INPLACE_XOR,
- RT_BINARY_OP_INPLACE_AND,
- RT_BINARY_OP_INPLACE_LSHIFT,
- RT_BINARY_OP_INPLACE_RSHIFT,
- RT_BINARY_OP_INPLACE_ADD,
- RT_BINARY_OP_INPLACE_SUBTRACT,
- RT_BINARY_OP_INPLACE_MULTIPLY,
- RT_BINARY_OP_INPLACE_FLOOR_DIVIDE,
- RT_BINARY_OP_INPLACE_TRUE_DIVIDE,
- RT_BINARY_OP_INPLACE_MODULO,
- RT_BINARY_OP_INPLACE_POWER,
- RT_BINARY_OP_LESS,
- RT_BINARY_OP_MORE,
- RT_BINARY_OP_EQUAL,
- RT_BINARY_OP_LESS_EQUAL,
- RT_BINARY_OP_MORE_EQUAL,
- RT_BINARY_OP_NOT_EQUAL,
- RT_BINARY_OP_IN,
- RT_BINARY_OP_IS,
+ MP_BINARY_OP_MULTIPLY,
+ MP_BINARY_OP_FLOOR_DIVIDE,
+ MP_BINARY_OP_TRUE_DIVIDE,
+ MP_BINARY_OP_MODULO,
+ MP_BINARY_OP_POWER,
+ MP_BINARY_OP_INPLACE_OR,
+ MP_BINARY_OP_INPLACE_XOR,
+ MP_BINARY_OP_INPLACE_AND,
+ MP_BINARY_OP_INPLACE_LSHIFT,
+ MP_BINARY_OP_INPLACE_RSHIFT,
+ MP_BINARY_OP_INPLACE_ADD,
+ MP_BINARY_OP_INPLACE_SUBTRACT,
+ MP_BINARY_OP_INPLACE_MULTIPLY,
+ MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
+ MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
+ MP_BINARY_OP_INPLACE_MODULO,
+ MP_BINARY_OP_INPLACE_POWER,
+ MP_BINARY_OP_LESS,
+ MP_BINARY_OP_MORE,
+ MP_BINARY_OP_EQUAL,
+ MP_BINARY_OP_LESS_EQUAL,
+ MP_BINARY_OP_MORE_EQUAL,
+ MP_BINARY_OP_NOT_EQUAL,
+ MP_BINARY_OP_IN,
+ MP_BINARY_OP_IS,
*/
- [RT_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
+ [MP_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
};
STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
@@ -192,7 +192,7 @@ STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
}
mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name);
if (member != MP_OBJ_NULL) {
- return rt_call_function_2(member, lhs_in, rhs_in);
+ return mp_call_function_2(member, lhs_in, rhs_in);
} else {
return MP_OBJ_NULL;
}
@@ -242,7 +242,7 @@ bool class_store_item(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__);
if (member != MP_OBJ_NULL) {
mp_obj_t args[3] = {self_in, index, value};
- rt_call_function_n_kw(member, 3, 0, args);
+ mp_call_function_n_kw(member, 3, 0, args);
return true;
} else {
return false;
diff --git a/py/objzip.c b/py/objzip.c
index 9200120899994195e840200a93394177728b7e3a..d26b77d7a3a5e07bfd70a262f57bbf6898f7e3a4 100644
--- a/py/objzip.c
+++ b/py/objzip.c
@@ -20,7 +20,7 @@ STATIC mp_obj_t zip_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_
o->base.type = &mp_type_zip;
o->n_iters = n_args;
for (int i = 0; i < n_args; i++) {
- o->iters[i] = rt_getiter(args[i]);
+ o->iters[i] = mp_getiter(args[i]);
}
return o;
}
@@ -40,7 +40,7 @@ STATIC mp_obj_t zip_iternext(mp_obj_t self_in) {
mp_obj_tuple_get(o, NULL, &items);
for (int i = 0; i < self->n_iters; i++) {
- mp_obj_t next = rt_iternext(self->iters[i]);
+ mp_obj_t next = mp_iternext(self->iters[i]);
if (next == MP_OBJ_NULL) {
mp_obj_tuple_del(o);
return MP_OBJ_NULL;
diff --git a/py/runtime.c b/py/runtime.c
index 121cfa04e08c6dbe3691f54792d7880107476fa7..a434d318e95c6adf2c8ae3303c9ee8e914f0f69e 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -37,7 +37,7 @@ STATIC void mp_map_add_qstr(mp_map_t *map, qstr qstr, mp_obj_t value) {
mp_map_lookup(map, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
}
-void rt_init(void) {
+void mp_init(void) {
mp_emit_glue_init();
// locals = globals for outer module (see Objects/frameobject.c/PyFrame_New())
@@ -60,86 +60,52 @@ void rt_init(void) {
#endif
// init sys.path
// for efficiency, left to platform-specific startup code
- //sys_path = mp_obj_new_list(0, NULL);
- //rt_store_attr(m_sys, MP_QSTR_path, sys_path);
+ //mp_sys_path = mp_obj_new_list(0, NULL);
+ //mp_store_attr(m_sys, MP_QSTR_path, mp_sys_path);
}
-void rt_deinit(void) {
+void mp_deinit(void) {
mp_map_free(map_globals);
mp_map_deinit(&map_builtins);
mp_module_deinit();
mp_emit_glue_deinit();
}
-int rt_is_true(mp_obj_t arg) {
- DEBUG_OP_printf("is true %p\n", arg);
- if (arg == mp_const_false) {
- return 0;
- } else if (arg == mp_const_true) {
- return 1;
- } else if (arg == mp_const_none) {
- return 0;
- } else if (MP_OBJ_IS_SMALL_INT(arg)) {
- if (MP_OBJ_SMALL_INT_VALUE(arg) == 0) {
- return 0;
- } else {
- return 1;
- }
- } else {
- mp_obj_type_t *type = mp_obj_get_type(arg);
- if (type->unary_op != NULL) {
- mp_obj_t result = type->unary_op(RT_UNARY_OP_BOOL, arg);
- if (result != MP_OBJ_NULL) {
- return result == mp_const_true;
- }
- }
-
- mp_obj_t len = mp_obj_len_maybe(arg);
- if (len != MP_OBJ_NULL) {
- // obj has a length, truth determined if len != 0
- return len != MP_OBJ_NEW_SMALL_INT(0);
- } else {
- // any other obj is true per Python semantics
- return 1;
- }
- }
-}
-
-mp_obj_t rt_list_append(mp_obj_t self_in, mp_obj_t arg) {
+mp_obj_t mp_list_append(mp_obj_t self_in, mp_obj_t arg) {
return mp_obj_list_append(self_in, arg);
}
-mp_obj_t rt_load_const_dec(qstr qstr) {
+mp_obj_t mp_load_const_dec(qstr qstr) {
DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
uint len;
const byte* data = qstr_data(qstr, &len);
return mp_parse_num_decimal((const char*)data, len, true, false);
}
-mp_obj_t rt_load_const_str(qstr qstr) {
+mp_obj_t mp_load_const_str(qstr qstr) {
DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
return MP_OBJ_NEW_QSTR(qstr);
}
-mp_obj_t rt_load_const_bytes(qstr qstr) {
+mp_obj_t mp_load_const_bytes(qstr qstr) {
DEBUG_OP_printf("load b'%s'\n", qstr_str(qstr));
uint len;
const byte *data = qstr_data(qstr, &len);
return mp_obj_new_bytes(data, len);
}
-mp_obj_t rt_load_name(qstr qstr) {
+mp_obj_t mp_load_name(qstr qstr) {
// logic: search locals, globals, builtins
DEBUG_OP_printf("load name %s\n", qstr_str(qstr));
mp_map_elem_t *elem = mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP);
if (elem != NULL) {
return elem->value;
} else {
- return rt_load_global(qstr);
+ return mp_load_global(qstr);
}
}
-mp_obj_t rt_load_global(qstr qstr) {
+mp_obj_t mp_load_global(qstr qstr) {
// logic: search globals, builtins
DEBUG_OP_printf("load global %s\n", qstr_str(qstr));
mp_map_elem_t *elem = mp_map_lookup(map_globals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP);
@@ -156,7 +122,7 @@ mp_obj_t rt_load_global(qstr qstr) {
return elem->value;
}
-mp_obj_t rt_load_build_class(void) {
+mp_obj_t mp_load_build_class(void) {
DEBUG_OP_printf("load_build_class\n");
// lookup __build_class__ in dynamic table of builtins first
mp_map_elem_t *elem = mp_map_lookup(&map_builtins, MP_OBJ_NEW_QSTR(MP_QSTR___build_class__), MP_MAP_LOOKUP);
@@ -169,47 +135,47 @@ mp_obj_t rt_load_build_class(void) {
}
}
-mp_obj_t rt_get_cell(mp_obj_t cell) {
+mp_obj_t mp_get_cell(mp_obj_t cell) {
return mp_obj_cell_get(cell);
}
-void rt_set_cell(mp_obj_t cell, mp_obj_t val) {
+void mp_set_cell(mp_obj_t cell, mp_obj_t val) {
mp_obj_cell_set(cell, val);
}
-void rt_store_name(qstr qstr, mp_obj_t obj) {
+void mp_store_name(qstr qstr, mp_obj_t obj) {
DEBUG_OP_printf("store name %s <- %p\n", qstr_str(qstr), obj);
mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = obj;
}
-void rt_delete_name(qstr qstr) {
+void mp_delete_name(qstr qstr) {
DEBUG_OP_printf("delete name %s\n", qstr_str(qstr));
mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
}
-void rt_store_global(qstr qstr, mp_obj_t obj) {
+void mp_store_global(qstr qstr, mp_obj_t obj) {
DEBUG_OP_printf("store global %s <- %p\n", qstr_str(qstr), obj);
mp_map_lookup(map_globals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = obj;
}
-mp_obj_t rt_unary_op(int op, mp_obj_t arg) {
+mp_obj_t mp_unary_op(int op, mp_obj_t arg) {
DEBUG_OP_printf("unary %d %p\n", op, arg);
if (MP_OBJ_IS_SMALL_INT(arg)) {
mp_small_int_t val = MP_OBJ_SMALL_INT_VALUE(arg);
switch (op) {
- case RT_UNARY_OP_BOOL:
+ case MP_UNARY_OP_BOOL:
return MP_BOOL(val != 0);
- case RT_UNARY_OP_POSITIVE:
+ case MP_UNARY_OP_POSITIVE:
return arg;
- case RT_UNARY_OP_NEGATIVE:
+ case MP_UNARY_OP_NEGATIVE:
// check for overflow
if (val == MP_SMALL_INT_MIN) {
return mp_obj_new_int(-val);
} else {
return MP_OBJ_NEW_SMALL_INT(-val);
}
- case RT_UNARY_OP_INVERT:
+ case MP_UNARY_OP_INVERT:
return MP_OBJ_NEW_SMALL_INT(~val);
default:
assert(0);
@@ -228,7 +194,7 @@ mp_obj_t rt_unary_op(int op, mp_obj_t arg) {
}
}
-mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
+mp_obj_t mp_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
DEBUG_OP_printf("binary %d %p %p\n", op, lhs, rhs);
// TODO correctly distinguish inplace operators for mutable objects
@@ -241,20 +207,20 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
// note that list does not implement + or +=, so that inplace_concat is reached first for +=
// deal with is
- if (op == RT_BINARY_OP_IS) {
+ if (op == MP_BINARY_OP_IS) {
return MP_BOOL(lhs == rhs);
}
// deal with == and != for all types
- if (op == RT_BINARY_OP_EQUAL || op == RT_BINARY_OP_NOT_EQUAL) {
+ if (op == MP_BINARY_OP_EQUAL || op == MP_BINARY_OP_NOT_EQUAL) {
if (mp_obj_equal(lhs, rhs)) {
- if (op == RT_BINARY_OP_EQUAL) {
+ if (op == MP_BINARY_OP_EQUAL) {
return mp_const_true;
} else {
return mp_const_false;
}
} else {
- if (op == RT_BINARY_OP_EQUAL) {
+ if (op == MP_BINARY_OP_EQUAL) {
return mp_const_false;
} else {
return mp_const_true;
@@ -263,7 +229,7 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
}
// deal with exception_match for all types
- if (op == RT_BINARY_OP_EXCEPTION_MATCH) {
+ if (op == MP_BINARY_OP_EXCEPTION_MATCH) {
// rhs must be issubclass(rhs, BaseException)
if (mp_obj_is_exception_type(rhs)) {
// if lhs is an instance of an exception, then extract and use its type
@@ -294,14 +260,14 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
// % if lhs=MIN and rhs=-1; result always fits in machine_int_t, then handled by SMALL_INT check
// << checked explicitly
switch (op) {
- case RT_BINARY_OP_OR:
- case RT_BINARY_OP_INPLACE_OR: lhs_val |= rhs_val; break;
- case RT_BINARY_OP_XOR:
- case RT_BINARY_OP_INPLACE_XOR: lhs_val ^= rhs_val; break;
- case RT_BINARY_OP_AND:
- case RT_BINARY_OP_INPLACE_AND: lhs_val &= rhs_val; break;
- case RT_BINARY_OP_LSHIFT:
- case RT_BINARY_OP_INPLACE_LSHIFT: {
+ case MP_BINARY_OP_OR:
+ case MP_BINARY_OP_INPLACE_OR: lhs_val |= rhs_val; break;
+ case MP_BINARY_OP_XOR:
+ case MP_BINARY_OP_INPLACE_XOR: lhs_val ^= rhs_val; break;
+ case MP_BINARY_OP_AND:
+ case MP_BINARY_OP_INPLACE_AND: lhs_val &= rhs_val; break;
+ case MP_BINARY_OP_LSHIFT:
+ case MP_BINARY_OP_INPLACE_LSHIFT: {
if (rhs_val < 0) {
// negative shift not allowed
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count"));
@@ -315,8 +281,8 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
}
break;
}
- case RT_BINARY_OP_RSHIFT:
- case RT_BINARY_OP_INPLACE_RSHIFT:
+ case MP_BINARY_OP_RSHIFT:
+ case MP_BINARY_OP_INPLACE_RSHIFT:
if (rhs_val < 0) {
// negative shift not allowed
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count"));
@@ -325,12 +291,12 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
lhs_val >>= rhs_val;
}
break;
- case RT_BINARY_OP_ADD:
- case RT_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
- case RT_BINARY_OP_SUBTRACT:
- case RT_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
- case RT_BINARY_OP_MULTIPLY:
- case RT_BINARY_OP_INPLACE_MULTIPLY: {
+ case MP_BINARY_OP_ADD:
+ case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
+ case MP_BINARY_OP_SUBTRACT:
+ case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
+ case MP_BINARY_OP_MULTIPLY:
+ case MP_BINARY_OP_INPLACE_MULTIPLY: {
// If long long type exists and is larger than machine_int_t, then
// we can use the following code to perform overflow-checked multiplication.
@@ -379,25 +345,25 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
break;
}
- case RT_BINARY_OP_FLOOR_DIVIDE:
- case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE:
+ case MP_BINARY_OP_FLOOR_DIVIDE:
+ case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
{
lhs_val = python_floor_divide(lhs_val, rhs_val);
break;
}
#if MICROPY_ENABLE_FLOAT
- case RT_BINARY_OP_TRUE_DIVIDE:
- case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: return mp_obj_new_float((mp_float_t)lhs_val / (mp_float_t)rhs_val);
+ case MP_BINARY_OP_TRUE_DIVIDE:
+ case MP_BINARY_OP_INPLACE_TRUE_DIVIDE: return mp_obj_new_float((mp_float_t)lhs_val / (mp_float_t)rhs_val);
#endif
- case RT_BINARY_OP_MODULO:
- case RT_BINARY_OP_INPLACE_MODULO:
+ case MP_BINARY_OP_MODULO:
+ case MP_BINARY_OP_INPLACE_MODULO:
{
lhs_val = python_modulo(lhs_val, rhs_val);
break;
}
- case RT_BINARY_OP_POWER:
- case RT_BINARY_OP_INPLACE_POWER:
+ case MP_BINARY_OP_POWER:
+ case MP_BINARY_OP_INPLACE_POWER:
if (rhs_val < 0) {
#if MICROPY_ENABLE_FLOAT
lhs = mp_obj_new_float(lhs_val);
@@ -418,10 +384,10 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
lhs_val = ans;
}
break;
- case RT_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val); break;
- case RT_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val); break;
- case RT_BINARY_OP_LESS_EQUAL: return MP_BOOL(lhs_val <= rhs_val); break;
- case RT_BINARY_OP_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val); break;
+ case MP_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val); break;
+ case MP_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val); break;
+ case MP_BINARY_OP_LESS_EQUAL: return MP_BOOL(lhs_val <= rhs_val); break;
+ case MP_BINARY_OP_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val); break;
default: assert(0);
}
@@ -445,7 +411,7 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
* NOTE `a in b` is `b.__contains__(a)`, hence why the generic dispatch
* needs to go below with swapped arguments
*/
- if (op == RT_BINARY_OP_IN) {
+ if (op == MP_BINARY_OP_IN) {
mp_obj_type_t *type = mp_obj_get_type(rhs);
if (type->binary_op != NULL) {
mp_obj_t res = type->binary_op(op, rhs, lhs);
@@ -456,8 +422,8 @@ mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
if (type->getiter != NULL) {
/* second attempt, walk the iterator */
mp_obj_t next = NULL;
- mp_obj_t iter = rt_getiter(rhs);
- while ((next = rt_iternext(iter)) != MP_OBJ_NULL) {
+ mp_obj_t iter = mp_getiter(rhs);
+ while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
if (mp_obj_equal(next, lhs)) {
return mp_const_true;
}
@@ -491,29 +457,29 @@ generic_binary_op:
return mp_const_none;
}
-mp_obj_t rt_call_function_0(mp_obj_t fun) {
- return rt_call_function_n_kw(fun, 0, 0, NULL);
+mp_obj_t mp_call_function_0(mp_obj_t fun) {
+ return mp_call_function_n_kw(fun, 0, 0, NULL);
}
-mp_obj_t rt_call_function_1(mp_obj_t fun, mp_obj_t arg) {
- return rt_call_function_n_kw(fun, 1, 0, &arg);
+mp_obj_t mp_call_function_1(mp_obj_t fun, mp_obj_t arg) {
+ return mp_call_function_n_kw(fun, 1, 0, &arg);
}
-mp_obj_t rt_call_function_2(mp_obj_t fun, mp_obj_t arg1, mp_obj_t arg2) {
+mp_obj_t mp_call_function_2(mp_obj_t fun, mp_obj_t arg1, mp_obj_t arg2) {
mp_obj_t args[2];
args[0] = arg1;
args[1] = arg2;
- return rt_call_function_n_kw(fun, 2, 0, args);
+ return mp_call_function_n_kw(fun, 2, 0, args);
}
// wrapper that accepts n_args and n_kw in one argument
// native emitter can only pass at most 3 arguments to a function
-mp_obj_t rt_call_function_n_kw_for_native(mp_obj_t fun_in, uint n_args_kw, const mp_obj_t *args) {
- return rt_call_function_n_kw(fun_in, n_args_kw & 0xff, (n_args_kw >> 8) & 0xff, args);
+mp_obj_t mp_call_function_n_kw_for_native(mp_obj_t fun_in, uint n_args_kw, const mp_obj_t *args) {
+ return mp_call_function_n_kw(fun_in, n_args_kw & 0xff, (n_args_kw >> 8) & 0xff, args);
}
// args contains, eg: arg0 arg1 key0 value0 key1 value1
-mp_obj_t rt_call_function_n_kw(mp_obj_t fun_in, uint n_args, uint n_kw, const mp_obj_t *args) {
+mp_obj_t mp_call_function_n_kw(mp_obj_t fun_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// TODO improve this: fun object can specify its type and we parse here the arguments,
// passing to the function arrays of fixed and keyword arguments
@@ -532,31 +498,31 @@ mp_obj_t rt_call_function_n_kw(mp_obj_t fun_in, uint n_args, uint n_kw, const mp
// args contains: fun self/NULL arg(0) ... arg(n_args-2) arg(n_args-1) kw_key(0) kw_val(0) ... kw_key(n_kw-1) kw_val(n_kw-1)
// if n_args==0 and n_kw==0 then there are only fun and self/NULL
-mp_obj_t rt_call_method_n_kw(uint n_args, uint n_kw, const mp_obj_t *args) {
+mp_obj_t mp_call_method_n_kw(uint n_args, uint n_kw, const mp_obj_t *args) {
DEBUG_OP_printf("call method (fun=%p, self=%p, n_args=%u, n_kw=%u, args=%p)\n", args[0], args[1], n_args, n_kw, args);
int adjust = (args[1] == NULL) ? 0 : 1;
- return rt_call_function_n_kw(args[0], n_args + adjust, n_kw, args + 2 - adjust);
+ return mp_call_function_n_kw(args[0], n_args + adjust, n_kw, args + 2 - adjust);
}
-mp_obj_t rt_build_tuple(int n_args, mp_obj_t *items) {
+mp_obj_t mp_build_tuple(int n_args, mp_obj_t *items) {
return mp_obj_new_tuple(n_args, items);
}
-mp_obj_t rt_build_list(int n_args, mp_obj_t *items) {
+mp_obj_t mp_build_list(int n_args, mp_obj_t *items) {
return mp_obj_new_list(n_args, items);
}
-mp_obj_t rt_build_set(int n_args, mp_obj_t *items) {
+mp_obj_t mp_build_set(int n_args, mp_obj_t *items) {
return mp_obj_new_set(n_args, items);
}
-mp_obj_t rt_store_set(mp_obj_t set, mp_obj_t item) {
+mp_obj_t mp_store_set(mp_obj_t set, mp_obj_t item) {
mp_obj_set_store(set, item);
return set;
}
// 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) {
+void mp_unpack_sequence(mp_obj_t seq_in, uint num, mp_obj_t *items) {
uint seq_len;
if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(seq_in, &mp_type_list)) {
mp_obj_t *seq_items;
@@ -574,16 +540,16 @@ void rt_unpack_sequence(mp_obj_t seq_in, uint num, mp_obj_t *items) {
items[i] = seq_items[num - 1 - i];
}
} else {
- mp_obj_t iterable = rt_getiter(seq_in);
+ mp_obj_t iterable = mp_getiter(seq_in);
for (seq_len = 0; seq_len < num; seq_len++) {
- mp_obj_t el = rt_iternext(iterable);
+ mp_obj_t el = mp_iternext(iterable);
if (el == MP_OBJ_NULL) {
goto too_short;
}
items[num - 1 - seq_len] = el;
}
- if (rt_iternext(iterable) != MP_OBJ_NULL) {
+ if (mp_iternext(iterable) != MP_OBJ_NULL) {
goto too_long;
}
}
@@ -595,20 +561,20 @@ too_long:
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "too many values to unpack (expected %d)", num));
}
-mp_obj_t rt_build_map(int n_args) {
+mp_obj_t mp_build_map(int n_args) {
return mp_obj_new_dict(n_args);
}
-mp_obj_t rt_store_map(mp_obj_t map, mp_obj_t key, mp_obj_t value) {
+mp_obj_t mp_store_map(mp_obj_t map, mp_obj_t key, mp_obj_t value) {
// map should always be a dict
return mp_obj_dict_store(map, key, value);
}
-mp_obj_t rt_load_attr(mp_obj_t base, qstr attr) {
+mp_obj_t mp_load_attr(mp_obj_t base, qstr attr) {
DEBUG_OP_printf("load attr %p.%s\n", base, qstr_str(attr));
// use load_method
mp_obj_t dest[2];
- rt_load_method(base, attr, dest);
+ mp_load_method(base, attr, dest);
if (dest[1] == MP_OBJ_NULL) {
// load_method returned just a normal attribute
return dest[0];
@@ -621,7 +587,7 @@ mp_obj_t rt_load_attr(mp_obj_t base, qstr attr) {
// no attribute found, returns: dest[0] == MP_OBJ_NULL, dest[1] == MP_OBJ_NULL
// normal attribute found, returns: dest[0] == <attribute>, dest[1] == MP_OBJ_NULL
// method attribute found, returns: dest[0] == <method>, dest[1] == <self>
-STATIC void rt_load_method_maybe(mp_obj_t base, qstr attr, mp_obj_t *dest) {
+STATIC void mp_load_method_maybe(mp_obj_t base, qstr attr, mp_obj_t *dest) {
// clear output to indicate no attribute/method found yet
dest[0] = MP_OBJ_NULL;
dest[1] = MP_OBJ_NULL;
@@ -673,10 +639,10 @@ STATIC void rt_load_method_maybe(mp_obj_t base, qstr attr, mp_obj_t *dest) {
}
}
-void rt_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
+void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
DEBUG_OP_printf("load method %p.%s\n", base, qstr_str(attr));
- rt_load_method_maybe(base, attr, dest);
+ mp_load_method_maybe(base, attr, dest);
if (dest[0] == MP_OBJ_NULL) {
// no attribute/method called attr
@@ -690,7 +656,7 @@ void rt_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
}
}
-void rt_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
+void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
DEBUG_OP_printf("store attr %p.%s <- %p\n", base, qstr_str(attr), value);
mp_obj_type_t *type = mp_obj_get_type(base);
if (type->store_attr != NULL) {
@@ -701,7 +667,7 @@ void rt_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_AttributeError, "'%s' object has no attribute '%s'", mp_obj_get_type_str(base), qstr_str(attr)));
}
-void rt_store_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
+void mp_store_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
DEBUG_OP_printf("store subscr %p[%p] <- %p\n", base, index, value);
if (MP_OBJ_IS_TYPE(base, &mp_type_list)) {
// list store
@@ -722,19 +688,19 @@ void rt_store_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
}
}
-mp_obj_t rt_getiter(mp_obj_t o_in) {
+mp_obj_t mp_getiter(mp_obj_t o_in) {
mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->getiter != NULL) {
return type->getiter(o_in);
} else {
// check for __iter__ method
mp_obj_t dest[2];
- rt_load_method_maybe(o_in, MP_QSTR___iter__, dest);
+ mp_load_method_maybe(o_in, MP_QSTR___iter__, dest);
if (dest[0] != MP_OBJ_NULL) {
// __iter__ exists, call it and return its result
- return rt_call_method_n_kw(0, 0, dest);
+ return mp_call_method_n_kw(0, 0, dest);
} else {
- rt_load_method_maybe(o_in, MP_QSTR___getitem__, dest);
+ mp_load_method_maybe(o_in, MP_QSTR___getitem__, dest);
if (dest[0] != MP_OBJ_NULL) {
// __getitem__ exists, create an iterator
return mp_obj_new_getitem_iter(dest);
@@ -748,17 +714,17 @@ mp_obj_t rt_getiter(mp_obj_t o_in) {
// may return MP_OBJ_NULL as an optimisation instead of raise StopIteration()
// may also raise StopIteration()
-mp_obj_t rt_iternext_allow_raise(mp_obj_t o_in) {
+mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->iternext != NULL) {
return type->iternext(o_in);
} else {
// check for __next__ method
mp_obj_t dest[2];
- rt_load_method_maybe(o_in, MP_QSTR___next__, dest);
+ mp_load_method_maybe(o_in, MP_QSTR___next__, dest);
if (dest[0] != MP_OBJ_NULL) {
// __next__ exists, call it and return its result
- return rt_call_method_n_kw(0, 0, dest);
+ return mp_call_method_n_kw(0, 0, dest);
} else {
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "'%s' object is not an iterator", mp_obj_get_type_str(o_in)));
}
@@ -767,19 +733,19 @@ mp_obj_t rt_iternext_allow_raise(mp_obj_t o_in) {
// will always return MP_OBJ_NULL instead of raising StopIteration() (or any subclass thereof)
// may raise other exceptions
-mp_obj_t rt_iternext(mp_obj_t o_in) {
+mp_obj_t mp_iternext(mp_obj_t o_in) {
mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->iternext != NULL) {
return type->iternext(o_in);
} else {
// check for __next__ method
mp_obj_t dest[2];
- rt_load_method_maybe(o_in, MP_QSTR___next__, dest);
+ mp_load_method_maybe(o_in, MP_QSTR___next__, dest);
if (dest[0] != MP_OBJ_NULL) {
// __next__ exists, call it and return its result
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
- mp_obj_t ret = rt_call_method_n_kw(0, 0, dest);
+ mp_obj_t ret = mp_call_method_n_kw(0, 0, dest);
nlr_pop();
return ret;
} else {
@@ -795,14 +761,14 @@ mp_obj_t rt_iternext(mp_obj_t o_in) {
}
}
-mp_obj_t rt_make_raise_obj(mp_obj_t o) {
+mp_obj_t mp_make_raise_obj(mp_obj_t o) {
DEBUG_printf("raise %p\n", o);
if (mp_obj_is_exception_type(o)) {
// o is an exception type (it is derived from BaseException (or is BaseException))
// create and return a new exception instance by calling o
// TODO could have an option to disable traceback, then builtin exceptions (eg TypeError)
// could have const instances in ROM which we return here instead
- return rt_call_function_n_kw(o, 0, 0, NULL);
+ return mp_call_function_n_kw(o, 0, 0, NULL);
} else if (mp_obj_is_exception_instance(o)) {
// o is an instance of an exception, so use it as the exception
return o;
@@ -812,7 +778,7 @@ mp_obj_t rt_make_raise_obj(mp_obj_t o) {
}
}
-mp_obj_t rt_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
+mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
DEBUG_printf("import name %s\n", qstr_str(name));
// build args array
@@ -827,10 +793,10 @@ mp_obj_t rt_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
return mp_builtin___import__(5, args);
}
-mp_obj_t rt_import_from(mp_obj_t module, qstr name) {
+mp_obj_t mp_import_from(mp_obj_t module, qstr name) {
DEBUG_printf("import from %p %s\n", module, qstr_str(name));
- mp_obj_t x = rt_load_attr(module, name);
+ mp_obj_t x = mp_load_attr(module, name);
/* TODO convert AttributeError to ImportError
if (fail) {
(ImportError, "cannot import name %s", qstr_str(name), NULL)
@@ -839,66 +805,66 @@ mp_obj_t rt_import_from(mp_obj_t module, qstr name) {
return x;
}
-void rt_import_all(mp_obj_t module) {
+void mp_import_all(mp_obj_t module) {
DEBUG_printf("import all %p\n", module);
mp_map_t *map = mp_obj_module_get_globals(module);
for (uint i = 0; i < map->alloc; i++) {
if (map->table[i].key != MP_OBJ_NULL) {
- rt_store_name(MP_OBJ_QSTR_VALUE(map->table[i].key), map->table[i].value);
+ mp_store_name(MP_OBJ_QSTR_VALUE(map->table[i].key), map->table[i].value);
}
}
}
-mp_map_t *rt_locals_get(void) {
+mp_map_t *mp_locals_get(void) {
return map_locals;
}
-void rt_locals_set(mp_map_t *m) {
- DEBUG_OP_printf("rt_locals_set(%p)\n", m);
+void mp_locals_set(mp_map_t *m) {
+ DEBUG_OP_printf("mp_locals_set(%p)\n", m);
map_locals = m;
}
-mp_map_t *rt_globals_get(void) {
+mp_map_t *mp_globals_get(void) {
return map_globals;
}
-void rt_globals_set(mp_map_t *m) {
- DEBUG_OP_printf("rt_globals_set(%p)\n", m);
+void mp_globals_set(mp_map_t *m) {
+ DEBUG_OP_printf("mp_globals_set(%p)\n", m);
map_globals = m;
}
// these must correspond to the respective enum
-void *const rt_fun_table[RT_F_NUMBER_OF] = {
- rt_load_const_dec,
- rt_load_const_str,
- rt_load_name,
- rt_load_global,
- rt_load_build_class,
- rt_load_attr,
- rt_load_method,
- rt_store_name,
- rt_store_attr,
- rt_store_subscr,
- rt_is_true,
- rt_unary_op,
- rt_binary_op,
- rt_build_tuple,
- rt_build_list,
- rt_list_append,
- rt_build_map,
- rt_store_map,
- rt_build_set,
- rt_store_set,
- rt_make_function_from_id,
- rt_call_function_n_kw_for_native,
- rt_call_method_n_kw,
- rt_getiter,
- rt_iternext,
+void *const mp_fun_table[MP_F_NUMBER_OF] = {
+ mp_load_const_dec,
+ mp_load_const_str,
+ mp_load_name,
+ mp_load_global,
+ mp_load_build_class,
+ mp_load_attr,
+ mp_load_method,
+ mp_store_name,
+ mp_store_attr,
+ mp_store_subscr,
+ mp_obj_is_true,
+ mp_unary_op,
+ mp_binary_op,
+ mp_build_tuple,
+ mp_build_list,
+ mp_list_append,
+ mp_build_map,
+ mp_store_map,
+ mp_build_set,
+ mp_store_set,
+ mp_make_function_from_id,
+ mp_call_function_n_kw_for_native,
+ mp_call_method_n_kw,
+ mp_getiter,
+ mp_iternext,
};
/*
-void rt_f_vector(rt_fun_kind_t fun_kind) {
- (rt_f_table[fun_kind])();
+void mp_f_vector(mp_fun_kind_t fun_kind) {
+ (mp_f_table[fun_kind])();
}
*/
diff --git a/py/runtime.h b/py/runtime.h
index a8f83e529dd1db2c5fda2b8c63c61091f881fdb5..1934ccd1e46139abde32303b0c9ef7f297520f0b 100644
--- a/py/runtime.h
+++ b/py/runtime.h
@@ -1,58 +1,64 @@
-void rt_init(void);
-void rt_deinit(void);
-
-void rt_check_nargs(int n_args, machine_uint_t n_args_min, machine_uint_t n_args_max, int n_kw, bool is_kw);
-
-int rt_is_true(mp_obj_t arg);
-
-mp_obj_t rt_load_const_dec(qstr qstr);
-mp_obj_t rt_load_const_str(qstr qstr);
-mp_obj_t rt_load_const_bytes(qstr qstr);
-mp_obj_t rt_load_name(qstr qstr);
-mp_obj_t rt_load_global(qstr qstr);
-mp_obj_t rt_load_build_class(void);
-mp_obj_t rt_get_cell(mp_obj_t cell);
-void rt_set_cell(mp_obj_t cell, mp_obj_t val);
-void rt_store_name(qstr qstr, mp_obj_t obj);
-void rt_store_global(qstr qstr, mp_obj_t obj);
-void rt_delete_name(qstr qstr);
-mp_obj_t rt_unary_op(int op, mp_obj_t arg);
-mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs);
-mp_obj_t rt_make_function_from_id(uint unique_code_id, bool free_unique_code, mp_obj_t def_args);
-mp_obj_t rt_make_function_n(int n_args, void *fun); // fun must have the correct signature for n_args fixed arguments
-mp_obj_t rt_make_function_var(int n_args_min, mp_fun_var_t fun);
-mp_obj_t rt_make_function_var_between(int n_args_min, int n_args_max, mp_fun_var_t fun); // min and max are inclusive
-mp_obj_t rt_make_closure_from_id(uint unique_code_id, mp_obj_t closure_tuple, mp_obj_t def_args);
-mp_obj_t rt_call_function_0(mp_obj_t fun);
-mp_obj_t rt_call_function_1(mp_obj_t fun, mp_obj_t arg);
-mp_obj_t rt_call_function_2(mp_obj_t fun, mp_obj_t arg1, mp_obj_t arg2);
-mp_obj_t rt_call_function_n_kw_for_native(mp_obj_t fun_in, uint n_args_kw, const mp_obj_t *args);
-mp_obj_t rt_call_function_n_kw(mp_obj_t fun, uint n_args, uint n_kw, const mp_obj_t *args);
-mp_obj_t rt_call_method_n_kw(uint n_args, uint n_kw, const mp_obj_t *args);
-mp_obj_t rt_build_tuple(int n_args, mp_obj_t *items);
-mp_obj_t rt_build_list(int n_args, mp_obj_t *items);
-mp_obj_t rt_list_append(mp_obj_t list, mp_obj_t arg);
-mp_obj_t rt_build_set(int n_args, mp_obj_t *items);
-mp_obj_t rt_store_set(mp_obj_t set, mp_obj_t item);
-void rt_unpack_sequence(mp_obj_t seq, uint num, mp_obj_t *items);
-mp_obj_t rt_build_map(int n_args);
-mp_obj_t rt_store_map(mp_obj_t map, mp_obj_t key, mp_obj_t value);
-mp_obj_t rt_load_attr(mp_obj_t base, qstr attr);
-void rt_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest);
-void rt_store_attr(mp_obj_t base, qstr attr, mp_obj_t val);
-void rt_store_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t val);
-mp_obj_t rt_getiter(mp_obj_t o);
-mp_obj_t rt_iternext_allow_raise(mp_obj_t o); // may return MP_OBJ_NULL instead of raising StopIteration()
-mp_obj_t rt_iternext(mp_obj_t o); // will always return MP_OBJ_NULL instead of raising StopIteration(...)
-mp_obj_t rt_make_raise_obj(mp_obj_t o);
-mp_obj_t rt_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level);
-mp_obj_t rt_import_from(mp_obj_t module, qstr name);
-void rt_import_all(mp_obj_t module);
-
-struct _mp_map_t;
-struct _mp_map_t *rt_locals_get(void);
-void rt_locals_set(struct _mp_map_t *m);
-struct _mp_map_t *rt_globals_get(void);
-void rt_globals_set(struct _mp_map_t *m);
-struct _mp_map_t *rt_loaded_modules_get(void);
-extern mp_obj_t sys_path;
+void mp_init(void);
+void mp_deinit(void);
+
+void mp_check_nargs(int n_args, machine_uint_t n_args_min, machine_uint_t n_args_max, int n_kw, bool is_kw);
+
+struct _mp_map_t *mp_locals_get(void);
+void mp_locals_set(struct _mp_map_t *m);
+struct _mp_map_t *mp_globals_get(void);
+void mp_globals_set(struct _mp_map_t *m);
+
+mp_obj_t mp_load_name(qstr qstr);
+mp_obj_t mp_load_global(qstr qstr);
+mp_obj_t mp_load_build_class(void);
+void mp_store_name(qstr qstr, mp_obj_t obj);
+void mp_store_global(qstr qstr, mp_obj_t obj);
+void mp_delete_name(qstr qstr);
+
+mp_obj_t mp_unary_op(int op, mp_obj_t arg);
+mp_obj_t mp_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs);
+
+mp_obj_t mp_load_const_dec(qstr qstr);
+mp_obj_t mp_load_const_str(qstr qstr);
+mp_obj_t mp_load_const_bytes(qstr qstr);
+
+mp_obj_t mp_get_cell(mp_obj_t cell);
+void mp_set_cell(mp_obj_t cell, mp_obj_t val);
+
+mp_obj_t mp_make_function_from_id(uint unique_code_id, bool free_unique_code, mp_obj_t def_args);
+mp_obj_t mp_make_function_n(int n_args, void *fun); // fun must have the correct signature for n_args fixed arguments
+mp_obj_t mp_make_function_var(int n_args_min, mp_fun_var_t fun);
+mp_obj_t mp_make_function_var_between(int n_args_min, int n_args_max, mp_fun_var_t fun); // min and max are inclusive
+mp_obj_t mp_make_closure_from_id(uint unique_code_id, mp_obj_t closure_tuple, mp_obj_t def_args);
+
+mp_obj_t mp_call_function_0(mp_obj_t fun);
+mp_obj_t mp_call_function_1(mp_obj_t fun, mp_obj_t arg);
+mp_obj_t mp_call_function_2(mp_obj_t fun, mp_obj_t arg1, mp_obj_t arg2);
+mp_obj_t mp_call_function_n_kw_for_native(mp_obj_t fun_in, uint n_args_kw, const mp_obj_t *args);
+mp_obj_t mp_call_function_n_kw(mp_obj_t fun, uint n_args, uint n_kw, const mp_obj_t *args);
+mp_obj_t mp_call_method_n_kw(uint n_args, uint n_kw, const mp_obj_t *args);
+
+mp_obj_t mp_build_tuple(int n_args, mp_obj_t *items);
+mp_obj_t mp_build_list(int n_args, mp_obj_t *items);
+mp_obj_t mp_list_append(mp_obj_t list, mp_obj_t arg);
+mp_obj_t mp_build_set(int n_args, mp_obj_t *items);
+mp_obj_t mp_store_set(mp_obj_t set, mp_obj_t item);
+void mp_unpack_sequence(mp_obj_t seq, uint num, mp_obj_t *items);
+mp_obj_t mp_build_map(int n_args);
+mp_obj_t mp_store_map(mp_obj_t map, mp_obj_t key, mp_obj_t value);
+mp_obj_t mp_load_attr(mp_obj_t base, qstr attr);
+void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest);
+void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t val);
+void mp_store_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t val);
+
+mp_obj_t mp_getiter(mp_obj_t o);
+mp_obj_t mp_iternext_allow_raise(mp_obj_t o); // may return MP_OBJ_NULL instead of raising StopIteration()
+mp_obj_t mp_iternext(mp_obj_t o); // will always return MP_OBJ_NULL instead of raising StopIteration(...)
+
+mp_obj_t mp_make_raise_obj(mp_obj_t o);
+
+extern mp_obj_t mp_sys_path;
+struct _mp_map_t *mp_loaded_modules_get(void);
+mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level);
+mp_obj_t mp_import_from(mp_obj_t module, qstr name);
+void mp_import_all(mp_obj_t module);
diff --git a/py/runtime0.h b/py/runtime0.h
index a650e704ae1feb8cfd7b01241517fdbb7fc4494f..8a78a2304bbeb53b9b3adc77ad04040ee66a12f2 100644
--- a/py/runtime0.h
+++ b/py/runtime0.h
@@ -13,83 +13,83 @@
#define MP_SCOPE_FLAG_NOFREE 0x40
typedef enum {
- RT_UNARY_OP_BOOL, // __bool__
- RT_UNARY_OP_LEN, // __len__
- RT_UNARY_OP_POSITIVE,
- RT_UNARY_OP_NEGATIVE,
- RT_UNARY_OP_INVERT,
+ MP_UNARY_OP_BOOL, // __bool__
+ MP_UNARY_OP_LEN, // __len__
+ MP_UNARY_OP_POSITIVE,
+ MP_UNARY_OP_NEGATIVE,
+ MP_UNARY_OP_INVERT,
// these are not supported by the runtime and must be synthesised by the emitter
- RT_UNARY_OP_NOT,
-} rt_unary_op_t;
+ MP_UNARY_OP_NOT,
+} mp_unary_op_t;
typedef enum {
- RT_BINARY_OP_SUBSCR,
- RT_BINARY_OP_OR,
- RT_BINARY_OP_XOR,
- RT_BINARY_OP_AND,
- RT_BINARY_OP_LSHIFT,
- RT_BINARY_OP_RSHIFT,
- RT_BINARY_OP_ADD,
- RT_BINARY_OP_SUBTRACT,
- RT_BINARY_OP_MULTIPLY,
- RT_BINARY_OP_FLOOR_DIVIDE,
- RT_BINARY_OP_TRUE_DIVIDE,
- RT_BINARY_OP_MODULO,
- RT_BINARY_OP_POWER,
- RT_BINARY_OP_INPLACE_OR,
- RT_BINARY_OP_INPLACE_XOR,
- RT_BINARY_OP_INPLACE_AND,
- RT_BINARY_OP_INPLACE_LSHIFT,
- RT_BINARY_OP_INPLACE_RSHIFT,
- RT_BINARY_OP_INPLACE_ADD,
- RT_BINARY_OP_INPLACE_SUBTRACT,
- RT_BINARY_OP_INPLACE_MULTIPLY,
- RT_BINARY_OP_INPLACE_FLOOR_DIVIDE,
- RT_BINARY_OP_INPLACE_TRUE_DIVIDE,
- RT_BINARY_OP_INPLACE_MODULO,
- RT_BINARY_OP_INPLACE_POWER,
+ MP_BINARY_OP_SUBSCR,
+ MP_BINARY_OP_OR,
+ MP_BINARY_OP_XOR,
+ MP_BINARY_OP_AND,
+ MP_BINARY_OP_LSHIFT,
+ MP_BINARY_OP_RSHIFT,
+ MP_BINARY_OP_ADD,
+ MP_BINARY_OP_SUBTRACT,
+ MP_BINARY_OP_MULTIPLY,
+ MP_BINARY_OP_FLOOR_DIVIDE,
+ MP_BINARY_OP_TRUE_DIVIDE,
+ MP_BINARY_OP_MODULO,
+ MP_BINARY_OP_POWER,
+ MP_BINARY_OP_INPLACE_OR,
+ MP_BINARY_OP_INPLACE_XOR,
+ MP_BINARY_OP_INPLACE_AND,
+ MP_BINARY_OP_INPLACE_LSHIFT,
+ MP_BINARY_OP_INPLACE_RSHIFT,
+ MP_BINARY_OP_INPLACE_ADD,
+ MP_BINARY_OP_INPLACE_SUBTRACT,
+ MP_BINARY_OP_INPLACE_MULTIPLY,
+ MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
+ MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
+ MP_BINARY_OP_INPLACE_MODULO,
+ MP_BINARY_OP_INPLACE_POWER,
// these should return a bool
- RT_BINARY_OP_LESS,
- RT_BINARY_OP_MORE,
- RT_BINARY_OP_EQUAL,
- RT_BINARY_OP_LESS_EQUAL,
- RT_BINARY_OP_MORE_EQUAL,
- RT_BINARY_OP_NOT_EQUAL,
- RT_BINARY_OP_IN,
- RT_BINARY_OP_IS,
- RT_BINARY_OP_EXCEPTION_MATCH,
+ MP_BINARY_OP_LESS,
+ MP_BINARY_OP_MORE,
+ MP_BINARY_OP_EQUAL,
+ MP_BINARY_OP_LESS_EQUAL,
+ MP_BINARY_OP_MORE_EQUAL,
+ MP_BINARY_OP_NOT_EQUAL,
+ MP_BINARY_OP_IN,
+ MP_BINARY_OP_IS,
+ MP_BINARY_OP_EXCEPTION_MATCH,
// these are not supported by the runtime and must be synthesised by the emitter
- RT_BINARY_OP_NOT_IN,
- RT_BINARY_OP_IS_NOT,
-} rt_binary_op_t;
+ MP_BINARY_OP_NOT_IN,
+ MP_BINARY_OP_IS_NOT,
+} mp_binary_op_t;
typedef enum {
- RT_F_LOAD_CONST_DEC = 0,
- RT_F_LOAD_CONST_STR,
- RT_F_LOAD_NAME,
- RT_F_LOAD_GLOBAL,
- RT_F_LOAD_BUILD_CLASS,
- RT_F_LOAD_ATTR,
- RT_F_LOAD_METHOD,
- RT_F_STORE_NAME,
- RT_F_STORE_ATTR,
- RT_F_STORE_SUBSCR,
- RT_F_IS_TRUE,
- RT_F_UNARY_OP,
- RT_F_BINARY_OP,
- RT_F_BUILD_TUPLE,
- RT_F_BUILD_LIST,
- RT_F_LIST_APPEND,
- RT_F_BUILD_MAP,
- RT_F_STORE_MAP,
- RT_F_BUILD_SET,
- RT_F_STORE_SET,
- RT_F_MAKE_FUNCTION_FROM_ID,
- RT_F_CALL_FUNCTION_N_KW_FOR_NATIVE,
- RT_F_CALL_METHOD_N_KW,
- RT_F_GETITER,
- RT_F_ITERNEXT,
- RT_F_NUMBER_OF,
-} rt_fun_kind_t;
+ MP_F_LOAD_CONST_DEC = 0,
+ MP_F_LOAD_CONST_STR,
+ MP_F_LOAD_NAME,
+ MP_F_LOAD_GLOBAL,
+ MP_F_LOAD_BUILD_CLASS,
+ MP_F_LOAD_ATTR,
+ MP_F_LOAD_METHOD,
+ MP_F_STORE_NAME,
+ MP_F_STORE_ATTR,
+ MP_F_STORE_SUBSCR,
+ MP_F_OBJ_IS_TRUE,
+ MP_F_UNARY_OP,
+ MP_F_BINARY_OP,
+ MP_F_BUILD_TUPLE,
+ MP_F_BUILD_LIST,
+ MP_F_LIST_APPEND,
+ MP_F_BUILD_MAP,
+ MP_F_STORE_MAP,
+ MP_F_BUILD_SET,
+ MP_F_STORE_SET,
+ MP_F_MAKE_FUNCTION_FROM_ID,
+ MP_F_CALL_FUNCTION_N_KW_FOR_NATIVE,
+ MP_F_CALL_METHOD_N_KW,
+ MP_F_GETITER,
+ MP_F_ITERNEXT,
+ MP_F_NUMBER_OF,
+} mp_fun_kind_t;
-extern void *const rt_fun_table[RT_F_NUMBER_OF];
+extern void *const mp_fun_table[MP_F_NUMBER_OF];
diff --git a/py/sequence.c b/py/sequence.c
index 184c34e0b89c78f9c36012b8a139d19f65c303ec..8810a47d9743c80a1a8bfb1aa84ed7087978731a 100644
--- a/py/sequence.c
+++ b/py/sequence.c
@@ -55,16 +55,16 @@ bool m_seq_get_fast_slice_indexes(machine_uint_t len, mp_obj_t slice, machine_ui
}
// Special-case comparison function for sequences of bytes
-// Don't pass RT_BINARY_OP_NOT_EQUAL here
+// Don't pass MP_BINARY_OP_NOT_EQUAL here
bool mp_seq_cmp_bytes(int op, const byte *data1, uint len1, const byte *data2, uint len2) {
// Let's deal only with > & >=
- if (op == RT_BINARY_OP_LESS || op == RT_BINARY_OP_LESS_EQUAL) {
+ if (op == MP_BINARY_OP_LESS || op == MP_BINARY_OP_LESS_EQUAL) {
SWAP(const byte*, data1, data2);
SWAP(uint, len1, len2);
- if (op == RT_BINARY_OP_LESS) {
- op = RT_BINARY_OP_MORE;
+ if (op == MP_BINARY_OP_LESS) {
+ op = MP_BINARY_OP_MORE;
} else {
- op = RT_BINARY_OP_MORE_EQUAL;
+ op = MP_BINARY_OP_MORE_EQUAL;
}
}
uint min_len = len1 < len2 ? len1 : len2;
@@ -83,7 +83,7 @@ bool mp_seq_cmp_bytes(int op, const byte *data1, uint len1, const byte *data2, u
// ... then longer list length wins (we deal only with >)
return false;
}
- } else if (op == RT_BINARY_OP_MORE) {
+ } else if (op == MP_BINARY_OP_MORE) {
// Otherwise, if we have strict relation, equality means failure
return false;
}
@@ -91,20 +91,20 @@ bool mp_seq_cmp_bytes(int op, const byte *data1, uint len1, const byte *data2, u
}
// Special-case comparison function for sequences of mp_obj_t
-// Don't pass RT_BINARY_OP_NOT_EQUAL here
+// Don't pass MP_BINARY_OP_NOT_EQUAL here
bool mp_seq_cmp_objs(int op, const mp_obj_t *items1, uint len1, const mp_obj_t *items2, uint len2) {
- if (op == RT_BINARY_OP_EQUAL && len1 != len2) {
+ if (op == MP_BINARY_OP_EQUAL && len1 != len2) {
return false;
}
// Let's deal only with > & >=
- if (op == RT_BINARY_OP_LESS || op == RT_BINARY_OP_LESS_EQUAL) {
+ if (op == MP_BINARY_OP_LESS || op == MP_BINARY_OP_LESS_EQUAL) {
SWAP(const mp_obj_t *, items1, items2);
SWAP(uint, len1, len2);
- if (op == RT_BINARY_OP_LESS) {
- op = RT_BINARY_OP_MORE;
+ if (op == MP_BINARY_OP_LESS) {
+ op = MP_BINARY_OP_MORE;
} else {
- op = RT_BINARY_OP_MORE_EQUAL;
+ op = MP_BINARY_OP_MORE_EQUAL;
}
}
@@ -113,10 +113,10 @@ bool mp_seq_cmp_objs(int op, const mp_obj_t *items1, uint len1, const mp_obj_t *
bool rel_status;
for (int i = 0; i < len; i++) {
eq_status = mp_obj_equal(items1[i], items2[i]);
- if (op == RT_BINARY_OP_EQUAL && !eq_status) {
+ if (op == MP_BINARY_OP_EQUAL && !eq_status) {
return false;
}
- rel_status = (rt_binary_op(op, items1[i], items2[i]) == mp_const_true);
+ rel_status = (mp_binary_op(op, items1[i], items2[i]) == mp_const_true);
if (!eq_status && !rel_status) {
return false;
}
@@ -130,7 +130,7 @@ bool mp_seq_cmp_objs(int op, const mp_obj_t *items1, uint len1, const mp_obj_t *
// ... then longer list length wins (we deal only with >)
return false;
}
- } else if (op == RT_BINARY_OP_MORE) {
+ } else if (op == MP_BINARY_OP_MORE) {
// Otherwise, if we have strict relation, equality means failure
return false;
}
diff --git a/py/vm.c b/py/vm.c
index c6260457af3c57aedb93556d2ce29a7f0fc8b197..bcd13389e9fbabcd9d160c18dc243df7d809fb30 100644
--- a/py/vm.c
+++ b/py/vm.c
@@ -157,7 +157,7 @@ outer_dispatch_loop:
if (inject_exc != MP_OBJ_NULL && *ip != MP_BC_YIELD_FROM) {
mp_obj_t t = inject_exc;
inject_exc = MP_OBJ_NULL;
- nlr_jump(rt_make_raise_obj(t));
+ nlr_jump(mp_make_raise_obj(t));
}
// loop to execute byte code
for (;;) {
@@ -201,22 +201,22 @@ dispatch_loop:
case MP_BC_LOAD_CONST_DEC:
DECODE_QSTR;
- PUSH(rt_load_const_dec(qst));
+ PUSH(mp_load_const_dec(qst));
break;
case MP_BC_LOAD_CONST_ID:
DECODE_QSTR;
- PUSH(rt_load_const_str(qst)); // TODO
+ PUSH(mp_load_const_str(qst)); // TODO
break;
case MP_BC_LOAD_CONST_BYTES:
DECODE_QSTR;
- PUSH(rt_load_const_bytes(qst));
+ PUSH(mp_load_const_bytes(qst));
break;
case MP_BC_LOAD_CONST_STRING:
DECODE_QSTR;
- PUSH(rt_load_const_str(qst));
+ PUSH(mp_load_const_str(qst));
break;
case MP_BC_LOAD_FAST_0:
@@ -238,32 +238,32 @@ dispatch_loop:
case MP_BC_LOAD_DEREF:
DECODE_UINT;
- PUSH(rt_get_cell(fastn[-unum]));
+ PUSH(mp_get_cell(fastn[-unum]));
break;
case MP_BC_LOAD_NAME:
DECODE_QSTR;
- PUSH(rt_load_name(qst));
+ PUSH(mp_load_name(qst));
break;
case MP_BC_LOAD_GLOBAL:
DECODE_QSTR;
- PUSH(rt_load_global(qst));
+ PUSH(mp_load_global(qst));
break;
case MP_BC_LOAD_ATTR:
DECODE_QSTR;
- SET_TOP(rt_load_attr(TOP(), qst));
+ SET_TOP(mp_load_attr(TOP(), qst));
break;
case MP_BC_LOAD_METHOD:
DECODE_QSTR;
- rt_load_method(*sp, qst, sp);
+ mp_load_method(*sp, qst, sp);
sp += 1;
break;
case MP_BC_LOAD_BUILD_CLASS:
- PUSH(rt_load_build_class());
+ PUSH(mp_load_build_class());
break;
case MP_BC_STORE_FAST_0:
@@ -285,33 +285,33 @@ dispatch_loop:
case MP_BC_STORE_DEREF:
DECODE_UINT;
- rt_set_cell(fastn[-unum], POP());
+ mp_set_cell(fastn[-unum], POP());
break;
case MP_BC_STORE_NAME:
DECODE_QSTR;
- rt_store_name(qst, POP());
+ mp_store_name(qst, POP());
break;
case MP_BC_STORE_GLOBAL:
DECODE_QSTR;
- rt_store_global(qst, POP());
+ mp_store_global(qst, POP());
break;
case MP_BC_STORE_ATTR:
DECODE_QSTR;
- rt_store_attr(sp[0], qst, sp[-1]);
+ mp_store_attr(sp[0], qst, sp[-1]);
sp -= 2;
break;
case MP_BC_STORE_SUBSCR:
- rt_store_subscr(sp[-1], sp[0], sp[-2]);
+ mp_store_subscr(sp[-1], sp[0], sp[-2]);
sp -= 3;
break;
case MP_BC_DELETE_NAME:
DECODE_QSTR;
- rt_delete_name(qst);
+ mp_delete_name(qst);
break;
case MP_BC_DUP_TOP:
@@ -349,21 +349,21 @@ dispatch_loop:
case MP_BC_POP_JUMP_IF_TRUE:
DECODE_SLABEL;
- if (rt_is_true(POP())) {
+ if (mp_obj_is_true(POP())) {
ip += unum;
}
break;
case MP_BC_POP_JUMP_IF_FALSE:
DECODE_SLABEL;
- if (!rt_is_true(POP())) {
+ if (!mp_obj_is_true(POP())) {
ip += unum;
}
break;
case MP_BC_JUMP_IF_TRUE_OR_POP:
DECODE_SLABEL;
- if (rt_is_true(TOP())) {
+ if (mp_obj_is_true(TOP())) {
ip += unum;
} else {
sp--;
@@ -372,7 +372,7 @@ dispatch_loop:
case MP_BC_JUMP_IF_FALSE_OR_POP:
DECODE_SLABEL;
- if (rt_is_true(TOP())) {
+ if (mp_obj_is_true(TOP())) {
sp--;
} else {
ip += unum;
@@ -388,9 +388,9 @@ dispatch_loop:
case MP_BC_SETUP_WITH:
obj1 = TOP();
- SET_TOP(rt_load_attr(obj1, MP_QSTR___exit__));
- rt_load_method(obj1, MP_QSTR___enter__, sp + 1);
- obj2 = rt_call_method_n_kw(0, 0, sp + 1);
+ SET_TOP(mp_load_attr(obj1, MP_QSTR___exit__));
+ mp_load_method(obj1, MP_QSTR___enter__, sp + 1);
+ obj2 = mp_call_method_n_kw(0, 0, sp + 1);
PUSH_EXC_BLOCK();
PUSH(obj2);
break;
@@ -405,19 +405,19 @@ dispatch_loop:
sp--;
obj1 = TOP();
SET_TOP(mp_const_none);
- obj2 = rt_call_function_n_kw(obj1, 3, 0, no_exc);
+ obj2 = mp_call_function_n_kw(obj1, 3, 0, no_exc);
} else if (MP_OBJ_IS_SMALL_INT(TOP())) {
mp_obj_t cause = POP();
switch (MP_OBJ_SMALL_INT_VALUE(cause)) {
case UNWIND_RETURN: {
mp_obj_t retval = POP();
- obj2 = rt_call_function_n_kw(TOP(), 3, 0, no_exc);
+ obj2 = mp_call_function_n_kw(TOP(), 3, 0, no_exc);
SET_TOP(retval);
PUSH(cause);
break;
}
case UNWIND_JUMP: {
- obj2 = rt_call_function_n_kw(sp[-2], 3, 0, no_exc);
+ obj2 = mp_call_function_n_kw(sp[-2], 3, 0, no_exc);
// Pop __exit__ boundmethod at sp[-2]
sp[-2] = sp[-1];
sp[-1] = sp[0];
@@ -429,14 +429,14 @@ dispatch_loop:
}
} else if (mp_obj_is_exception_type(TOP())) {
mp_obj_t args[3] = {sp[0], sp[-1], sp[-2]};
- obj2 = rt_call_function_n_kw(sp[-3], 3, 0, args);
+ obj2 = mp_call_function_n_kw(sp[-3], 3, 0, args);
// Pop __exit__ boundmethod at sp[-3]
// TODO: Once semantics is proven, optimize for case when obj2 == True
sp[-3] = sp[-2];
sp[-2] = sp[-1];
sp[-1] = sp[0];
sp--;
- if (rt_is_true(obj2)) {
+ if (mp_obj_is_true(obj2)) {
// This is what CPython does
//PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_SILENCED));
// But what we need to do is - pop exception from value stack...
@@ -514,12 +514,12 @@ unwind_jump:
break;
case MP_BC_GET_ITER:
- SET_TOP(rt_getiter(TOP()));
+ SET_TOP(mp_getiter(TOP()));
break;
case MP_BC_FOR_ITER:
DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
- obj1 = rt_iternext_allow_raise(TOP());
+ obj1 = mp_iternext_allow_raise(TOP());
if (obj1 == MP_OBJ_NULL) {
--sp; // pop the exhausted iterator
ip += unum; // jump to after for-block
@@ -557,62 +557,62 @@ unwind_jump:
case MP_BC_UNARY_OP:
unum = *ip++;
- SET_TOP(rt_unary_op(unum, TOP()));
+ SET_TOP(mp_unary_op(unum, TOP()));
break;
case MP_BC_BINARY_OP:
unum = *ip++;
obj2 = POP();
obj1 = TOP();
- SET_TOP(rt_binary_op(unum, obj1, obj2));
+ SET_TOP(mp_binary_op(unum, obj1, obj2));
break;
case MP_BC_BUILD_TUPLE:
DECODE_UINT;
sp -= unum - 1;
- SET_TOP(rt_build_tuple(unum, sp));
+ SET_TOP(mp_build_tuple(unum, sp));
break;
case MP_BC_BUILD_LIST:
DECODE_UINT;
sp -= unum - 1;
- SET_TOP(rt_build_list(unum, sp));
+ SET_TOP(mp_build_list(unum, sp));
break;
case MP_BC_LIST_APPEND:
DECODE_UINT;
// I think it's guaranteed by the compiler that sp[unum] is a list
- rt_list_append(sp[-unum], sp[0]);
+ mp_list_append(sp[-unum], sp[0]);
sp--;
break;
case MP_BC_BUILD_MAP:
DECODE_UINT;
- PUSH(rt_build_map(unum));
+ PUSH(mp_build_map(unum));
break;
case MP_BC_STORE_MAP:
sp -= 2;
- rt_store_map(sp[0], sp[2], sp[1]);
+ mp_store_map(sp[0], sp[2], sp[1]);
break;
case MP_BC_MAP_ADD:
DECODE_UINT;
// I think it's guaranteed by the compiler that sp[-unum - 1] is a map
- rt_store_map(sp[-unum - 1], sp[0], sp[-1]);
+ mp_store_map(sp[-unum - 1], sp[0], sp[-1]);
sp -= 2;
break;
case MP_BC_BUILD_SET:
DECODE_UINT;
sp -= unum - 1;
- SET_TOP(rt_build_set(unum, sp));
+ SET_TOP(mp_build_set(unum, sp));
break;
case MP_BC_SET_ADD:
DECODE_UINT;
// I think it's guaranteed by the compiler that sp[-unum] is a set
- rt_store_set(sp[-unum], sp[0]);
+ mp_store_set(sp[-unum], sp[0]);
sp--;
break;
@@ -632,29 +632,29 @@ unwind_jump:
case MP_BC_UNPACK_SEQUENCE:
DECODE_UINT;
- rt_unpack_sequence(sp[0], unum, sp);
+ mp_unpack_sequence(sp[0], unum, sp);
sp += unum - 1;
break;
case MP_BC_MAKE_FUNCTION:
DECODE_UINT;
- PUSH(rt_make_function_from_id(unum, false, MP_OBJ_NULL));
+ PUSH(mp_make_function_from_id(unum, false, MP_OBJ_NULL));
break;
case MP_BC_MAKE_FUNCTION_DEFARGS:
DECODE_UINT;
- SET_TOP(rt_make_function_from_id(unum, false, TOP()));
+ SET_TOP(mp_make_function_from_id(unum, false, TOP()));
break;
case MP_BC_MAKE_CLOSURE:
DECODE_UINT;
- SET_TOP(rt_make_closure_from_id(unum, TOP(), MP_OBJ_NULL));
+ SET_TOP(mp_make_closure_from_id(unum, TOP(), MP_OBJ_NULL));
break;
case MP_BC_MAKE_CLOSURE_DEFARGS:
DECODE_UINT;
obj1 = POP();
- SET_TOP(rt_make_closure_from_id(unum, obj1, TOP()));
+ SET_TOP(mp_make_closure_from_id(unum, obj1, TOP()));
break;
case MP_BC_CALL_FUNCTION:
@@ -662,7 +662,7 @@ unwind_jump:
// unum & 0xff == n_positional
// (unum >> 8) & 0xff == n_keyword
sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe);
- SET_TOP(rt_call_function_n_kw(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1));
+ SET_TOP(mp_call_function_n_kw(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1));
break;
case MP_BC_CALL_METHOD:
@@ -670,7 +670,7 @@ unwind_jump:
// unum & 0xff == n_positional
// (unum >> 8) & 0xff == n_keyword
sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1;
- SET_TOP(rt_call_method_n_kw(unum & 0xff, (unum >> 8) & 0xff, sp));
+ SET_TOP(mp_call_method_n_kw(unum & 0xff, (unum >> 8) & 0xff, sp));
break;
case MP_BC_RETURN_VALUE:
@@ -714,7 +714,7 @@ unwind_return:
} else {
obj1 = POP();
}
- nlr_jump(rt_make_raise_obj(obj1));
+ nlr_jump(mp_make_raise_obj(obj1));
case MP_BC_YIELD_VALUE:
yield:
@@ -778,17 +778,17 @@ yield:
case MP_BC_IMPORT_NAME:
DECODE_QSTR;
obj1 = POP();
- SET_TOP(rt_import_name(qst, obj1, TOP()));
+ SET_TOP(mp_import_name(qst, obj1, TOP()));
break;
case MP_BC_IMPORT_FROM:
DECODE_QSTR;
- obj1 = rt_import_from(TOP(), qst);
+ obj1 = mp_import_from(TOP(), qst);
PUSH(obj1);
break;
case MP_BC_IMPORT_STAR:
- rt_import_all(POP());
+ mp_import_all(POP());
break;
default:
diff --git a/stm/accel.c b/stm/accel.c
index ae9d5886801aaf22fb0e028d7200d52f5c997487..c55bc6ba2d75149c1e0b4dc4bc9daeb4701357b3 100644
--- a/stm/accel.c
+++ b/stm/accel.c
@@ -268,7 +268,7 @@ mp_obj_t pyb_accel_read(void) {
data[2] = mp_obj_new_int(accel_buf[2] + accel_buf[5] + accel_buf[8] + accel_buf[11]);
data[3] = mp_obj_new_int(jolt_info);
- return rt_build_tuple(4, data);
+ return mp_build_tuple(4, data);
}
MP_DEFINE_CONST_FUN_OBJ_0(pyb_accel_read_obj, pyb_accel_read);
@@ -283,7 +283,7 @@ mp_obj_t pyb_accel_read_all(void) {
}
data[10] = mp_obj_new_int(accel_read_nack());
- return rt_build_tuple(11, data);
+ return mp_build_tuple(11, data);
}
MP_DEFINE_CONST_FUN_OBJ_0(pyb_accel_read_all_obj, pyb_accel_read_all);
diff --git a/stm/exti.c b/stm/exti.c
index 5b8c694a88790b4f4e8a642489ef91202b25c6f1..33821cd18dee33204e165d026868d749e53f453e 100644
--- a/stm/exti.c
+++ b/stm/exti.c
@@ -284,7 +284,7 @@ static void exti_load_attr(mp_obj_t self_in, qstr attr_qstr, mp_obj_t *dest) {
static mp_obj_t exti_call(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// type_in == exti_obj_type
- rt_check_nargs(n_args, 4, 4, n_kw, 0);
+ mp_check_nargs(n_args, 4, 4, n_kw, 0);
exti_obj_t *self = m_new_obj(exti_obj_t);
self->base.type = type_in;
@@ -336,7 +336,7 @@ static void Handle_EXTI_Irq(uint32_t line) {
if (line < EXTI_NUM_VECTORS) {
exti_vector_t *v = &exti_vector[line];
if (v->callback_obj != mp_const_none) {
- rt_call_function_1(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line));
+ mp_call_function_1(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line));
}
}
}
diff --git a/stm/gpio.c b/stm/gpio.c
index 19e7098acc742a1589ae78d007296cfd09033e93..9f9e8e079257b5566d30e81d9a65164ad4f359e6 100644
--- a/stm/gpio.c
+++ b/stm/gpio.c
@@ -46,7 +46,7 @@ mp_obj_t pyb_gpio(uint n_args, mp_obj_t *args) {
}
} else {
// set pin
- if (rt_is_true(args[1])) {
+ if (mp_obj_is_true(args[1])) {
// set pin high
port->BSRRL = pin_mask;
} else {
diff --git a/stm/lcd.c b/stm/lcd.c
index fb12cd4d983effcfde251eda097dd0b0ad6823ce..3c5bdf75da9aea8dde73df35c8190c6435360eed 100644
--- a/stm/lcd.c
+++ b/stm/lcd.c
@@ -209,7 +209,7 @@ mp_obj_t lcd_print(mp_obj_t text) {
mp_obj_t lcd_light(mp_obj_t value) {
#if defined(PYB_LCD_BL_PORT)
- if (rt_is_true(value)) {
+ if (mp_obj_is_true(value)) {
PYB_LCD_BL_PORT->BSRRL = PYB_LCD_BL_PIN; // set pin high to turn backlight on
} else {
PYB_LCD_BL_PORT->BSRRH = PYB_LCD_BL_PIN; // set pin low to turn backlight off
@@ -288,14 +288,14 @@ static mp_obj_t pyb_lcd_init(void) {
// Micro Python interface
mp_obj_t o = mp_obj_new_type(MP_QSTR_LCD, mp_const_empty_tuple, mp_obj_new_dict(0));
- rt_store_attr(o, qstr_from_str("lcd8"), rt_make_function_n(2, lcd_draw_pixel_8));
- rt_store_attr(o, qstr_from_str("clear"), rt_make_function_n(0, lcd_pix_clear));
- rt_store_attr(o, qstr_from_str("get"), rt_make_function_n(2, lcd_pix_get));
- rt_store_attr(o, qstr_from_str("set"), rt_make_function_n(2, lcd_pix_set));
- rt_store_attr(o, qstr_from_str("reset"), rt_make_function_n(2, lcd_pix_reset));
- rt_store_attr(o, qstr_from_str("show"), rt_make_function_n(0, lcd_pix_show));
- rt_store_attr(o, qstr_from_str("text"), rt_make_function_n(1, lcd_print));
- rt_store_attr(o, qstr_from_str("light"), rt_make_function_n(1, lcd_light));
+ mp_store_attr(o, qstr_from_str("lcd8"), mp_make_function_n(2, lcd_draw_pixel_8));
+ mp_store_attr(o, qstr_from_str("clear"), mp_make_function_n(0, lcd_pix_clear));
+ mp_store_attr(o, qstr_from_str("get"), mp_make_function_n(2, lcd_pix_get));
+ mp_store_attr(o, qstr_from_str("set"), mp_make_function_n(2, lcd_pix_set));
+ mp_store_attr(o, qstr_from_str("reset"), mp_make_function_n(2, lcd_pix_reset));
+ mp_store_attr(o, qstr_from_str("show"), mp_make_function_n(0, lcd_pix_show));
+ mp_store_attr(o, qstr_from_str("text"), mp_make_function_n(1, lcd_print));
+ mp_store_attr(o, qstr_from_str("light"), mp_make_function_n(1, lcd_light));
mp_lcd = o;
return o;
}
@@ -304,7 +304,7 @@ static MP_DEFINE_CONST_FUN_OBJ_0(pyb_lcd_init_obj, pyb_lcd_init);
void lcd_init(void) {
mp_lcd = MP_OBJ_NULL;
- rt_store_name(qstr_from_str("LCD"), (mp_obj_t)&pyb_lcd_init_obj);
+ mp_store_name(qstr_from_str("LCD"), (mp_obj_t)&pyb_lcd_init_obj);
}
void lcd_print_str(const char *str) {
diff --git a/stm/main.c b/stm/main.c
index 44be4d348c0c55becab9ccea0494f3460a32df08..a11a813d2dadf5a4189cdf466ddaab126713e1df 100644
--- a/stm/main.c
+++ b/stm/main.c
@@ -233,12 +233,12 @@ soft_reset:
// Micro Python init
qstr_init();
- rt_init();
+ mp_init();
mp_obj_t def_path[3];
def_path[0] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_);
def_path[1] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_src);
def_path[2] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_lib);
- sys_path = mp_obj_new_list(3, def_path);
+ mp_sys_path = mp_obj_new_list(3, def_path);
exti_init();
@@ -270,8 +270,8 @@ soft_reset:
pin_map_init();
// add some functions to the builtin Python namespace
- rt_store_name(MP_QSTR_help, rt_make_function_n(0, pyb_help));
- rt_store_name(MP_QSTR_open, rt_make_function_n(2, pyb_io_open));
+ mp_store_name(MP_QSTR_help, mp_make_function_n(0, pyb_help));
+ mp_store_name(MP_QSTR_open, mp_make_function_n(2, pyb_io_open));
// load the pyb module
mp_module_register(MP_QSTR_pyb, (mp_obj_t)&pyb_module);
diff --git a/stm/pin_map.c b/stm/pin_map.c
index e4b1624a379808ff345cc47d6a8e2a92bda16666..187ed3e63429a4480a0d50e3e6be7d43fd0a5fbe 100644
--- a/stm/pin_map.c
+++ b/stm/pin_map.c
@@ -69,7 +69,7 @@ static void pin_map_obj_print(void (*print)(void *env, const char *fmt, ...), vo
static mp_obj_t pin_map_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
pin_map_obj_t *self = self_in;
- rt_check_nargs(n_args, 1, 2, n_kw, false);
+ mp_check_nargs(n_args, 1, 2, n_kw, false);
if (n_args > 1) {
if (!self->map_dict) {
@@ -96,7 +96,7 @@ static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_map_obj_mapper_obj, 1, 2, pin_map
static mp_obj_t pin_map_obj_debug(uint n_args, mp_obj_t *args) {
pin_map_obj_t *self = args[0];
if (n_args > 1) {
- self->debug = rt_is_true(args[1]);
+ self->debug = mp_obj_is_true(args[1]);
return mp_const_none;
}
return MP_BOOL(self->debug);
@@ -162,7 +162,7 @@ const pin_obj_t *pin_map_user_obj(mp_obj_t user_obj) {
}
if (pin_map_obj.mapper) {
- pin_obj = rt_call_function_1(pin_map_obj.mapper, user_obj);
+ pin_obj = mp_call_function_1(pin_map_obj.mapper, user_obj);
if (pin_obj != mp_const_none) {
if (!MP_OBJ_IS_TYPE(pin_obj, &pin_obj_type)) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "Pin.mapper didn't return a Pin object"));
diff --git a/stm/pyexec.c b/stm/pyexec.c
index e3e50441ddab99ce9518dff2c0dac03190953aa5..7b4da42b0b086b2a7fed903f1a767f762267975a 100644
--- a/stm/pyexec.c
+++ b/stm/pyexec.c
@@ -154,7 +154,7 @@ bool parse_compile_execute(mp_lexer_t *lex, mp_parse_input_kind_t input_kind, bo
uint32_t start = sys_tick_counter;
if (nlr_push(&nlr) == 0) {
usb_vcp_set_interrupt_char(VCP_CHAR_CTRL_C); // allow ctrl-C to interrupt us
- rt_call_function_0(module_fun);
+ mp_call_function_0(module_fun);
usb_vcp_set_interrupt_char(VCP_CHAR_NONE); // disable interrupt
nlr_pop();
ret = true;
@@ -238,8 +238,8 @@ raw_repl_reset:
void pyexec_repl(void) {
#if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
// in host mode, we enable the LCD for the repl
- mp_obj_t lcd_o = rt_call_function_0(rt_load_name(qstr_from_str("LCD")));
- rt_call_function_1(rt_load_attr(lcd_o, qstr_from_str("light")), mp_const_true);
+ mp_obj_t lcd_o = mp_call_function_0(mp_load_name(qstr_from_str("LCD")));
+ mp_call_function_1(mp_load_attr(lcd_o, qstr_from_str("light")), mp_const_true);
#endif
stdout_tx_str("Micro Python build <git hash> on 25/1/2014; " MICROPY_HW_BOARD_NAME " with STM32F405RG\r\n");
diff --git a/stm/sdcard.c b/stm/sdcard.c
index 566fe70d53a92da9a1f178e91cccc39ceada770d..59256292fd628d8033a2daf13525ac9560e18cc5 100644
--- a/stm/sdcard.c
+++ b/stm/sdcard.c
@@ -173,7 +173,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(sd_present_obj, sd_present);
static mp_obj_t sd_power(mp_obj_t self, mp_obj_t state) {
bool result;
- if (rt_is_true(state)) {
+ if (mp_obj_is_true(state)) {
result = sdcard_power_on();
} else {
sdcard_power_off();
diff --git a/stm/timer.c b/stm/timer.c
index d20d3a77bd96bf7ec2a6d92ae780fb460b93b8ca..0a19fa5a8171112132a5bc09f1474897f46f30b7 100644
--- a/stm/timer.c
+++ b/stm/timer.c
@@ -74,11 +74,11 @@ void timer_init(void) {
// Python interface
mp_obj_t m = mp_obj_new_module(QSTR_FROM_STR_STATIC("timer"));
- rt_store_attr(m, QSTR_FROM_STR_STATIC("callback"), rt_make_function_n(1, timer_py_set_callback));
- rt_store_attr(m, QSTR_FROM_STR_STATIC("period"), rt_make_function_n(1, timer_py_set_period));
- rt_store_attr(m, QSTR_FROM_STR_STATIC("prescaler"), rt_make_function_n(1, timer_py_set_prescaler));
- rt_store_attr(m, QSTR_FROM_STR_STATIC("value"), rt_make_function_n(0, timer_py_get_value));
- rt_store_name(QSTR_FROM_STR_STATIC("timer"), m);
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("callback"), mp_make_function_n(1, timer_py_set_callback));
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("period"), mp_make_function_n(1, timer_py_set_period));
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("prescaler"), mp_make_function_n(1, timer_py_set_prescaler));
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("value"), mp_make_function_n(0, timer_py_get_value));
+ mp_store_name(QSTR_FROM_STR_STATIC("timer"), m);
}
void timer_interrupt(void) {
@@ -86,7 +86,7 @@ void timer_interrupt(void) {
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
// XXX what to do if the GC is in the middle of running??
- rt_call_function_0(timer_py_callback);
+ mp_call_function_0(timer_py_callback);
nlr_pop();
} else {
// uncaught exception
diff --git a/stm/usrsw.c b/stm/usrsw.c
index 98db562e630140c8418ab823be6023416cd142d0..a00ca90d2868ceac6760e68949f8a72389055fb8 100644
--- a/stm/usrsw.c
+++ b/stm/usrsw.c
@@ -33,7 +33,7 @@ static mp_obj_t switch_user_callback_obj;
static mp_obj_t switch_callback(mp_obj_t line) {
if (switch_user_callback_obj != mp_const_none) {
- rt_call_function_0(switch_user_callback_obj);
+ mp_call_function_0(switch_user_callback_obj);
}
return mp_const_none;
}
diff --git a/stmhal/accel.c b/stmhal/accel.c
index c77ec5c51193ecdacfe4f106fb6186da143461c1..a564902c0c5f59596d636679423a1822af6c8352 100644
--- a/stmhal/accel.c
+++ b/stmhal/accel.c
@@ -76,7 +76,7 @@ STATIC pyb_accel_obj_t pyb_accel_obj;
STATIC mp_obj_t pyb_accel_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// check arguments
- rt_check_nargs(n_args, 0, 0, n_kw, false);
+ mp_check_nargs(n_args, 0, 0, n_kw, false);
// init accel object
pyb_accel_obj.base.type = &pyb_accel_type;
@@ -135,7 +135,7 @@ STATIC mp_obj_t pyb_accel_filtered_xyz(mp_obj_t self_in) {
tuple[i] = mp_obj_new_int(val);
}
- return rt_build_tuple(3, tuple);
+ return mp_build_tuple(3, tuple);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_accel_filtered_xyz_obj, pyb_accel_filtered_xyz);
diff --git a/stmhal/adc.c b/stmhal/adc.c
index d28392c89450c5d5ea1d70f0bbe2815fdea2afce..c4e0b9e25ee39959286062b2e72bb048704bee47 100644
--- a/stmhal/adc.c
+++ b/stmhal/adc.c
@@ -119,7 +119,7 @@ STATIC void adc_print(void (*print)(void *env, const char *fmt, ...), void *env,
STATIC mp_obj_t adc_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// check number of arguments
- rt_check_nargs(n_args, 1, 1, n_kw, false);
+ mp_check_nargs(n_args, 1, 1, n_kw, false);
// 1st argument is the pin name
mp_obj_t pin_obj = args[0];
diff --git a/stmhal/dac.c b/stmhal/dac.c
index 8bbab35be9f18f55559d0b2c255255d425e016df..b57e2c440f6cae9fea5bfe72cdc2cb9ce8c813db 100644
--- a/stmhal/dac.c
+++ b/stmhal/dac.c
@@ -65,7 +65,7 @@ STATIC pyb_dac_obj_t pyb_dac_channel_2 = {{&pyb_dac_type}, DAC_CHANNEL_2, DMA1_S
STATIC mp_obj_t pyb_dac_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// check arguments
- rt_check_nargs(n_args, 1, 1, n_kw, false);
+ mp_check_nargs(n_args, 1, 1, n_kw, false);
machine_int_t dac_id = mp_obj_get_int(args[0]);
uint32_t pin;
diff --git a/stmhal/exti.c b/stmhal/exti.c
index e5e9b53bda512923560cc9db217cac0a21ccbca9..99bcd07e891b19ec1b4726351c47e7a70079ce1b 100644
--- a/stmhal/exti.c
+++ b/stmhal/exti.c
@@ -264,7 +264,7 @@ STATIC MP_DEFINE_CONST_DICT(exti_locals_dict, exti_locals_dict_table);
STATIC mp_obj_t exti_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// type_in == exti_obj_type
- rt_check_nargs(n_args, 4, 4, n_kw, false);
+ mp_check_nargs(n_args, 4, 4, n_kw, false);
exti_obj_t *self = m_new_obj(exti_obj_t);
self->base.type = type_in;
@@ -305,7 +305,7 @@ void Handle_EXTI_Irq(uint32_t line) {
exti_vector_t *v = &exti_vector[line];
if (v->callback_obj != mp_const_none) {
// TODO need to wrap this in an nlr_buf; really need a general function for this
- rt_call_function_1(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line));
+ mp_call_function_1(v->callback_obj, MP_OBJ_NEW_SMALL_INT(line));
}
}
}
diff --git a/stmhal/gpio.c b/stmhal/gpio.c
index be1249b37676f85d9978a42f010f8f6345bf8d17..4548dca58773aef4da068cb9a78f61769576bc28 100644
--- a/stmhal/gpio.c
+++ b/stmhal/gpio.c
@@ -27,7 +27,7 @@ mp_obj_t pyb_gpio(uint n_args, mp_obj_t *args) {
}
// set pin
- HAL_GPIO_WritePin(pin->gpio, pin->pin_mask, rt_is_true(args[1]));
+ HAL_GPIO_WritePin(pin->gpio, pin->pin_mask, mp_obj_is_true(args[1]));
return mp_const_none;
}
diff --git a/stmhal/i2c.c b/stmhal/i2c.c
index ab37f756b8d2b7e76d5b2c061ba1fce16a53797e..0b76d35cb45249ed353689cb35e1ab76ee1f3fe1 100644
--- a/stmhal/i2c.c
+++ b/stmhal/i2c.c
@@ -80,7 +80,7 @@ STATIC pyb_i2c_obj_t pyb_i2c_obj[PYB_NUM_I2C] = {{{&pyb_i2c_type}, &I2cHandle_X}
STATIC mp_obj_t pyb_i2c_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// check arguments
- rt_check_nargs(n_args, 1, 1, n_kw, false);
+ mp_check_nargs(n_args, 1, 1, n_kw, false);
// get i2c number
machine_int_t i2c_id = mp_obj_get_int(args[0]) - 1;
diff --git a/stmhal/lcd.c b/stmhal/lcd.c
index e2b9e229767f0ca8ccbb3dd5c347af57c055ff42..efee13d233cf395b21de4bdbf936d51d94283798 100644
--- a/stmhal/lcd.c
+++ b/stmhal/lcd.c
@@ -214,7 +214,7 @@ mp_obj_t lcd_print(mp_obj_t text) {
mp_obj_t lcd_light(mp_obj_t value) {
#if defined(PYB_LCD_BL_PORT)
- if (rt_is_true(value)) {
+ if (mp_obj_is_true(value)) {
PYB_LCD_BL_PORT->BSRRL = PYB_LCD_BL_PIN; // set pin high to turn backlight on
} else {
PYB_LCD_BL_PORT->BSRRH = PYB_LCD_BL_PIN; // set pin low to turn backlight off
@@ -291,14 +291,14 @@ static mp_obj_t pyb_lcd_init(void) {
// Micro Python interface
mp_obj_t o = mp_obj_new_type(MP_QSTR_LCD, mp_const_empty_tuple, mp_obj_new_dict(0));
- rt_store_attr(o, qstr_from_str("lcd8"), rt_make_function_n(2, lcd_draw_pixel_8));
- rt_store_attr(o, qstr_from_str("clear"), rt_make_function_n(0, lcd_pix_clear));
- rt_store_attr(o, qstr_from_str("get"), rt_make_function_n(2, lcd_pix_get));
- rt_store_attr(o, qstr_from_str("set"), rt_make_function_n(2, lcd_pix_set));
- rt_store_attr(o, qstr_from_str("reset"), rt_make_function_n(2, lcd_pix_reset));
- rt_store_attr(o, qstr_from_str("show"), rt_make_function_n(0, lcd_pix_show));
- rt_store_attr(o, qstr_from_str("text"), rt_make_function_n(1, lcd_print));
- rt_store_attr(o, qstr_from_str("light"), rt_make_function_n(1, lcd_light));
+ mp_store_attr(o, qstr_from_str("lcd8"), mp_make_function_n(2, lcd_draw_pixel_8));
+ mp_store_attr(o, qstr_from_str("clear"), mp_make_function_n(0, lcd_pix_clear));
+ mp_store_attr(o, qstr_from_str("get"), mp_make_function_n(2, lcd_pix_get));
+ mp_store_attr(o, qstr_from_str("set"), mp_make_function_n(2, lcd_pix_set));
+ mp_store_attr(o, qstr_from_str("reset"), mp_make_function_n(2, lcd_pix_reset));
+ mp_store_attr(o, qstr_from_str("show"), mp_make_function_n(0, lcd_pix_show));
+ mp_store_attr(o, qstr_from_str("text"), mp_make_function_n(1, lcd_print));
+ mp_store_attr(o, qstr_from_str("light"), mp_make_function_n(1, lcd_light));
mp_lcd = o;
return o;
}
@@ -307,7 +307,7 @@ static MP_DEFINE_CONST_FUN_OBJ_0(pyb_lcd_init_obj, pyb_lcd_init);
void lcd_init(void) {
mp_lcd = MP_OBJ_NULL;
- rt_store_name(qstr_from_str("LCD"), (mp_obj_t)&pyb_lcd_init_obj);
+ mp_store_name(qstr_from_str("LCD"), (mp_obj_t)&pyb_lcd_init_obj);
}
void lcd_print_str(const char *str) {
diff --git a/stmhal/led.c b/stmhal/led.c
index 506e82e548cda5c3732164ad32fed1fbaa9b06df..995b518e2591658c79c073053ef6afc3905b9f9b 100644
--- a/stmhal/led.c
+++ b/stmhal/led.c
@@ -208,7 +208,7 @@ void led_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp
STATIC mp_obj_t led_obj_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// check arguments
- rt_check_nargs(n_args, 1, 1, n_kw, false);
+ mp_check_nargs(n_args, 1, 1, n_kw, false);
// get led number
machine_int_t led_id = mp_obj_get_int(args[0]) - 1;
diff --git a/stmhal/main.c b/stmhal/main.c
index 9efaaec764e00418c5342e0cdcb59422d0dadefe..d6d9b9ed7eebe26a3b729d67448b4f589862a676 100644
--- a/stmhal/main.c
+++ b/stmhal/main.c
@@ -251,12 +251,12 @@ soft_reset:
// Micro Python init
qstr_init();
- rt_init();
+ mp_init();
mp_obj_t def_path[3];
def_path[0] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_);
def_path[1] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_src);
def_path[2] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_lib);
- sys_path = mp_obj_new_list(3, def_path);
+ mp_sys_path = mp_obj_new_list(3, def_path);
readline_init();
diff --git a/stmhal/pin_map.c b/stmhal/pin_map.c
index a754d24a05b7ea20f7adf3ebf96299f61cf6b3ae..8a0be1d52a1ae2c73a6fa440bc56cfdaa68a2b5d 100644
--- a/stmhal/pin_map.c
+++ b/stmhal/pin_map.c
@@ -69,7 +69,7 @@ static void pin_map_obj_print(void (*print)(void *env, const char *fmt, ...), vo
static mp_obj_t pin_map_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
pin_map_obj_t *self = self_in;
- rt_check_nargs(n_args, 1, 2, n_kw, false);
+ mp_check_nargs(n_args, 1, 2, n_kw, false);
if (n_args > 1) {
if (!self->map_dict) {
@@ -96,7 +96,7 @@ static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_map_obj_mapper_obj, 1, 2, pin_map
static mp_obj_t pin_map_obj_debug(uint n_args, mp_obj_t *args) {
pin_map_obj_t *self = args[0];
if (n_args > 1) {
- self->debug = rt_is_true(args[1]);
+ self->debug = mp_obj_is_true(args[1]);
return mp_const_none;
}
return MP_BOOL(self->debug);
@@ -162,7 +162,7 @@ const pin_obj_t *pin_map_user_obj(mp_obj_t user_obj) {
}
if (pin_map_obj.mapper) {
- pin_obj = rt_call_function_1(pin_map_obj.mapper, user_obj);
+ pin_obj = mp_call_function_1(pin_map_obj.mapper, user_obj);
if (pin_obj != mp_const_none) {
if (!MP_OBJ_IS_TYPE(pin_obj, &pin_obj_type)) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "Pin.mapper didn't return a Pin object"));
diff --git a/stmhal/pyexec.c b/stmhal/pyexec.c
index 7c19d45ca692f4b326aa8341b41d6aeda4653193..ffee4dd2e20a6b953e9df7385080525052360df0 100644
--- a/stmhal/pyexec.c
+++ b/stmhal/pyexec.c
@@ -55,7 +55,7 @@ bool parse_compile_execute(mp_lexer_t *lex, mp_parse_input_kind_t input_kind, bo
uint32_t start = HAL_GetTick();
if (nlr_push(&nlr) == 0) {
usb_vcp_set_interrupt_char(VCP_CHAR_CTRL_C); // allow ctrl-C to interrupt us
- rt_call_function_0(module_fun);
+ mp_call_function_0(module_fun);
usb_vcp_set_interrupt_char(VCP_CHAR_NONE); // disable interrupt
nlr_pop();
ret = true;
@@ -151,8 +151,8 @@ int pyexec_friendly_repl(void) {
#if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
// in host mode, we enable the LCD for the repl
- mp_obj_t lcd_o = rt_call_function_0(rt_load_name(qstr_from_str("LCD")));
- rt_call_function_1(rt_load_attr(lcd_o, qstr_from_str("light")), mp_const_true);
+ mp_obj_t lcd_o = mp_call_function_0(mp_load_name(qstr_from_str("LCD")));
+ mp_call_function_1(mp_load_attr(lcd_o, qstr_from_str("light")), mp_const_true);
#endif
friendly_repl_reset:
diff --git a/stmhal/sdcard.c b/stmhal/sdcard.c
index ae03c9f3fa89eb12798494cbd955ed73569eca19..84ee0b7b1121fc0a894824fada950b24532e2f91 100644
--- a/stmhal/sdcard.c
+++ b/stmhal/sdcard.c
@@ -209,7 +209,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(sd_present_obj, sd_present);
static mp_obj_t sd_power(mp_obj_t self, mp_obj_t state) {
bool result;
- if (rt_is_true(state)) {
+ if (mp_obj_is_true(state)) {
result = sdcard_power_on();
} else {
sdcard_power_off();
diff --git a/stmhal/servo.c b/stmhal/servo.c
index 5955328580882319e5820068cd66f2b67bb31cd5..4e8ff1543b1861b6ef6e530d1866027b8244eee6 100644
--- a/stmhal/servo.c
+++ b/stmhal/servo.c
@@ -157,7 +157,7 @@ STATIC void pyb_servo_print(void (*print)(void *env, const char *fmt, ...), void
STATIC mp_obj_t pyb_servo_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// check arguments
- rt_check_nargs(n_args, 1, 1, n_kw, false);
+ mp_check_nargs(n_args, 1, 1, n_kw, false);
// get servo number
machine_int_t servo_id = mp_obj_get_int(args[0]) - 1;
diff --git a/stmhal/usrsw.c b/stmhal/usrsw.c
index 038fbf9efbdb2620a655068c740a17d8a559a6c4..453c3dfa8258edee8e69fec4c3797d95253d1ca6 100644
--- a/stmhal/usrsw.c
+++ b/stmhal/usrsw.c
@@ -33,7 +33,7 @@ static mp_obj_t switch_user_callback_obj;
static mp_obj_t switch_callback(mp_obj_t line) {
if (switch_user_callback_obj != mp_const_none) {
- rt_call_function_0(switch_user_callback_obj);
+ mp_call_function_0(switch_user_callback_obj);
}
return mp_const_none;
}
diff --git a/teensy/main.c b/teensy/main.c
index ab7bd46812f8b7de459fe822cc8c6ae6a6e34da8..ea8726f769e1d95c36556a4c20b158ba03e6736a 100644
--- a/teensy/main.c
+++ b/teensy/main.c
@@ -186,7 +186,7 @@ mp_obj_t pyb_gpio(int n_args, mp_obj_t *args) {
// set pin
pinMode(pin, OUTPUT);
- digitalWrite(pin, rt_is_true(args[1]));
+ digitalWrite(pin, mp_obj_is_true(args[1]));
return mp_const_none;
pin_error:
@@ -237,7 +237,7 @@ mp_obj_t pyb_delay(mp_obj_t count) {
}
mp_obj_t pyb_led(mp_obj_t state) {
- led_state(PYB_LED_BUILTIN, rt_is_true(state));
+ led_state(PYB_LED_BUILTIN, mp_obj_is_true(state));
return state;
}
@@ -368,7 +368,7 @@ bool do_file(const char *filename) {
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
- rt_call_function_0(module_fun);
+ mp_call_function_0(module_fun);
nlr_pop();
return true;
} else {
@@ -427,7 +427,7 @@ void do_repl(void) {
nlr_buf_t nlr;
uint32_t start = micros();
if (nlr_push(&nlr) == 0) {
- rt_call_function_0(module_fun);
+ mp_call_function_0(module_fun);
nlr_pop();
// optional timing
if (0) {
@@ -468,28 +468,28 @@ soft_reset:
gc_init(&_heap_start, (void*)HEAP_END);
qstr_init();
- rt_init();
+ mp_init();
// add some functions to the python namespace
{
- rt_store_name(MP_QSTR_help, rt_make_function_n(0, pyb_help));
+ mp_store_name(MP_QSTR_help, mp_make_function_n(0, pyb_help));
mp_obj_t m = mp_obj_new_module(MP_QSTR_pyb);
- rt_store_attr(m, MP_QSTR_info, rt_make_function_n(0, pyb_info));
- rt_store_attr(m, MP_QSTR_source_dir, rt_make_function_n(1, pyb_source_dir));
- rt_store_attr(m, MP_QSTR_main, rt_make_function_n(1, pyb_main));
- rt_store_attr(m, MP_QSTR_gc, rt_make_function_n(0, pyb_gc));
- rt_store_attr(m, MP_QSTR_delay, rt_make_function_n(1, pyb_delay));
- rt_store_attr(m, MP_QSTR_led, rt_make_function_n(1, pyb_led));
- rt_store_attr(m, MP_QSTR_Led, rt_make_function_n(1, pyb_Led));
- rt_store_attr(m, MP_QSTR_analogRead, rt_make_function_n(1, pyb_analog_read));
- rt_store_attr(m, MP_QSTR_analogWrite, rt_make_function_n(2, pyb_analog_write));
- rt_store_attr(m, MP_QSTR_analogWriteResolution, rt_make_function_n(1, pyb_analog_write_resolution));
- rt_store_attr(m, MP_QSTR_analogWriteFrequency, rt_make_function_n(2, pyb_analog_write_frequency));
-
- rt_store_attr(m, MP_QSTR_gpio, (mp_obj_t)&pyb_gpio_obj);
- rt_store_attr(m, MP_QSTR_Servo, rt_make_function_n(0, pyb_Servo));
- rt_store_name(MP_QSTR_pyb, m);
- rt_store_name(MP_QSTR_run, rt_make_function_n(1, pyb_run));
+ mp_store_attr(m, MP_QSTR_info, mp_make_function_n(0, pyb_info));
+ mp_store_attr(m, MP_QSTR_source_dir, mp_make_function_n(1, pyb_source_dir));
+ mp_store_attr(m, MP_QSTR_main, mp_make_function_n(1, pyb_main));
+ mp_store_attr(m, MP_QSTR_gc, mp_make_function_n(0, pyb_gc));
+ mp_store_attr(m, MP_QSTR_delay, mp_make_function_n(1, pyb_delay));
+ mp_store_attr(m, MP_QSTR_led, mp_make_function_n(1, pyb_led));
+ mp_store_attr(m, MP_QSTR_Led, mp_make_function_n(1, pyb_Led));
+ mp_store_attr(m, MP_QSTR_analogRead, mp_make_function_n(1, pyb_analog_read));
+ mp_store_attr(m, MP_QSTR_analogWrite, mp_make_function_n(2, pyb_analog_write));
+ mp_store_attr(m, MP_QSTR_analogWriteResolution, mp_make_function_n(1, pyb_analog_write_resolution));
+ mp_store_attr(m, MP_QSTR_analogWriteFrequency, mp_make_function_n(2, pyb_analog_write_frequency));
+
+ mp_store_attr(m, MP_QSTR_gpio, (mp_obj_t)&pyb_gpio_obj);
+ mp_store_attr(m, MP_QSTR_Servo, mp_make_function_n(0, pyb_Servo));
+ mp_store_name(MP_QSTR_pyb, m);
+ mp_store_name(MP_QSTR_run, mp_make_function_n(1, pyb_run));
}
printf("About execute /boot.py\n");
diff --git a/unix-cpy/main.c b/unix-cpy/main.c
index 7e2703139e74bbc17fbe5c7841e3decade0eea60..da385ae6127d2a4355e0a3db1b0a252d1a9b984e 100644
--- a/unix-cpy/main.c
+++ b/unix-cpy/main.c
@@ -61,7 +61,7 @@ void do_file(const char *file) {
int main(int argc, char **argv) {
qstr_init();
- rt_init();
+ mp_init();
if (argc == 2) {
do_file(argv[1]);
@@ -69,7 +69,7 @@ int main(int argc, char **argv) {
printf("usage: py [<file>]\n");
return 1;
}
- rt_deinit();
+ mp_deinit();
return 0;
}
diff --git a/unix/ffi.c b/unix/ffi.c
index 9a4c03572fa7073c68045d0cfbab6ff7016e8b63..71fb0b66ab959603932923d987cb7ba26fee99ea 100644
--- a/unix/ffi.c
+++ b/unix/ffi.c
@@ -128,10 +128,10 @@ STATIC mp_obj_t ffimod_func(uint n_args, const mp_obj_t *args) {
o->func = sym;
o->rettype = *rettype;
- mp_obj_t iterable = rt_getiter(args[3]);
+ mp_obj_t iterable = mp_getiter(args[3]);
mp_obj_t item;
int i = 0;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
o->params[i++] = get_ffi_type(item);
}
@@ -149,7 +149,7 @@ STATIC void call_py_func(ffi_cif *cif, void *ret, void** args, mp_obj_t func) {
for (int i = 0; i < cif->nargs; i++) {
pyargs[i] = mp_obj_new_int(*(int*)args[i]);
}
- mp_obj_t res = rt_call_function_n_kw(func, cif->nargs, 0, pyargs);
+ mp_obj_t res = mp_call_function_n_kw(func, cif->nargs, 0, pyargs);
*(ffi_arg*)ret = mp_obj_int_get(res);
}
@@ -165,10 +165,10 @@ STATIC mp_obj_t mod_ffi_callback(mp_obj_t rettype_in, mp_obj_t func_in, mp_obj_t
o->rettype = *rettype;
- mp_obj_t iterable = rt_getiter(paramtypes_in);
+ mp_obj_t iterable = mp_getiter(paramtypes_in);
mp_obj_t item;
int i = 0;
- while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) {
+ while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
o->params[i++] = get_ffi_type(item);
}
@@ -348,8 +348,8 @@ MP_DEFINE_CONST_FUN_OBJ_2(mod_ffi_as_bytearray_obj, mod_ffi_as_bytearray);
void ffi_init() {
mp_obj_t m = mp_obj_new_module(QSTR_FROM_STR_STATIC("ffi"));
- rt_store_attr(m, MP_QSTR_open, (mp_obj_t)&mod_ffi_open_obj);
- rt_store_attr(m, QSTR_FROM_STR_STATIC("callback"), (mp_obj_t)&mod_ffi_callback_obj);
+ mp_store_attr(m, MP_QSTR_open, (mp_obj_t)&mod_ffi_open_obj);
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("callback"), (mp_obj_t)&mod_ffi_callback_obj);
// there would be as_bytes, but bytes currently is value, not reference type!
- rt_store_attr(m, QSTR_FROM_STR_STATIC("as_bytearray"), (mp_obj_t)&mod_ffi_as_bytearray_obj);
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("as_bytearray"), (mp_obj_t)&mod_ffi_as_bytearray_obj);
}
diff --git a/unix/file.c b/unix/file.c
index f037b6f7eaf8d5f7d96b6b16ab0eb33c69c309f5..948ec4405121ded72884a2a0219ac947072c65f4 100644
--- a/unix/file.c
+++ b/unix/file.c
@@ -140,7 +140,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_open_obj, 1, 2, mp_builtin_open);
void file_init() {
mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys);
- rt_store_attr(m_sys, MP_QSTR_stdin, fdfile_new(STDIN_FILENO));
- rt_store_attr(m_sys, MP_QSTR_stdout, fdfile_new(STDOUT_FILENO));
- rt_store_attr(m_sys, MP_QSTR_stderr, fdfile_new(STDERR_FILENO));
+ mp_store_attr(m_sys, MP_QSTR_stdin, fdfile_new(STDIN_FILENO));
+ mp_store_attr(m_sys, MP_QSTR_stdout, fdfile_new(STDOUT_FILENO));
+ mp_store_attr(m_sys, MP_QSTR_stderr, fdfile_new(STDERR_FILENO));
}
diff --git a/unix/main.c b/unix/main.c
index 6b25988759656a543a50baa30cdbc26cfac3ee77..ffbdbb7e79515ad603e89938544fd7846e4a6403 100644
--- a/unix/main.c
+++ b/unix/main.c
@@ -85,7 +85,7 @@ static void execute_from_lexer(mp_lexer_t *lex, mp_parse_input_kind_t input_kind
// execute it
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
- rt_call_function_0(module_fun);
+ mp_call_function_0(module_fun);
nlr_pop();
} else {
// uncaught exception
@@ -278,7 +278,7 @@ int main(int argc, char **argv) {
#endif
qstr_init();
- rt_init();
+ mp_init();
char *home = getenv("HOME");
char *path = getenv("MICROPYPATH");
@@ -292,9 +292,9 @@ int main(int argc, char **argv) {
p++;
}
}
- sys_path = mp_obj_new_list(path_num, NULL);
+ mp_sys_path = mp_obj_new_list(path_num, NULL);
mp_obj_t *path_items;
- mp_obj_list_get(sys_path, &path_num, &path_items);
+ mp_obj_list_get(mp_sys_path, &path_num, &path_items);
path_items[0] = MP_OBJ_NEW_QSTR(MP_QSTR_);
char *p = path;
for (int i = 1; i < path_num; i++) {
@@ -315,15 +315,15 @@ int main(int argc, char **argv) {
}
mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys);
- rt_store_attr(m_sys, MP_QSTR_path, sys_path);
+ mp_store_attr(m_sys, MP_QSTR_path, mp_sys_path);
mp_obj_t py_argv = mp_obj_new_list(0, NULL);
- rt_store_attr(m_sys, MP_QSTR_argv, py_argv);
+ mp_store_attr(m_sys, MP_QSTR_argv, py_argv);
- rt_store_name(qstr_from_str("test"), test_obj_new(42));
- rt_store_name(qstr_from_str("mem_info"), rt_make_function_n(0, mem_info));
- rt_store_name(qstr_from_str("qstr_info"), rt_make_function_n(0, qstr_info));
+ mp_store_name(qstr_from_str("test"), test_obj_new(42));
+ mp_store_name(qstr_from_str("mem_info"), mp_make_function_n(0, mem_info));
+ mp_store_name(qstr_from_str("qstr_info"), mp_make_function_n(0, qstr_info));
#if MICROPY_ENABLE_GC
- rt_store_name(qstr_from_str("gc"), (mp_obj_t)&pyb_gc_obj);
+ mp_store_name(qstr_from_str("gc"), (mp_obj_t)&pyb_gc_obj);
#endif
file_init();
@@ -344,8 +344,8 @@ int main(int argc, char **argv) {
// test_obj.attr = 42
mp_obj_t test_class_type, test_class_instance;
test_class_type = mp_obj_new_type(QSTR_FROM_STR_STATIC("TestClass"), mp_const_empty_tuple, mp_obj_new_dict(0));
- rt_store_name(QSTR_FROM_STR_STATIC("test_obj"), test_class_instance = rt_call_function_0(test_class_type));
- rt_store_attr(test_class_instance, QSTR_FROM_STR_STATIC("attr"), mp_obj_new_int(42));
+ mp_store_name(QSTR_FROM_STR_STATIC("test_obj"), test_class_instance = mp_call_function_0(test_class_type));
+ mp_store_attr(test_class_instance, QSTR_FROM_STR_STATIC("attr"), mp_obj_new_int(42));
/*
printf("bytes:\n");
@@ -378,7 +378,7 @@ int main(int argc, char **argv) {
free(basedir);
}
for (int i = a; i < argc; i++) {
- rt_list_append(py_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i])));
+ mp_list_append(py_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i])));
}
do_file(argv[a]);
executed = true;
@@ -390,7 +390,7 @@ int main(int argc, char **argv) {
do_repl();
}
- rt_deinit();
+ mp_deinit();
//printf("total bytes = %d\n", m_get_total_bytes_allocated());
return 0;
diff --git a/unix/socket.c b/unix/socket.c
index 04c1d10c73d54ad107d7db22703c2ac4449687a6..ee74ea084592848f6a1cb906a96b6e88b9785300 100644
--- a/unix/socket.c
+++ b/unix/socket.c
@@ -314,7 +314,7 @@ static mp_obj_t mod_socket_getaddrinfo(uint n_args, const mp_obj_t *args) {
}
assert(addr);
- mp_obj_t list = rt_build_list(0, NULL);
+ mp_obj_t list = mp_build_list(0, NULL);
for (; addr; addr = addr->ai_next) {
mp_obj_tuple_t *t = mp_obj_new_tuple(5, NULL);
t->items[0] = MP_OBJ_NEW_SMALL_INT((machine_int_t)addr->ai_family);
@@ -328,7 +328,7 @@ static mp_obj_t mod_socket_getaddrinfo(uint n_args, const mp_obj_t *args) {
t->items[3] = mp_const_none;
}
t->items[4] = mp_obj_new_bytearray(addr->ai_addrlen, addr->ai_addr);
- rt_list_append(list, t);
+ mp_list_append(list, t);
}
return list;
}
@@ -366,15 +366,15 @@ static const struct sym_entry {
void microsocket_init() {
mp_obj_t m = mp_obj_new_module(MP_QSTR_microsocket);
- rt_store_attr(m, MP_QSTR_socket, (mp_obj_t)µsocket_type);
+ mp_store_attr(m, MP_QSTR_socket, (mp_obj_t)µsocket_type);
#if MICROPY_SOCKET_EXTRA
- rt_store_attr(m, MP_QSTR_sockaddr_in, (mp_obj_t)&sockaddr_in_type);
- rt_store_attr(m, MP_QSTR_htons, (mp_obj_t)&mod_socket_htons_obj);
- rt_store_attr(m, MP_QSTR_inet_aton, (mp_obj_t)&mod_socket_inet_aton_obj);
- rt_store_attr(m, MP_QSTR_gethostbyname, (mp_obj_t)&mod_socket_gethostbyname_obj);
+ mp_store_attr(m, MP_QSTR_sockaddr_in, (mp_obj_t)&sockaddr_in_type);
+ mp_store_attr(m, MP_QSTR_htons, (mp_obj_t)&mod_socket_htons_obj);
+ mp_store_attr(m, MP_QSTR_inet_aton, (mp_obj_t)&mod_socket_inet_aton_obj);
+ mp_store_attr(m, MP_QSTR_gethostbyname, (mp_obj_t)&mod_socket_gethostbyname_obj);
#endif
- rt_store_attr(m, MP_QSTR_getaddrinfo, (mp_obj_t)&mod_socket_getaddrinfo_obj);
+ mp_store_attr(m, MP_QSTR_getaddrinfo, (mp_obj_t)&mod_socket_getaddrinfo_obj);
for (const struct sym_entry *p = constants; p->sym != NULL; p++) {
- rt_store_attr(m, QSTR_FROM_STR_STATIC(p->sym), MP_OBJ_NEW_SMALL_INT((machine_int_t)p->val));
+ mp_store_attr(m, QSTR_FROM_STR_STATIC(p->sym), MP_OBJ_NEW_SMALL_INT((machine_int_t)p->val));
}
}
diff --git a/unix/time.c b/unix/time.c
index 7d25b3dd562c3545790c0bd36766687e5d19bc9a..fb52133580f32201d8f261314b84f623234780ab 100644
--- a/unix/time.c
+++ b/unix/time.c
@@ -43,7 +43,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(mod_time_sleep_obj, mod_time_sleep);
void time_init() {
mp_obj_t m = mp_obj_new_module(QSTR_FROM_STR_STATIC("time"));
- rt_store_attr(m, QSTR_FROM_STR_STATIC("time"), (mp_obj_t)&mod_time_time_obj);
- rt_store_attr(m, QSTR_FROM_STR_STATIC("clock"), (mp_obj_t)&mod_time_clock_obj);
- rt_store_attr(m, QSTR_FROM_STR_STATIC("sleep"), (mp_obj_t)&mod_time_sleep_obj);
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("time"), (mp_obj_t)&mod_time_time_obj);
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("clock"), (mp_obj_t)&mod_time_clock_obj);
+ mp_store_attr(m, QSTR_FROM_STR_STATIC("sleep"), (mp_obj_t)&mod_time_sleep_obj);
}
diff --git a/windows/main.c b/windows/main.c
index 4456a796d0939ce92fd38ea1b16fe48da6e54982..8ba5ebc67268feaad15a2ccd045e232e2c1002a0 100644
--- a/windows/main.c
+++ b/windows/main.c
@@ -69,7 +69,7 @@ static void execute_from_lexer(mp_lexer_t *lex, mp_parse_input_kind_t input_kind
// execute it
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
- rt_call_function_0(module_fun);
+ mp_call_function_0(module_fun);
nlr_pop();
} else {
// uncaught exception
@@ -183,14 +183,14 @@ mp_obj_t qstr_info(void) {
int main(int argc, char **argv) {
qstr_init();
- rt_init();
+ mp_init();
mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys);
mp_obj_t py_argv = mp_obj_new_list(0, NULL);
- rt_store_attr(m_sys, MP_QSTR_argv, py_argv);
+ mp_store_attr(m_sys, MP_QSTR_argv, py_argv);
- rt_store_name(qstr_from_str("mem_info"), rt_make_function_n(0, mem_info));
- rt_store_name(qstr_from_str("qstr_info"), rt_make_function_n(0, qstr_info));
+ mp_store_name(qstr_from_str("mem_info"), mp_make_function_n(0, mem_info));
+ mp_store_name(qstr_from_str("qstr_info"), mp_make_function_n(0, qstr_info));
file_init();
@@ -217,7 +217,7 @@ int main(int argc, char **argv) {
}
} else {
for (int i = a; i < argc; i++) {
- rt_list_append(py_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i])));
+ mp_list_append(py_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i])));
}
do_file(argv[a]);
break;
@@ -225,7 +225,7 @@ int main(int argc, char **argv) {
}
}
- rt_deinit();
+ mp_deinit();
//printf("total bytes = %d\n", m_get_total_bytes_allocated());
return 0;