mirror
/
micropython
kopia lustrzana https://github.com/micropython/micropython
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Rename rt_* to mp_*. 

Mostly just a global search and replace.  Except rt_is_true which
becomes mp_obj_is_true.

Still would like to tidy up some of the names, but this will do for now.
pull/396/head
Damien George 2014-03-30 13:35:08 +01:00
rodzic 09d207785c
commit d17926db71
71 zmienionych plików z 983 dodań i 978 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

50
py/builtin.c
Wyświetl plik

@ -22,15 +22,15 @@ STATIC mp_obj_t mp_builtin___build_class__(uint n_args, const mp_obj_t *args) {
assert(2 <= n_args); assert(2 <= n_args);
// we differ from CPython: we set the new __locals__ object here // 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); 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 // 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 // restore old __locals__ object
rt_locals_set(old_locals); mp_locals_set(old_locals);
// get the class type (meta object) from the base objects // get the class type (meta object) from the base objects
mp_obj_t meta; 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[0] = args[1]; // class name
meta_args[1] = mp_obj_new_tuple(n_args - 2, args + 2); // tuple of bases meta_args[1] = mp_obj_new_tuple(n_args - 2, args + 2); // tuple of bases
meta_args[2] = class_locals; // dict of members 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 // store into cell if neede
if (cell != mp_const_none) { 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); 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) { 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; mp_obj_t item;
while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) { while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (!rt_is_true(item)) { if (!mp_obj_is_true(item)) {
return mp_const_false; 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); 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) { 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; mp_obj_t item;
while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) { while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (rt_is_true(item)) { if (mp_obj_is_true(item)) {
return mp_const_true; 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; mp_map_t *map = NULL;
if (n_args == 0) { if (n_args == 0) {
// make a list of names in the local name space // make a list of names in the local name space
map = rt_locals_get(); map = mp_locals_get();
} else { // n_args == 1 } else { // n_args == 1
// make a list of names in the given object // make a list of names in the given object
if (MP_OBJ_IS_TYPE(args[0], &mp_type_module)) { 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]; mp_obj_t args[2];
args[0] = MP_OBJ_NEW_SMALL_INT(i1 / i2); args[0] = MP_OBJ_NEW_SMALL_INT(i1 / i2);
args[1] = 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 { } 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))); 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); 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) { 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); 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) { STATIC mp_obj_t mp_builtin_max(uint n_args, const mp_obj_t *args) {
if (n_args == 1) { if (n_args == 1) {
// given an iterable // 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 max_obj = NULL;
mp_obj_t item; 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)) { if (max_obj == NULL || mp_obj_less(max_obj, item)) {
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) { STATIC mp_obj_t mp_builtin_min(uint n_args, const mp_obj_t *args) {
if (n_args == 1) { if (n_args == 1) {
// given an iterable // 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 min_obj = NULL;
mp_obj_t item; 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)) { if (min_obj == NULL || mp_obj_less(item, min_obj)) {
min_obj = item; 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); 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) { 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) { if (ret == MP_OBJ_NULL) {
nlr_jump(mp_obj_new_exception(&mp_type_StopIteration)); nlr_jump(mp_obj_new_exception(&mp_type_StopIteration));
} else { } 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) { STATIC mp_obj_t mp_builtin_pow(uint n_args, const mp_obj_t *args) {
assert(2 <= n_args && n_args <= 3); assert(2 <= n_args && n_args <= 3);
switch (n_args) { switch (n_args) {
case 2: return rt_binary_op(RT_BINARY_OP_POWER, args[0], args[1]); case 2: return mp_binary_op(MP_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... 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; case 1: value = mp_obj_new_int(0); break;
default: value = args[1]; 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; mp_obj_t item;
while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) { while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
value = rt_binary_op(RT_BINARY_OP_ADD, value, item); value = mp_binary_op(MP_BINARY_OP_ADD, value, item);
} }
return value; 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) { STATIC mp_obj_t mp_builtin_getattr(mp_obj_t o_in, mp_obj_t attr) {
assert(MP_OBJ_IS_QSTR(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); MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_getattr_obj, mp_builtin_getattr);

14
py/builtinevex.c
Wyświetl plik

@ -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 // 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) { 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) { STATIC mp_obj_t mp_builtin_exec(uint n_args, const mp_obj_t *args) {
// Unconditional getting/setting assumes that these operations // Unconditional getting/setting assumes that these operations
// are cheap, which is the case when this comment was written. // are cheap, which is the case when this comment was written.
mp_map_t *old_globals = rt_globals_get(); mp_map_t *old_globals = mp_globals_get();
mp_map_t *old_locals = rt_locals_get(); mp_map_t *old_locals = mp_locals_get();
if (n_args > 1) { if (n_args > 1) {
mp_obj_t globals = args[1]; mp_obj_t globals = args[1];
mp_obj_t locals; mp_obj_t locals;
@ -65,13 +65,13 @@ STATIC mp_obj_t mp_builtin_exec(uint n_args, const mp_obj_t *args) {
} else { } else {
locals = globals; locals = globals;
} }
rt_globals_set(mp_obj_dict_get_map(globals)); mp_globals_set(mp_obj_dict_get_map(globals));
rt_locals_set(mp_obj_dict_get_map(locals)); mp_locals_set(mp_obj_dict_get_map(locals));
} }
mp_obj_t res = parse_compile_execute(args[0], MP_PARSE_FILE_INPUT); 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 // TODO if the above call throws an exception, then we never get to reset the globals/locals
rt_globals_set(old_globals); mp_globals_set(old_globals);
rt_locals_set(old_locals); mp_locals_set(old_locals);
return res; return res;
} }

36
py/builtinimport.c
Wyświetl plik

@ -22,7 +22,7 @@
#define PATH_SEP_CHAR '/' #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) { mp_import_stat_t stat_dir_or_file(vstr_t *path) {
//printf("stat %s\n", vstr_str(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 // extract the list of paths
uint path_num = 0; uint path_num = 0;
mp_obj_t *path_items; mp_obj_t *path_items;
if (sys_path != MP_OBJ_NULL) { if (mp_sys_path != MP_OBJ_NULL) {
mp_obj_list_get(sys_path, &path_num, &path_items); mp_obj_list_get(mp_sys_path, &path_num, &path_items);
} }
if (path_num == 0) { 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); vstr_add_strn(dest, file_str, file_len);
return stat_dir_or_file(dest); return stat_dir_or_file(dest);
} else { } else {
@ -84,12 +84,12 @@ void do_load(mp_obj_t module_obj, vstr_t *file) {
qstr source_name = mp_lexer_source_name(lex); qstr source_name = mp_lexer_source_name(lex);
// save the old context // save the old context
mp_map_t *old_locals = rt_locals_get(); mp_map_t *old_locals = mp_locals_get();
mp_map_t *old_globals = rt_globals_get(); mp_map_t *old_globals = mp_globals_get();
// set the new context // set the new context
rt_locals_set(mp_obj_module_get_globals(module_obj)); mp_locals_set(mp_obj_module_get_globals(module_obj));
rt_globals_set(mp_obj_module_get_globals(module_obj)); mp_globals_set(mp_obj_module_get_globals(module_obj));
// parse the imported script // parse the imported script
mp_parse_error_kind_t parse_error_kind; 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) { if (pn == MP_PARSE_NODE_NULL) {
// parse error; clean up and raise exception // parse error; clean up and raise exception
rt_locals_set(old_locals); mp_locals_set(old_locals);
rt_globals_set(old_globals); mp_globals_set(old_globals);
nlr_jump(mp_parse_make_exception(parse_error_kind)); 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) { if (module_fun == mp_const_none) {
// TODO handle compile error correctly // TODO handle compile error correctly
rt_locals_set(old_locals); mp_locals_set(old_locals);
rt_globals_set(old_globals); mp_globals_set(old_globals);
return; return;
} }
// complied successfully, execute it // complied successfully, execute it
nlr_buf_t nlr; nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
rt_call_function_0(module_fun); mp_call_function_0(module_fun);
nlr_pop(); nlr_pop();
} else { } else {
// exception; restore context and re-raise same exception // exception; restore context and re-raise same exception
rt_locals_set(old_locals); mp_locals_set(old_locals);
rt_globals_set(old_globals); mp_globals_set(old_globals);
nlr_jump(nlr.ret_val); nlr_jump(nlr.ret_val);
} }
rt_locals_set(old_locals); mp_locals_set(old_locals);
rt_globals_set(old_globals); mp_globals_set(old_globals);
} }
mp_obj_t mp_builtin___import__(uint n_args, mp_obj_t *args) { 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) { if (outer_module_obj != MP_OBJ_NULL) {
qstr s = qstr_from_strn(mod_str + last, i - last); 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; outer_module_obj = module_obj;
if (top_module_obj == MP_OBJ_NULL) { if (top_module_obj == MP_OBJ_NULL) {

100
py/compile.c
Wyświetl plik

@ -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]); compile_node(comp, pns1->nodes[0]);
if (assign_kind == ASSIGN_AUG_LOAD) { if (assign_kind == ASSIGN_AUG_LOAD) {
EMIT(dup_top_two); EMIT(dup_top_two);
EMIT_ARG(binary_op, RT_BINARY_OP_SUBSCR); EMIT_ARG(binary_op, MP_BINARY_OP_SUBSCR);
} else { } else {
EMIT(store_subscr); 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 // compile: var += step
c_assign(comp, pn_var, ASSIGN_AUG_LOAD); c_assign(comp, pn_var, ASSIGN_AUG_LOAD);
compile_node(comp, pn_step); 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); c_assign(comp, pn_var, ASSIGN_AUG_STORE);
EMIT_ARG(label_assign, entry_label); 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); compile_node(comp, pn_end);
assert(MP_PARSE_NODE_IS_SMALL_INT(pn_step)); assert(MP_PARSE_NODE_IS_SMALL_INT(pn_step));
if (MP_PARSE_NODE_LEAF_SMALL_INT(pn_step) >= 0) { 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 { } 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); 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); EMIT(dup_top);
compile_node(comp, pns_exception_expr); 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); 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 c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
compile_node(comp, pns1->nodes[1]); // rhs compile_node(comp, pns1->nodes[1]); // rhs
assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0])); 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])) { 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_PIPE_EQUAL: op = MP_BINARY_OP_INPLACE_OR; break;
case MP_TOKEN_DEL_CARET_EQUAL: op = RT_BINARY_OP_INPLACE_XOR; break; case MP_TOKEN_DEL_CARET_EQUAL: op = MP_BINARY_OP_INPLACE_XOR; break;
case MP_TOKEN_DEL_AMPERSAND_EQUAL: op = RT_BINARY_OP_INPLACE_AND; break; case MP_TOKEN_DEL_AMPERSAND_EQUAL: op = MP_BINARY_OP_INPLACE_AND; break;
case MP_TOKEN_DEL_DBL_LESS_EQUAL: op = RT_BINARY_OP_INPLACE_LSHIFT; break; case MP_TOKEN_DEL_DBL_LESS_EQUAL: op = MP_BINARY_OP_INPLACE_LSHIFT; break;
case MP_TOKEN_DEL_DBL_MORE_EQUAL: op = RT_BINARY_OP_INPLACE_RSHIFT; break; case MP_TOKEN_DEL_DBL_MORE_EQUAL: op = MP_BINARY_OP_INPLACE_RSHIFT; break;
case MP_TOKEN_DEL_PLUS_EQUAL: op = RT_BINARY_OP_INPLACE_ADD; break; case MP_TOKEN_DEL_PLUS_EQUAL: op = MP_BINARY_OP_INPLACE_ADD; break;
case MP_TOKEN_DEL_MINUS_EQUAL: op = RT_BINARY_OP_INPLACE_SUBTRACT; break; case MP_TOKEN_DEL_MINUS_EQUAL: op = MP_BINARY_OP_INPLACE_SUBTRACT; break;
case MP_TOKEN_DEL_STAR_EQUAL: op = RT_BINARY_OP_INPLACE_MULTIPLY; break; case MP_TOKEN_DEL_STAR_EQUAL: op = MP_BINARY_OP_INPLACE_MULTIPLY; break;
case MP_TOKEN_DEL_DBL_SLASH_EQUAL: op = RT_BINARY_OP_INPLACE_FLOOR_DIVIDE; break; case MP_TOKEN_DEL_DBL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_FLOOR_DIVIDE; break;
case MP_TOKEN_DEL_SLASH_EQUAL: op = RT_BINARY_OP_INPLACE_TRUE_DIVIDE; break; case MP_TOKEN_DEL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_TRUE_DIVIDE; break;
case MP_TOKEN_DEL_PERCENT_EQUAL: op = RT_BINARY_OP_INPLACE_MODULO; break; case MP_TOKEN_DEL_PERCENT_EQUAL: op = MP_BINARY_OP_INPLACE_MODULO; break;
case MP_TOKEN_DEL_DBL_STAR_EQUAL: op = RT_BINARY_OP_INPLACE_POWER; break; case MP_TOKEN_DEL_DBL_STAR_EQUAL: op = MP_BINARY_OP_INPLACE_POWER; break;
default: assert(0); op = RT_BINARY_OP_INPLACE_OR; // shouldn't happen default: assert(0); op = MP_BINARY_OP_INPLACE_OR; // shouldn't happen
} }
EMIT_ARG(binary_op, op); EMIT_ARG(binary_op, op);
c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign 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); int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
compile_node(comp, pns->nodes[0]); compile_node(comp, pns->nodes[0]);
for (int i = 1; i < num_nodes; i += 1) { 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) { void compile_not_test_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[0]); 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) { 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); EMIT(rot_three);
} }
if (MP_PARSE_NODE_IS_TOKEN(pns->nodes[i])) { 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])) { switch (MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])) {
case MP_TOKEN_OP_LESS: op = RT_BINARY_OP_LESS; break; case MP_TOKEN_OP_LESS: op = MP_BINARY_OP_LESS; break;
case MP_TOKEN_OP_MORE: op = RT_BINARY_OP_MORE; break; case MP_TOKEN_OP_MORE: op = MP_BINARY_OP_MORE; break;
case MP_TOKEN_OP_DBL_EQUAL: op = RT_BINARY_OP_EQUAL; break; case MP_TOKEN_OP_DBL_EQUAL: op = MP_BINARY_OP_EQUAL; break;
case MP_TOKEN_OP_LESS_EQUAL: op = RT_BINARY_OP_LESS_EQUAL; break; case MP_TOKEN_OP_LESS_EQUAL: op = MP_BINARY_OP_LESS_EQUAL; break;
case MP_TOKEN_OP_MORE_EQUAL: op = RT_BINARY_OP_MORE_EQUAL; break; case MP_TOKEN_OP_MORE_EQUAL: op = MP_BINARY_OP_MORE_EQUAL; break;
case MP_TOKEN_OP_NOT_EQUAL: op = RT_BINARY_OP_NOT_EQUAL; break; case MP_TOKEN_OP_NOT_EQUAL: op = MP_BINARY_OP_NOT_EQUAL; break;
case MP_TOKEN_KW_IN: op = RT_BINARY_OP_IN; break; case MP_TOKEN_KW_IN: op = MP_BINARY_OP_IN; break;
default: assert(0); op = RT_BINARY_OP_LESS; // shouldn't happen default: assert(0); op = MP_BINARY_OP_LESS; // shouldn't happen
} }
EMIT_ARG(binary_op, op); EMIT_ARG(binary_op, op);
} else if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])) { } else if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])) {
mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)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); int kind = MP_PARSE_NODE_STRUCT_KIND(pns2);
if (kind == PN_comp_op_not_in) { 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) { } else if (kind == PN_comp_op_is) {
if (MP_PARSE_NODE_IS_NULL(pns2->nodes[0])) { 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 { } else {
EMIT_ARG(binary_op, RT_BINARY_OP_IS_NOT); EMIT_ARG(binary_op, MP_BINARY_OP_IS_NOT);
} }
} else { } else {
// shouldn't happen // 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) { 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) { 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) { 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) { 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) { for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]); compile_node(comp, pns->nodes[i + 1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_DBL_LESS)) { 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)) { } 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 { } else {
// shouldn't happen // shouldn't happen
assert(0); 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) { for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]); compile_node(comp, pns->nodes[i + 1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_PLUS)) { 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)) { } 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 { } else {
// shouldn't happen // shouldn't happen
assert(0); 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) { for (int i = 1; i + 1 < num_nodes; i += 2) {
compile_node(comp, pns->nodes[i + 1]); compile_node(comp, pns->nodes[i + 1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[i], MP_TOKEN_OP_STAR)) { 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)) { } 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)) { } 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)) { } 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 { } else {
// shouldn't happen // shouldn't happen
assert(0); 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) { void compile_factor_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[1]); compile_node(comp, pns->nodes[1]);
if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[0], MP_TOKEN_OP_PLUS)) { 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)) { } 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)) { } 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 { } else {
// shouldn't happen // shouldn't happen
assert(0); 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) { void compile_power_dbl_star(compiler_t *comp, mp_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[0]); 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) { 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) { void compile_trailer_bracket(compiler_t *comp, mp_parse_node_struct_t *pns) {
// object who's index we want is on top of stack // object who's index we want is on top of stack
compile_node(comp, pns->nodes[0]); // the index 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) { 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 #else
// return function that executes the outer module // 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 // 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 #endif
} }
} }

4
py/emit.h
Wyświetl plik

@ -84,8 +84,8 @@ typedef struct _emit_method_table_t {
void (*for_iter_end)(emit_t *emit); void (*for_iter_end)(emit_t *emit);
void (*pop_block)(emit_t *emit); void (*pop_block)(emit_t *emit);
void (*pop_except)(emit_t *emit); void (*pop_except)(emit_t *emit);
void (*unary_op)(emit_t *emit, rt_unary_op_t op); void (*unary_op)(emit_t *emit, mp_unary_op_t op);
void (*binary_op)(emit_t *emit, rt_binary_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_tuple)(emit_t *emit, int n_args);
void (*build_list)(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); void (*list_append)(emit_t *emit, int list_stack_index);

16
py/emitbc.c
Wyświetl plik

@ -632,10 +632,10 @@ STATIC void emit_bc_pop_except(emit_t *emit) {
emit_write_byte_code_byte(emit, MP_BC_POP_EXCEPT); emit_write_byte_code_byte(emit, MP_BC_POP_EXCEPT);
} }
STATIC void emit_bc_unary_op(emit_t *emit, rt_unary_op_t op) { STATIC void emit_bc_unary_op(emit_t *emit, mp_unary_op_t op) {
if (op == RT_UNARY_OP_NOT) { if (op == MP_UNARY_OP_NOT) {
emit_bc_pre(emit, 0); 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_bc_pre(emit, 0);
emit_write_byte_code_byte(emit, MP_BC_NOT); emit_write_byte_code_byte(emit, MP_BC_NOT);
} else { } 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; bool invert = false;
if (op == RT_BINARY_OP_NOT_IN) { if (op == MP_BINARY_OP_NOT_IN) {
invert = true; invert = true;
op = RT_BINARY_OP_IN; op = MP_BINARY_OP_IN;
} else if (op == RT_BINARY_OP_IS_NOT) { } else if (op == MP_BINARY_OP_IS_NOT) {
invert = true; invert = true;
op = RT_BINARY_OP_IS; op = MP_BINARY_OP_IS;
} }
emit_bc_pre(emit, -1); emit_bc_pre(emit, -1);
emit_write_byte_code_byte_byte(emit, MP_BC_BINARY_OP, op); emit_write_byte_code_byte_byte(emit, MP_BC_BINARY_OP, op);

86
py/emitcpy.c
Wyświetl plik

@ -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); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
switch (op) { switch (op) {
case RT_UNARY_OP_POSITIVE: printf("UNARY_POSITIVE\n"); break; case MP_UNARY_OP_POSITIVE: printf("UNARY_POSITIVE\n"); break;
case RT_UNARY_OP_NEGATIVE: printf("UNARY_NEGATIVE\n"); break; case MP_UNARY_OP_NEGATIVE: printf("UNARY_NEGATIVE\n"); break;
case RT_UNARY_OP_INVERT: printf("UNARY_INVERT\n"); break; case MP_UNARY_OP_INVERT: printf("UNARY_INVERT\n"); break;
case RT_UNARY_OP_NOT: printf("UNARY_NOT\n"); break; case MP_UNARY_OP_NOT: printf("UNARY_NOT\n"); break;
default: assert(0); default: assert(0);
} }
} }
} }
STATIC void emit_cpy_binary_op(emit_t *emit, rt_binary_op_t op) { STATIC void emit_cpy_binary_op(emit_t *emit, mp_binary_op_t op) {
if (op <= RT_BINARY_OP_INPLACE_POWER) { if (op <= MP_BINARY_OP_INPLACE_POWER) {
// CPython uses a byte code for each binary op // CPython uses a byte code for each binary op
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
} else { } else {
@ -564,42 +564,42 @@ STATIC void emit_cpy_binary_op(emit_t *emit, rt_binary_op_t op) {
} }
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
switch (op) { switch (op) {
case RT_BINARY_OP_SUBSCR: printf("BINARY_SUBSCR\n"); break; case MP_BINARY_OP_SUBSCR: printf("BINARY_SUBSCR\n"); break;
case RT_BINARY_OP_OR: printf("BINARY_OR\n"); break; case MP_BINARY_OP_OR: printf("BINARY_OR\n"); break;
case RT_BINARY_OP_XOR: printf("BINARY_XOR\n"); break; case MP_BINARY_OP_XOR: printf("BINARY_XOR\n"); break;
case RT_BINARY_OP_AND: printf("BINARY_AND\n"); break; case MP_BINARY_OP_AND: printf("BINARY_AND\n"); break;
case RT_BINARY_OP_LSHIFT: printf("BINARY_LSHIFT\n"); break; case MP_BINARY_OP_LSHIFT: printf("BINARY_LSHIFT\n"); break;
case RT_BINARY_OP_RSHIFT: printf("BINARY_RSHIFT\n"); break; case MP_BINARY_OP_RSHIFT: printf("BINARY_RSHIFT\n"); break;
case RT_BINARY_OP_ADD: printf("BINARY_ADD\n"); break; case MP_BINARY_OP_ADD: printf("BINARY_ADD\n"); break;
case RT_BINARY_OP_SUBTRACT: printf("BINARY_SUBTRACT\n"); break; case MP_BINARY_OP_SUBTRACT: printf("BINARY_SUBTRACT\n"); break;
case RT_BINARY_OP_MULTIPLY: printf("BINARY_MULTIPLY\n"); break; case MP_BINARY_OP_MULTIPLY: printf("BINARY_MULTIPLY\n"); break;
case RT_BINARY_OP_FLOOR_DIVIDE: printf("BINARY_FLOOR_DIVIDE\n"); break; case MP_BINARY_OP_FLOOR_DIVIDE: printf("BINARY_FLOOR_DIVIDE\n"); break;
case RT_BINARY_OP_TRUE_DIVIDE: printf("BINARY_TRUE_DIVIDE\n"); break; case MP_BINARY_OP_TRUE_DIVIDE: printf("BINARY_TRUE_DIVIDE\n"); break;
case RT_BINARY_OP_MODULO: printf("BINARY_MODULO\n"); break; case MP_BINARY_OP_MODULO: printf("BINARY_MODULO\n"); break;
case RT_BINARY_OP_POWER: printf("BINARY_POWER\n"); break; case MP_BINARY_OP_POWER: printf("BINARY_POWER\n"); break;
case RT_BINARY_OP_INPLACE_OR: printf("INPLACE_OR\n"); break; case MP_BINARY_OP_INPLACE_OR: printf("INPLACE_OR\n"); break;
case RT_BINARY_OP_INPLACE_XOR: printf("INPLACE_XOR\n"); break; case MP_BINARY_OP_INPLACE_XOR: printf("INPLACE_XOR\n"); break;
case RT_BINARY_OP_INPLACE_AND: printf("INPLACE_AND\n"); break; case MP_BINARY_OP_INPLACE_AND: printf("INPLACE_AND\n"); break;
case RT_BINARY_OP_INPLACE_LSHIFT: printf("INPLACE_LSHIFT\n"); break; case MP_BINARY_OP_INPLACE_LSHIFT: printf("INPLACE_LSHIFT\n"); break;
case RT_BINARY_OP_INPLACE_RSHIFT: printf("INPLACE_RSHIFT\n"); break; case MP_BINARY_OP_INPLACE_RSHIFT: printf("INPLACE_RSHIFT\n"); break;
case RT_BINARY_OP_INPLACE_ADD: printf("INPLACE_ADD\n"); break; case MP_BINARY_OP_INPLACE_ADD: printf("INPLACE_ADD\n"); break;
case RT_BINARY_OP_INPLACE_SUBTRACT: printf("INPLACE_SUBTRACT\n"); break; case MP_BINARY_OP_INPLACE_SUBTRACT: printf("INPLACE_SUBTRACT\n"); break;
case RT_BINARY_OP_INPLACE_MULTIPLY: printf("INPLACE_MULTIPLY\n"); break; case MP_BINARY_OP_INPLACE_MULTIPLY: printf("INPLACE_MULTIPLY\n"); break;
case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: printf("INPLACE_FLOOR_DIVIDE\n"); break; case MP_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 MP_BINARY_OP_INPLACE_TRUE_DIVIDE: printf("INPLACE_TRUE_DIVIDE\n"); break;
case RT_BINARY_OP_INPLACE_MODULO: printf("INPLACE_MODULO\n"); break; case MP_BINARY_OP_INPLACE_MODULO: printf("INPLACE_MODULO\n"); break;
case RT_BINARY_OP_INPLACE_POWER: printf("INPLACE_POWER\n"); break; case MP_BINARY_OP_INPLACE_POWER: printf("INPLACE_POWER\n"); break;
case RT_BINARY_OP_LESS: printf("COMPARE_OP <\n"); break; case MP_BINARY_OP_LESS: printf("COMPARE_OP <\n"); break;
case RT_BINARY_OP_MORE: printf("COMPARE_OP >\n"); break; case MP_BINARY_OP_MORE: printf("COMPARE_OP >\n"); break;
case RT_BINARY_OP_EQUAL: printf("COMPARE_OP ==\n"); break; case MP_BINARY_OP_EQUAL: printf("COMPARE_OP ==\n"); break;
case RT_BINARY_OP_LESS_EQUAL: printf("COMPARE_OP <=\n"); break; case MP_BINARY_OP_LESS_EQUAL: printf("COMPARE_OP <=\n"); break;
case RT_BINARY_OP_MORE_EQUAL: printf("COMPARE_OP >=\n"); break; case MP_BINARY_OP_MORE_EQUAL: printf("COMPARE_OP >=\n"); break;
case RT_BINARY_OP_NOT_EQUAL: printf("COMPARE_OP !=\n"); break; case MP_BINARY_OP_NOT_EQUAL: printf("COMPARE_OP !=\n"); break;
case RT_BINARY_OP_IN: printf("COMPARE_OP in\n"); break; case MP_BINARY_OP_IN: printf("COMPARE_OP in\n"); break;
case RT_BINARY_OP_IS: printf("COMPARE_OP is\n"); break; case MP_BINARY_OP_IS: printf("COMPARE_OP is\n"); break;
case RT_BINARY_OP_EXCEPTION_MATCH: printf("COMPARE_OP exception match\n"); break; case MP_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 MP_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_IS_NOT: printf("COMPARE_OP is not\n"); break;
default: assert(0); default: assert(0);
} }
} }

8
py/emitglue.c
Wyświetl plik

@ -190,7 +190,7 @@ void mp_emit_glue_assign_inline_asm_code(uint unique_code_id, void *fun, uint le
#endif #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); DEBUG_OP_printf("make_function_from_id %d\n", unique_code_id);
if (unique_code_id >= unique_codes_total) { if (unique_code_id >= unique_codes_total) {
// illegal code id // 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); fun = mp_obj_new_fun_bc(c->scope_flags, c->arg_names, c->n_args, def_args, c->u_byte.code);
break; break;
case MP_CODE_NATIVE: 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; break;
case MP_CODE_INLINE_ASM: case MP_CODE_INLINE_ASM:
fun = mp_obj_new_fun_asm(c->n_args, c->u_inline_asm.fun); 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; 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); DEBUG_OP_printf("make_closure_from_id %d\n", unique_code_id);
// make function object // 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 // wrap function in closure object
return mp_obj_new_closure(ffun, closure_tuple); return mp_obj_new_closure(ffun, closure_tuple);
} }

94
py/emitnative.c
Wyświetl plik

@ -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 #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); 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); need_reg_all(emit);
#if N_X64 #if N_X64
asm_x64_call_ind(emit->as, fun, REG_RAX); asm_x64_call_ind(emit->as, fun, REG_RAX);
#elif N_THUMB #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 #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); need_reg_all(emit);
ASM_MOV_IMM_TO_REG(arg_val, arg_reg); ASM_MOV_IMM_TO_REG(arg_val, arg_reg);
#if N_X64 #if N_X64
asm_x64_call_ind(emit->as, fun, REG_RAX); asm_x64_call_ind(emit->as, fun, REG_RAX);
#elif N_THUMB #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 #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); need_reg_all(emit);
ASM_MOV_IMM_TO_REG(arg_val1, arg_reg1); ASM_MOV_IMM_TO_REG(arg_val1, arg_reg1);
ASM_MOV_IMM_TO_REG(arg_val2, arg_reg2); ASM_MOV_IMM_TO_REG(arg_val2, arg_reg2);
#if N_X64 #if N_X64
asm_x64_call_ind(emit->as, fun, REG_RAX); asm_x64_call_ind(emit->as, fun, REG_RAX);
#elif N_THUMB #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 #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) { STATIC void emit_native_load_const_dec(emit_t *emit, qstr qstr) {
// for viper, a float/complex is just a Python object // for viper, a float/complex is just a Python object
emit_native_pre(emit); 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); 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) { if (emit->do_viper_types) {
assert(0); assert(0);
} else { } 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); 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); assert(0);
emit_post_push_imm(emit, VTYPE_PTR, (machine_uint_t)qstr_str(qstr)); emit_post_push_imm(emit, VTYPE_PTR, (machine_uint_t)qstr_str(qstr));
} else { } 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); 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) { STATIC void emit_native_load_name(emit_t *emit, qstr qstr) {
emit_native_pre(emit); 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); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
} }
STATIC void emit_native_load_global(emit_t *emit, qstr qstr) { STATIC void emit_native_load_global(emit_t *emit, qstr qstr) {
emit_native_pre(emit); 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); 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: // depends on type of subject:
// - integer, function, pointer to integers: error // - integer, function, pointer to integers: error
// - pointer to structure: get member, quite easy // - 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; vtype_kind_t vtype_base;
emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
assert(vtype_base == VTYPE_PYOBJ); 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); 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 emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
assert(vtype_base == VTYPE_PYOBJ); assert(vtype_base == VTYPE_PYOBJ);
emit_get_stack_pointer_to_reg_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr 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) { STATIC void emit_native_load_build_class(emit_t *emit) {
emit_native_pre(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); 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) { 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; vtype_kind_t vtype;
emit_pre_pop_reg(emit, &vtype, REG_ARG_2); emit_pre_pop_reg(emit, &vtype, REG_ARG_2);
assert(vtype == VTYPE_PYOBJ); 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); 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 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_base == VTYPE_PYOBJ);
assert(vtype_val == 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); emit_post(emit);
} }
@ -815,7 +815,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
assert(vtype_index == VTYPE_PYOBJ); assert(vtype_index == VTYPE_PYOBJ);
assert(vtype_base == VTYPE_PYOBJ); assert(vtype_base == VTYPE_PYOBJ);
assert(vtype_value == 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) { 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) { STATIC void emit_native_delete_name(emit_t *emit, qstr qstr) {
// not implemented // not implemented
// use rt_delete_name // use mp_delete_name
assert(0); assert(0);
} }
STATIC void emit_native_delete_global(emit_t *emit, qstr qstr) { STATIC void emit_native_delete_global(emit_t *emit, qstr qstr) {
// not implemented // not implemented
// use rt_delete_global // use mp_delete_global
assert(0); 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); emit_pre_pop_reg(emit, &vtype, REG_RET);
} else if (vtype == VTYPE_PYOBJ) { } else if (vtype == VTYPE_PYOBJ) {
emit_pre_pop_reg(emit, &vtype, REG_ARG_1); 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 { } else {
printf("ViperTypeError: expecting a bool or pyobj, got %d\n", vtype); printf("ViperTypeError: expecting a bool or pyobj, got %d\n", vtype);
assert(0); assert(0);
@ -977,7 +977,7 @@ STATIC void emit_native_get_iter(emit_t *emit) {
vtype_kind_t vtype; vtype_kind_t vtype;
emit_pre_pop_reg(emit, &vtype, REG_ARG_1); emit_pre_pop_reg(emit, &vtype, REG_ARG_1);
assert(vtype == VTYPE_PYOBJ); 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); 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; vtype_kind_t vtype;
emit_access_stack(emit, 1, &vtype, REG_ARG_1); emit_access_stack(emit, 1, &vtype, REG_ARG_1);
assert(vtype == VTYPE_PYOBJ); 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); ASM_MOV_IMM_TO_REG((machine_uint_t)MP_OBJ_NULL, REG_TEMP1);
#if N_X64 #if N_X64
asm_x64_cmp_r64_with_r64(emit->as, REG_RET, REG_TEMP1); 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); 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; vtype_kind_t vtype;
emit_pre_pop_reg(emit, &vtype, REG_ARG_2); emit_pre_pop_reg(emit, &vtype, REG_ARG_2);
assert(vtype == VTYPE_PYOBJ); 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); 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; vtype_kind_t vtype_lhs, vtype_rhs;
emit_pre_pop_reg_reg(emit, &vtype_rhs, REG_ARG_3, &vtype_lhs, REG_ARG_2); 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 (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 #if N_X64
asm_x64_add_r64_to_r64(emit->as, REG_ARG_3, REG_ARG_2); asm_x64_add_r64_to_r64(emit->as, REG_ARG_3, REG_ARG_2);
#elif N_THUMB #elif N_THUMB
asm_thumb_add_reg_reg_reg(emit->as, REG_ARG_2, REG_ARG_2, REG_ARG_3); asm_thumb_add_reg_reg_reg(emit->as, REG_ARG_2, REG_ARG_2, REG_ARG_3);
#endif #endif
emit_post_push_reg(emit, VTYPE_INT, REG_ARG_2); 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 #if N_X64
asm_x64_xor_r64_to_r64(emit->as, REG_RET, REG_RET); 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); 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); assert(0);
} }
} else if (vtype_lhs == VTYPE_PYOBJ && vtype_rhs == VTYPE_PYOBJ) { } 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); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
} else { } else {
printf("ViperTypeError: can't do binary op between types %d and %d\n", vtype_lhs, vtype_rhs); 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 // if wrapped in byte_array, or something, allocates memory and fills it
emit_native_pre(emit); emit_native_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items 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 emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new tuple
} }
STATIC void emit_native_build_list(emit_t *emit, int n_args) { STATIC void emit_native_build_list(emit_t *emit, int n_args) {
emit_native_pre(emit); emit_native_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items 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 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); emit_access_stack(emit, list_index, &vtype_list, REG_ARG_1);
assert(vtype_list == VTYPE_PYOBJ); assert(vtype_list == VTYPE_PYOBJ);
assert(vtype_item == 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); emit_post(emit);
} }
STATIC void emit_native_build_map(emit_t *emit, int n_args) { STATIC void emit_native_build_map(emit_t *emit, int n_args) {
emit_native_pre(emit); 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 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_key == VTYPE_PYOBJ);
assert(vtype_value == VTYPE_PYOBJ); assert(vtype_value == VTYPE_PYOBJ);
assert(vtype_map == 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 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_map == VTYPE_PYOBJ);
assert(vtype_key == VTYPE_PYOBJ); assert(vtype_key == VTYPE_PYOBJ);
assert(vtype_value == 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); emit_post(emit);
} }
STATIC void emit_native_build_set(emit_t *emit, int n_args) { STATIC void emit_native_build_set(emit_t *emit, int n_args) {
emit_native_pre(emit); emit_native_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items 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 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); emit_access_stack(emit, set_index, &vtype_set, REG_ARG_1);
assert(vtype_set == VTYPE_PYOBJ); assert(vtype_set == VTYPE_PYOBJ);
assert(vtype_item == 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); 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 // 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); assert(n_default_params == 0 && n_dict_params == 0);
emit_native_pre(emit); 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); 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; vtype_kind_t vtype_fun;
emit_pre_pop_reg(emit, &vtype_fun, REG_ARG_1); // the function emit_pre_pop_reg(emit, &vtype_fun, REG_ARG_1); // the function
assert(vtype_fun == VTYPE_PYOBJ); 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) { } else if (n_positional == 1) {
vtype_kind_t vtype_fun, vtype_arg1; 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 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_fun == VTYPE_PYOBJ);
assert(vtype_arg1 == 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) { } else if (n_positional == 2) {
vtype_kind_t vtype_fun, vtype_arg1, vtype_arg2; 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 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_fun == VTYPE_PYOBJ);
assert(vtype_arg1 == VTYPE_PYOBJ); assert(vtype_arg1 == VTYPE_PYOBJ);
assert(vtype_arg2 == 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 { } 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; vtype_kind_t vtype_fun;
emit_pre_pop_reg(emit, &vtype_fun, REG_ARG_1); // the function emit_pre_pop_reg(emit, &vtype_fun, REG_ARG_1); // the function
assert(vtype_fun == VTYPE_PYOBJ); 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); 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 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_meth == VTYPE_PYOBJ);
assert(vtype_self == 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) { } else if (n_positional == 1) {
vtype_kind_t vtype_meth, vtype_self, vtype_arg1; 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 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_meth == VTYPE_PYOBJ);
assert(vtype_self == VTYPE_PYOBJ); assert(vtype_self == VTYPE_PYOBJ);
assert(vtype_arg1 == 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 { } else {
*/ */
emit_native_pre(emit); 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_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); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
} }

39
py/obj.c
Wyświetl plik

@ -67,6 +67,39 @@ void mp_obj_print_exception(mp_obj_t exc) {
printf("\n"); 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) { bool mp_obj_is_callable(mp_obj_t o_in) {
return mp_obj_get_type(o_in)->call != NULL; 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 // If o2 is long int, dispatch to its virtual methods
mp_obj_base_t *o = o2; mp_obj_base_t *o = o2;
if (o->type->binary_op != NULL) { 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; return r == mp_const_true ? true : false;
} }
} }
@ -132,7 +165,7 @@ bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2) {
} else { } else {
mp_obj_base_t *o = o1; mp_obj_base_t *o = o1;
if (o->type->binary_op != NULL) { 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) { if (r != MP_OBJ_NULL) {
return r == mp_const_true ? true : false; return r == mp_const_true ? true : false;
} }
@ -271,7 +304,7 @@ mp_obj_t mp_obj_len_maybe(mp_obj_t o_in) {
} else { } else {
mp_obj_type_t *type = mp_obj_get_type(o_in); mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->unary_op != NULL) { 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 { } else {
return MP_OBJ_NULL; return MP_OBJ_NULL;
} }

1
py/obj.h
Wyświetl plik

@ -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(mp_obj_t o, mp_print_kind_t kind);
void mp_obj_print_exception(mp_obj_t exc); 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); bool mp_obj_is_callable(mp_obj_t o_in);
machine_int_t mp_obj_hash(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); bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2);

10
py/objarray.c
Wyświetl plik

@ -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_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; mp_obj_t item;
int i = 0; int i = 0;
while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) { while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (len == 0) { if (len == 0) {
array_append(array, item); array_append(array, item);
} else { } 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) { STATIC mp_obj_t array_unary_op(int op, mp_obj_t o_in) {
mp_obj_array_t *o = o_in; mp_obj_array_t *o = o_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(o->len != 0); case MP_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_LEN: return MP_OBJ_NEW_SMALL_INT(o->len);
default: return MP_OBJ_NULL; // op not supported 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) { STATIC mp_obj_t array_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_array_t *o = lhs; mp_obj_array_t *o = lhs;
switch (op) { switch (op) {
case RT_BINARY_OP_SUBSCR: case MP_BINARY_OP_SUBSCR:
{ {
uint index = mp_get_index(o->base.type, o->len, rhs, false); uint index = mp_get_index(o->base.type, o->len, rhs, false);
return mp_binary_get_val(o->typecode, o->items, index); return mp_binary_get_val(o->typecode, o->items, index);

10
py/objbool.c
Wyświetl plik

@ -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) { switch (n_args) {
case 0: return mp_const_false; 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)); 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) { 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; machine_int_t value = ((mp_obj_bool_t*)o_in)->value;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return o_in; case MP_UNARY_OP_BOOL: return o_in;
case RT_UNARY_OP_POSITIVE: return MP_OBJ_NEW_SMALL_INT(value); case MP_UNARY_OP_POSITIVE: return MP_OBJ_NEW_SMALL_INT(value);
case RT_UNARY_OP_NEGATIVE: return MP_OBJ_NEW_SMALL_INT(-value); case MP_UNARY_OP_NEGATIVE: return MP_OBJ_NEW_SMALL_INT(-value);
case RT_UNARY_OP_INVERT: case MP_UNARY_OP_INVERT:
default: // no other cases default: // no other cases
return MP_OBJ_NEW_SMALL_INT(~value); return MP_OBJ_NEW_SMALL_INT(~value);
} }

4
py/objboundmeth.c
Wyświetl plik

@ -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]; mp_obj_t args2[5];
args2[0] = self->self; args2[0] = self->self;
memcpy(args2 + 1, args, n_total * sizeof(mp_obj_t)); 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 { } else {
// use heap to allocate temporary args array // use heap to allocate temporary args array
mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_total); mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_total);
args2[0] = self->self; args2[0] = self->self;
memcpy(args2 + 1, args, n_total * sizeof(mp_obj_t)); 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); m_del(mp_obj_t, args2, 1 + n_total);
return res; return res;
} }

4
py/objclosure.c
Wyświetl plik

@ -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]; mp_obj_t args2[5];
memcpy(args2, self->closed, self->n_closed * sizeof(mp_obj_t)); 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)); 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 { } else {
// use heap to allocate temporary args array // use heap to allocate temporary args array
mp_obj_t *args2 = m_new(mp_obj_t, n_total); 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->closed, self->n_closed * sizeof(mp_obj_t));
memcpy(args2 + self->n_closed, args, (n_args + 2 * n_kw) * 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); m_del(mp_obj_t, args2, n_total);
return res; return res;
} }

26
py/objcomplex.c
Wyświetl plik

@ -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) { STATIC mp_obj_t complex_unary_op(int op, mp_obj_t o_in) {
mp_obj_complex_t *o = o_in; mp_obj_complex_t *o = o_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(o->real != 0 || o->imag != 0); case MP_UNARY_OP_BOOL: return MP_BOOL(o->real != 0 || o->imag != 0);
case RT_UNARY_OP_POSITIVE: return o_in; case MP_UNARY_OP_POSITIVE: return o_in;
case RT_UNARY_OP_NEGATIVE: return mp_obj_new_complex(-o->real, -o->imag); case MP_UNARY_OP_NEGATIVE: return mp_obj_new_complex(-o->real, -o->imag);
default: return MP_OBJ_NULL; // op not supported 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_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) mp_obj_get_complex(rhs_in, &rhs_real, &rhs_imag); // can be any type, this function will convert to float (if possible)
switch (op) { switch (op) {
case RT_BINARY_OP_ADD: case MP_BINARY_OP_ADD:
case RT_BINARY_OP_INPLACE_ADD: case MP_BINARY_OP_INPLACE_ADD:
lhs_real += rhs_real; lhs_real += rhs_real;
lhs_imag += rhs_imag; lhs_imag += rhs_imag;
break; break;
case RT_BINARY_OP_SUBTRACT: case MP_BINARY_OP_SUBTRACT:
case RT_BINARY_OP_INPLACE_SUBTRACT: case MP_BINARY_OP_INPLACE_SUBTRACT:
lhs_real -= rhs_real; lhs_real -= rhs_real;
lhs_imag -= rhs_imag; lhs_imag -= rhs_imag;
break; break;
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
case RT_BINARY_OP_INPLACE_MULTIPLY: case MP_BINARY_OP_INPLACE_MULTIPLY:
{ {
mp_float_t real = lhs_real * rhs_real - lhs_imag * rhs_imag; mp_float_t real = lhs_real * rhs_real - lhs_imag * rhs_imag;
lhs_imag = lhs_real * rhs_imag + lhs_imag * rhs_real; 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; break;
} }
/* TODO floor(?) the value /* TODO floor(?) the value
case RT_BINARY_OP_FLOOR_DIVIDE: case MP_BINARY_OP_FLOOR_DIVIDE:
case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break; case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break;
*/ */
/* TODO /* TODO
case RT_BINARY_OP_TRUE_DIVIDE: case MP_BINARY_OP_TRUE_DIVIDE:
case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: val = lhs_val / rhs_val; break; case MP_BINARY_OP_INPLACE_TRUE_DIVIDE: val = lhs_val / rhs_val; break;
*/ */
return NULL; // op not supported return NULL; // op not supported
} }

28
py/objdict.c
Wyświetl plik

@ -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) { 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! // 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) { STATIC mp_obj_t dict_unary_op(int op, mp_obj_t self_in) {
mp_obj_dict_t *self = self_in; mp_obj_dict_t *self = self_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(self->map.used != 0); case MP_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_LEN: return MP_OBJ_NEW_SMALL_INT((machine_int_t)self->map.used);
default: return MP_OBJ_NULL; // op not supported for None 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) { 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; mp_obj_dict_t *o = lhs_in;
switch (op) { switch (op) {
case RT_BINARY_OP_SUBSCR: case MP_BINARY_OP_SUBSCR:
{ {
// dict load // dict load
mp_map_elem_t *elem = mp_map_lookup(&o->map, rhs_in, MP_MAP_LOOKUP); 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; 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); mp_map_elem_t *elem = mp_map_lookup(&o->map, rhs_in, MP_MAP_LOOKUP);
return MP_BOOL(elem != NULL); 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 // this is a classmethod
STATIC mp_obj_t dict_fromkeys(uint n_args, const mp_obj_t *args) { STATIC mp_obj_t dict_fromkeys(uint n_args, const mp_obj_t *args) {
assert(2 <= n_args && n_args <= 3); 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 len = mp_obj_len_maybe(iter);
mp_obj_t value = mp_const_none; mp_obj_t value = mp_const_none;
mp_obj_t next = NULL; 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)); 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; 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)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_dict));
mp_obj_dict_t *self = self_in; mp_obj_dict_t *self = self_in;
/* TODO: check for the "keys" method */ /* 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; mp_obj_t next = NULL;
while ((next = rt_iternext(iter)) != MP_OBJ_NULL) { while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
mp_obj_t inneriter = rt_getiter(next); mp_obj_t inneriter = mp_getiter(next);
mp_obj_t key = rt_iternext(inneriter); mp_obj_t key = mp_iternext(inneriter);
mp_obj_t value = rt_iternext(inneriter); mp_obj_t value = mp_iternext(inneriter);
mp_obj_t stop = rt_iternext(inneriter); mp_obj_t stop = mp_iternext(inneriter);
if (key == MP_OBJ_NULL if (key == MP_OBJ_NULL
|| value == MP_OBJ_NULL || value == MP_OBJ_NULL
|| stop != 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 */ /* only supported for the 'keys' kind until sets and dicts are refactored */
mp_obj_dict_view_t *o = lhs_in; mp_obj_dict_view_t *o = lhs_in;
if (o->kind != MP_DICT_VIEW_KEYS) return NULL; 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); return dict_binary_op(op, o->dict, rhs_in);
} }

4
py/objenumerate.c
Wyświetl plik

@ -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); assert(n_args > 0);
mp_obj_enumerate_t *o = m_new_obj(mp_obj_enumerate_t); mp_obj_enumerate_t *o = m_new_obj(mp_obj_enumerate_t);
o->base.type = &mp_type_enumerate; 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; o->cur = n_args > 1 ? mp_obj_get_int(args[1]) : 0;
return o; 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) { STATIC mp_obj_t enumerate_iternext(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_enumerate)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_enumerate));
mp_obj_enumerate_t *self = self_in; 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) { if (next == MP_OBJ_NULL) {
return MP_OBJ_NULL; return MP_OBJ_NULL;
} else { } else {

2
py/objexcept.c
Wyświetl plik

@ -244,7 +244,7 @@ bool mp_obj_is_exception_instance(mp_obj_t self_in) {
// exception type. // exception type.
bool mp_obj_exception_match(mp_obj_t exc, const mp_obj_type_t *exc_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. // 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) { void mp_obj_exception_clear_traceback(mp_obj_t self_in) {

8
py/objfilter.c
Wyświetl plik

@ -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); mp_obj_filter_t *o = m_new_obj(mp_obj_filter_t);
o->base.type = &mp_type_filter; o->base.type = &mp_type_filter;
o->fun = args[0]; o->fun = args[0];
o->iter = rt_getiter(args[1]); o->iter = mp_getiter(args[1]);
return o; 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)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_filter));
mp_obj_filter_t *self = self_in; mp_obj_filter_t *self = self_in;
mp_obj_t next; 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; mp_obj_t val;
if (self->fun != mp_const_none) { 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 { } else {
val = next; val = next;
} }
if (rt_is_true(val)) { if (mp_obj_is_true(val)) {
return next; return next;
} }
} }

34
py/objfloat.c
Wyświetl plik

@ -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) { STATIC mp_obj_t float_unary_op(int op, mp_obj_t o_in) {
mp_obj_float_t *o = o_in; mp_obj_float_t *o = o_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(o->value != 0); case MP_UNARY_OP_BOOL: return MP_BOOL(o->value != 0);
case RT_UNARY_OP_POSITIVE: return o_in; case MP_UNARY_OP_POSITIVE: return o_in;
case RT_UNARY_OP_NEGATIVE: return mp_obj_new_float(-o->value); case MP_UNARY_OP_NEGATIVE: return mp_obj_new_float(-o->value);
default: return NULL; // op not supported 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_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) 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) { switch (op) {
case RT_BINARY_OP_ADD: case MP_BINARY_OP_ADD:
case RT_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break; case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
case RT_BINARY_OP_SUBTRACT: case MP_BINARY_OP_SUBTRACT:
case RT_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break; case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
case RT_BINARY_OP_INPLACE_MULTIPLY: lhs_val *= rhs_val; break; case MP_BINARY_OP_INPLACE_MULTIPLY: lhs_val *= rhs_val; break;
/* TODO floor(?) the value /* TODO floor(?) the value
case RT_BINARY_OP_FLOOR_DIVIDE: case MP_BINARY_OP_FLOOR_DIVIDE:
case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break; case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break;
*/ */
case RT_BINARY_OP_TRUE_DIVIDE: case MP_BINARY_OP_TRUE_DIVIDE:
case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: case MP_BINARY_OP_INPLACE_TRUE_DIVIDE:
lhs_val /= rhs_val; lhs_val /= rhs_val;
if (isinf(lhs_val)){ // check for division by zero if (isinf(lhs_val)){ // check for division by zero
nlr_jump(mp_obj_new_exception_msg(&mp_type_ZeroDivisionError, "float division by zero")); nlr_jump(mp_obj_new_exception_msg(&mp_type_ZeroDivisionError, "float division by zero"));
} }
break; break;
case RT_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val); case MP_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val);
case RT_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val); case MP_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val);
case RT_BINARY_OP_LESS_EQUAL: return MP_BOOL(lhs_val <= rhs_val); case MP_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_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val);
return NULL; // op not supported return NULL; // op not supported
} }

18
py/objfun.c
Wyświetl plik

@ -26,10 +26,10 @@
// mp_obj_fun_native_t defined in obj.h // 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) { 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) { if (n_kw && !is_kw) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError,
"function does not take keyword arguments")); "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 // 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); mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
o->base.type = &mp_type_fun_native; o->base.type = &mp_type_fun_native;
o->is_kw = false; o->is_kw = false;
@ -116,7 +116,7 @@ mp_obj_t rt_make_function_n(int n_args, void *fun) {
return o; 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); mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
o->base.type = &mp_type_fun_native; o->base.type = &mp_type_fun_native;
o->is_kw = false; 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 // 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); mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
o->base.type = &mp_type_fun_native; o->base.type = &mp_type_fun_native;
o->is_kw = false; o->is_kw = false;
@ -278,14 +278,14 @@ continue2:;
} }
} }
mp_map_t *old_globals = rt_globals_get(); mp_map_t *old_globals = mp_globals_get();
rt_globals_set(self->globals); mp_globals_set(self->globals);
mp_obj_t result; 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); 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(args, n_args);
dump_args(extra_args, n_extra_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); 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) { if (vm_return_kind == MP_VM_RETURN_NORMAL) {
return result; 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); 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->base.type = &mp_type_fun_bc;
o->globals = rt_globals_get(); o->globals = mp_globals_get();
o->args = args; o->args = args;
o->n_args = n_args; o->n_args = n_args;
o->n_def_args = n_def_args; o->n_def_args = n_def_args;

2
py/objgenerator.c
Wyświetl plik

@ -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_close(mp_obj_t self_in);
STATIC mp_obj_t gen_instance_throw(uint n_args, const mp_obj_t *args) { 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]; 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)) { if (mp_obj_is_subclass_fast(mp_obj_get_type(exc), &mp_type_GeneratorExit)) {
// Throwing GeneratorExit is equivalent of calling close aka // Throwing GeneratorExit is equivalent of calling close aka
// GeneratorExit should be handled specially // GeneratorExit should be handled specially

4
py/objgetitemiter.c
Wyświetl plik

@ -19,7 +19,7 @@ STATIC mp_obj_t it_iternext(mp_obj_t self_in) {
nlr_buf_t nlr; nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
// try to get next item // 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); self->args[2] = MP_OBJ_NEW_SMALL_INT(MP_OBJ_SMALL_INT_VALUE(self->args[2]) + 1);
nlr_pop(); nlr_pop();
return value; return value;
@ -41,7 +41,7 @@ STATIC const mp_obj_type_t it_type = {
.iternext = it_iternext .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_t mp_obj_new_getitem_iter(mp_obj_t *args) {
mp_obj_getitem_iter_t *o = m_new_obj(mp_obj_getitem_iter_t); mp_obj_getitem_iter_t *o = m_new_obj(mp_obj_getitem_iter_t);
o->base.type = &it_type; o->base.type = &it_type;

60
py/objint_longlong.c
Wyświetl plik

@ -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_t int_unary_op(int op, mp_obj_t o_in) {
mp_obj_int_t *o = o_in; mp_obj_int_t *o = o_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(o->val != 0); case MP_UNARY_OP_BOOL: return MP_BOOL(o->val != 0);
case RT_UNARY_OP_POSITIVE: return o_in; case MP_UNARY_OP_POSITIVE: return o_in;
case RT_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val); case MP_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_INVERT: return mp_obj_new_int_from_ll(~o->val);
default: return NULL; // op not supported 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) { switch (op) {
case RT_BINARY_OP_ADD: case MP_BINARY_OP_ADD:
case RT_BINARY_OP_INPLACE_ADD: case MP_BINARY_OP_INPLACE_ADD:
return mp_obj_new_int_from_ll(lhs_val + rhs_val); return mp_obj_new_int_from_ll(lhs_val + rhs_val);
case RT_BINARY_OP_SUBTRACT: case MP_BINARY_OP_SUBTRACT:
case RT_BINARY_OP_INPLACE_SUBTRACT: case MP_BINARY_OP_INPLACE_SUBTRACT:
return mp_obj_new_int_from_ll(lhs_val - rhs_val); return mp_obj_new_int_from_ll(lhs_val - rhs_val);
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
case RT_BINARY_OP_INPLACE_MULTIPLY: case MP_BINARY_OP_INPLACE_MULTIPLY:
return mp_obj_new_int_from_ll(lhs_val * rhs_val); return mp_obj_new_int_from_ll(lhs_val * rhs_val);
case RT_BINARY_OP_FLOOR_DIVIDE: case MP_BINARY_OP_FLOOR_DIVIDE:
case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
return mp_obj_new_int_from_ll(lhs_val / rhs_val); return mp_obj_new_int_from_ll(lhs_val / rhs_val);
case RT_BINARY_OP_MODULO: case MP_BINARY_OP_MODULO:
case RT_BINARY_OP_INPLACE_MODULO: case MP_BINARY_OP_INPLACE_MODULO:
return mp_obj_new_int_from_ll(lhs_val % rhs_val); return mp_obj_new_int_from_ll(lhs_val % rhs_val);
case RT_BINARY_OP_AND: case MP_BINARY_OP_AND:
case RT_BINARY_OP_INPLACE_AND: case MP_BINARY_OP_INPLACE_AND:
return mp_obj_new_int_from_ll(lhs_val & rhs_val); return mp_obj_new_int_from_ll(lhs_val & rhs_val);
case RT_BINARY_OP_OR: case MP_BINARY_OP_OR:
case RT_BINARY_OP_INPLACE_OR: case MP_BINARY_OP_INPLACE_OR:
return mp_obj_new_int_from_ll(lhs_val | rhs_val); return mp_obj_new_int_from_ll(lhs_val | rhs_val);
case RT_BINARY_OP_XOR: case MP_BINARY_OP_XOR:
case RT_BINARY_OP_INPLACE_XOR: case MP_BINARY_OP_INPLACE_XOR:
return mp_obj_new_int_from_ll(lhs_val ^ rhs_val); return mp_obj_new_int_from_ll(lhs_val ^ rhs_val);
case RT_BINARY_OP_LSHIFT: case MP_BINARY_OP_LSHIFT:
case RT_BINARY_OP_INPLACE_LSHIFT: case MP_BINARY_OP_INPLACE_LSHIFT:
return mp_obj_new_int_from_ll(lhs_val << (int)rhs_val); return mp_obj_new_int_from_ll(lhs_val << (int)rhs_val);
case RT_BINARY_OP_RSHIFT: case MP_BINARY_OP_RSHIFT:
case RT_BINARY_OP_INPLACE_RSHIFT: case MP_BINARY_OP_INPLACE_RSHIFT:
return mp_obj_new_int_from_ll(lhs_val >> (int)rhs_val); 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); return MP_BOOL(lhs_val < rhs_val);
case RT_BINARY_OP_MORE: case MP_BINARY_OP_MORE:
return MP_BOOL(lhs_val > rhs_val); 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); 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); return MP_BOOL(lhs_val >= rhs_val);
case RT_BINARY_OP_EQUAL: case MP_BINARY_OP_EQUAL:
return MP_BOOL(lhs_val == rhs_val); 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); return MP_BOOL(lhs_val != rhs_val);
default: default:

72
py/objint_mpz.c
Wyświetl plik

@ -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_t int_unary_op(int op, mp_obj_t o_in) {
mp_obj_int_t *o = o_in; mp_obj_int_t *o = o_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(!mpz_is_zero(&o->mpz)); case MP_UNARY_OP_BOOL: return MP_BOOL(!mpz_is_zero(&o->mpz));
case RT_UNARY_OP_POSITIVE: return o_in; case MP_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 MP_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_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 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; 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)) { 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)); 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; 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 (0) {
#if MICROPY_ENABLE_FLOAT #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 flhs = mpz_as_float(zlhs);
mp_float_t frhs = mpz_as_float(zrhs); mp_float_t frhs = mpz_as_float(zrhs);
return mp_obj_new_float(flhs / frhs); return mp_obj_new_float(flhs / frhs);
#endif #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(); mp_obj_int_t *res = mp_obj_int_new_mpz();
switch (op) { switch (op) {
case RT_BINARY_OP_ADD: case MP_BINARY_OP_ADD:
case RT_BINARY_OP_INPLACE_ADD: case MP_BINARY_OP_INPLACE_ADD:
mpz_add_inpl(&res->mpz, zlhs, zrhs); mpz_add_inpl(&res->mpz, zlhs, zrhs);
break; break;
case RT_BINARY_OP_SUBTRACT: case MP_BINARY_OP_SUBTRACT:
case RT_BINARY_OP_INPLACE_SUBTRACT: case MP_BINARY_OP_INPLACE_SUBTRACT:
mpz_sub_inpl(&res->mpz, zlhs, zrhs); mpz_sub_inpl(&res->mpz, zlhs, zrhs);
break; break;
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
case RT_BINARY_OP_INPLACE_MULTIPLY: case MP_BINARY_OP_INPLACE_MULTIPLY:
mpz_mul_inpl(&res->mpz, zlhs, zrhs); mpz_mul_inpl(&res->mpz, zlhs, zrhs);
break; break;
case RT_BINARY_OP_FLOOR_DIVIDE: case MP_BINARY_OP_FLOOR_DIVIDE:
case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: { case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: {
mpz_t rem; mpz_init_zero(&rem); mpz_t rem; mpz_init_zero(&rem);
mpz_divmod_inpl(&res->mpz, &rem, zlhs, zrhs); mpz_divmod_inpl(&res->mpz, &rem, zlhs, zrhs);
if (zlhs->neg != zrhs->neg) { 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); mpz_deinit(&rem);
break; break;
} }
case RT_BINARY_OP_MODULO: case MP_BINARY_OP_MODULO:
case RT_BINARY_OP_INPLACE_MODULO: { case MP_BINARY_OP_INPLACE_MODULO: {
mpz_t quo; mpz_init_zero(&quo); mpz_t quo; mpz_init_zero(&quo);
mpz_divmod_inpl(&quo, &res->mpz, zlhs, zrhs); mpz_divmod_inpl(&quo, &res->mpz, zlhs, zrhs);
mpz_deinit(&quo); 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; break;
} }
case RT_BINARY_OP_AND: case MP_BINARY_OP_AND:
case RT_BINARY_OP_INPLACE_AND: case MP_BINARY_OP_INPLACE_AND:
mpz_and_inpl(&res->mpz, zlhs, zrhs); mpz_and_inpl(&res->mpz, zlhs, zrhs);
break; break;
case RT_BINARY_OP_OR: case MP_BINARY_OP_OR:
case RT_BINARY_OP_INPLACE_OR: case MP_BINARY_OP_INPLACE_OR:
mpz_or_inpl(&res->mpz, zlhs, zrhs); mpz_or_inpl(&res->mpz, zlhs, zrhs);
break; break;
case RT_BINARY_OP_XOR: case MP_BINARY_OP_XOR:
case RT_BINARY_OP_INPLACE_XOR: case MP_BINARY_OP_INPLACE_XOR:
mpz_xor_inpl(&res->mpz, zlhs, zrhs); mpz_xor_inpl(&res->mpz, zlhs, zrhs);
break; break;
case RT_BINARY_OP_LSHIFT: case MP_BINARY_OP_LSHIFT:
case RT_BINARY_OP_INPLACE_LSHIFT: case MP_BINARY_OP_INPLACE_LSHIFT:
case RT_BINARY_OP_RSHIFT: case MP_BINARY_OP_RSHIFT:
case RT_BINARY_OP_INPLACE_RSHIFT: { case MP_BINARY_OP_INPLACE_RSHIFT: {
// TODO check conversion overflow // TODO check conversion overflow
machine_int_t irhs = mpz_as_int(zrhs); machine_int_t irhs = mpz_as_int(zrhs);
if (irhs < 0) { if (irhs < 0) {
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count")); 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); mpz_shl_inpl(&res->mpz, zlhs, irhs);
} else { } else {
mpz_shr_inpl(&res->mpz, zlhs, irhs); 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; break;
} }
case RT_BINARY_OP_POWER: case MP_BINARY_OP_POWER:
case RT_BINARY_OP_INPLACE_POWER: case MP_BINARY_OP_INPLACE_POWER:
mpz_pow_inpl(&res->mpz, zlhs, zrhs); mpz_pow_inpl(&res->mpz, zlhs, zrhs);
break; break;
@ -171,17 +171,17 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
} else { } else {
int cmp = mpz_cmp(zlhs, zrhs); int cmp = mpz_cmp(zlhs, zrhs);
switch (op) { switch (op) {
case RT_BINARY_OP_LESS: case MP_BINARY_OP_LESS:
return MP_BOOL(cmp < 0); return MP_BOOL(cmp < 0);
case RT_BINARY_OP_MORE: case MP_BINARY_OP_MORE:
return MP_BOOL(cmp > 0); return MP_BOOL(cmp > 0);
case RT_BINARY_OP_LESS_EQUAL: case MP_BINARY_OP_LESS_EQUAL:
return MP_BOOL(cmp <= 0); return MP_BOOL(cmp <= 0);
case RT_BINARY_OP_MORE_EQUAL: case MP_BINARY_OP_MORE_EQUAL:
return MP_BOOL(cmp >= 0); return MP_BOOL(cmp >= 0);
case RT_BINARY_OP_EQUAL: case MP_BINARY_OP_EQUAL:
return MP_BOOL(cmp == 0); return MP_BOOL(cmp == 0);
case RT_BINARY_OP_NOT_EQUAL: case MP_BINARY_OP_NOT_EQUAL:
return MP_BOOL(cmp != 0); return MP_BOOL(cmp != 0);
default: default:

42
py/objlist.c
Wyświetl plik

@ -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: case 1:
{ {
// make list from iterable // 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 list = mp_obj_new_list(0, NULL);
mp_obj_t item; 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); mp_obj_list_append(list, item);
} }
return list; 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; 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) { 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)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_list));
if (!MP_OBJ_IS_TYPE(another_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) { STATIC mp_obj_t list_unary_op(int op, mp_obj_t self_in) {
mp_obj_list_t *self = self_in; mp_obj_list_t *self = self_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(self->len != 0); case MP_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_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
default: return MP_OBJ_NULL; // op not supported for None 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) { STATIC mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_list_t *o = lhs; mp_obj_list_t *o = lhs;
switch (op) { switch (op) {
case RT_BINARY_OP_SUBSCR: case MP_BINARY_OP_SUBSCR:
{ {
#if MICROPY_ENABLE_SLICE #if MICROPY_ENABLE_SLICE
if (MP_OBJ_IS_TYPE(rhs, &mp_type_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); uint index = mp_get_index(o->base.type, o->len, rhs, false);
return o->items[index]; return o->items[index];
} }
case RT_BINARY_OP_ADD: case MP_BINARY_OP_ADD:
{ {
if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) { if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) {
return NULL; 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); m_seq_cat(s->items, o->items, o->len, p->items, p->len, mp_obj_t);
return s; return s;
} }
case RT_BINARY_OP_INPLACE_ADD: case MP_BINARY_OP_INPLACE_ADD:
{ {
if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) { if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) {
return NULL; 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); list_extend(lhs, rhs);
return o; return o;
} }
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
{ {
if (!MP_OBJ_IS_SMALL_INT(rhs)) { if (!MP_OBJ_IS_SMALL_INT(rhs)) {
return NULL; 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); mp_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items);
return s; return s;
} }
case RT_BINARY_OP_EQUAL: case MP_BINARY_OP_EQUAL:
case RT_BINARY_OP_LESS: case MP_BINARY_OP_LESS:
case RT_BINARY_OP_LESS_EQUAL: case MP_BINARY_OP_LESS_EQUAL:
case RT_BINARY_OP_MORE: case MP_BINARY_OP_MORE:
case RT_BINARY_OP_MORE_EQUAL: case MP_BINARY_OP_MORE_EQUAL:
return MP_BOOL(list_cmp_helper(op, lhs, rhs)); return MP_BOOL(list_cmp_helper(op, lhs, rhs));
case RT_BINARY_OP_NOT_EQUAL: case MP_BINARY_OP_NOT_EQUAL:
return MP_BOOL(!list_cmp_helper(RT_BINARY_OP_EQUAL, lhs, rhs)); return MP_BOOL(!list_cmp_helper(MP_BINARY_OP_EQUAL, lhs, rhs));
default: default:
// op not supported // 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 // 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) { 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) { while (head < tail) {
mp_obj_t *h = head - 1; mp_obj_t *h = head - 1;
mp_obj_t *t = tail; 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 (;;) { 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 ++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 && rt_binary_op(op, v, key_fn == NULL ? t[0] : rt_call_function_1(key_fn, t[0])) == 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; if (h >= t) break;
mp_obj_t x = h[0]; mp_obj_t x = h[0];
h[0] = t[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_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, mp_quicksort(self->items, self->items + self->len - 1,
keyfun ? keyfun->value : NULL, 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 return mp_const_none; // return None, as per CPython
} }

6
py/objmap.c
Wyświetl plik

@ -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->n_iters = n_args - 1;
o->fun = args[0]; o->fun = args[0];
for (int i = 0; i < n_args - 1; i++) { 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; 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); mp_obj_t *nextses = m_new(mp_obj_t, self->n_iters);
for (int i = 0; i < self->n_iters; i++) { 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) { if (next == MP_OBJ_NULL) {
m_del(mp_obj_t, nextses, self->n_iters); m_del(mp_obj_t, nextses, self->n_iters);
return MP_OBJ_NULL; return MP_OBJ_NULL;
} }
nextses[i] = next; 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 = { const mp_obj_type_t mp_type_map = {

2
py/objnone.c
Wyświetl plik

@ -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) { STATIC mp_obj_t none_unary_op(int op, mp_obj_t o_in) {
switch (op) { 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 default: return MP_OBJ_NULL; // op not supported for None
} }
} }

54
py/objset.c
Wyświetl plik

@ -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 // 1 argument, an iterable from which we make a new set
mp_obj_t set = mp_obj_new_set(0, NULL); 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; 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); mp_obj_set_store(set, item);
} }
return set; 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) { if (self == other) {
set_clear(self); set_clear(self);
} else { } else {
mp_obj_t iter = rt_getiter(other); mp_obj_t iter = mp_getiter(other);
mp_obj_t next; mp_obj_t next;
while ((next = rt_iternext(iter)) != MP_OBJ_NULL) { while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
set_discard(self, next); 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 *self = self_in;
mp_obj_set_t *out = mp_obj_new_set(0, NULL); 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; 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)) { if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) {
set_add(out, next); 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)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_set));
mp_obj_set_t *self = self_in; 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; 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)) { if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) {
return mp_const_false; 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) { 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)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_set));
mp_obj_set_t *self = self_in; 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; 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); mp_set_lookup(&self->set, next, MP_MAP_LOOKUP_REMOVE_IF_FOUND | MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
} }
return mp_const_none; 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 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) { 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; 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); 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) { STATIC mp_obj_t set_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_t args[] = {lhs, rhs}; mp_obj_t args[] = {lhs, rhs};
switch (op) { switch (op) {
case RT_BINARY_OP_OR: case MP_BINARY_OP_OR:
return set_union(lhs, rhs); return set_union(lhs, rhs);
case RT_BINARY_OP_XOR: case MP_BINARY_OP_XOR:
return set_symmetric_difference(lhs, rhs); return set_symmetric_difference(lhs, rhs);
case RT_BINARY_OP_AND: case MP_BINARY_OP_AND:
return set_intersect(lhs, rhs); return set_intersect(lhs, rhs);
case RT_BINARY_OP_SUBTRACT: case MP_BINARY_OP_SUBTRACT:
return set_diff(2, args); return set_diff(2, args);
case RT_BINARY_OP_INPLACE_OR: case MP_BINARY_OP_INPLACE_OR:
return set_union(lhs, rhs); return set_union(lhs, rhs);
case RT_BINARY_OP_INPLACE_XOR: case MP_BINARY_OP_INPLACE_XOR:
return set_symmetric_difference(lhs, rhs); return set_symmetric_difference(lhs, rhs);
case RT_BINARY_OP_INPLACE_AND: case MP_BINARY_OP_INPLACE_AND:
return set_intersect(lhs, rhs); return set_intersect(lhs, rhs);
case RT_BINARY_OP_INPLACE_SUBTRACT: case MP_BINARY_OP_INPLACE_SUBTRACT:
return set_diff(2, args); return set_diff(2, args);
case RT_BINARY_OP_LESS: case MP_BINARY_OP_LESS:
return set_issubset_proper(lhs, rhs); return set_issubset_proper(lhs, rhs);
case RT_BINARY_OP_MORE: case MP_BINARY_OP_MORE:
return set_issuperset_proper(lhs, rhs); return set_issuperset_proper(lhs, rhs);
case RT_BINARY_OP_EQUAL: case MP_BINARY_OP_EQUAL:
return set_equal(lhs, rhs); return set_equal(lhs, rhs);
case RT_BINARY_OP_LESS_EQUAL: case MP_BINARY_OP_LESS_EQUAL:
return set_issubset(lhs, rhs); return set_issubset(lhs, rhs);
case RT_BINARY_OP_MORE_EQUAL: case MP_BINARY_OP_MORE_EQUAL:
return set_issuperset(lhs, rhs); 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); 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_set_t *o = lhs;
mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP); mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP);

32
py/objstr.c
Wyświetl plik

@ -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); 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; mp_obj_t item;
while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) { while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (len == -1) { if (len == -1) {
vstr_add_char(vstr, MP_OBJ_SMALL_INT_VALUE(item)); vstr_add_char(vstr, MP_OBJ_SMALL_INT_VALUE(item));
} else { } 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) { 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); GET_STR_DATA_LEN(lhs_in, lhs_data, lhs_len);
switch (op) { 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) // TODO: need predicate to check for int-like type (bools are such for example)
// ["no", "yes"][1 == 2] is common idiom // ["no", "yes"][1 == 2] is common idiom
if (MP_OBJ_IS_SMALL_INT(rhs_in)) { 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")); nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "index must be int"));
} }
case RT_BINARY_OP_ADD: case MP_BINARY_OP_ADD:
case RT_BINARY_OP_INPLACE_ADD: case MP_BINARY_OP_INPLACE_ADD:
if (MP_OBJ_IS_STR(rhs_in)) { if (MP_OBJ_IS_STR(rhs_in)) {
// add 2 strings // 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; break;
case RT_BINARY_OP_IN: case MP_BINARY_OP_IN:
/* NOTE `a in b` is `b.__contains__(a)` */ /* NOTE `a in b` is `b.__contains__(a)` */
if (MP_OBJ_IS_STR(rhs_in)) { if (MP_OBJ_IS_STR(rhs_in)) {
GET_STR_DATA_LEN(rhs_in, rhs_data, rhs_len); 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; break;
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
{ {
if (!MP_OBJ_IS_SMALL_INT(rhs_in)) { if (!MP_OBJ_IS_SMALL_INT(rhs_in)) {
return NULL; 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); return mp_obj_str_builder_end(s);
} }
// These 2 are never passed here, dealt with as a special case in rt_binary_op(). // These 2 are never passed here, dealt with as a special case in mp_binary_op().
//case RT_BINARY_OP_EQUAL: //case MP_BINARY_OP_EQUAL:
//case RT_BINARY_OP_NOT_EQUAL: //case MP_BINARY_OP_NOT_EQUAL:
case RT_BINARY_OP_LESS: case MP_BINARY_OP_LESS:
case RT_BINARY_OP_LESS_EQUAL: case MP_BINARY_OP_LESS_EQUAL:
case RT_BINARY_OP_MORE: case MP_BINARY_OP_MORE:
case RT_BINARY_OP_MORE_EQUAL: case MP_BINARY_OP_MORE_EQUAL:
if (MP_OBJ_IS_STR(rhs_in)) { if (MP_OBJ_IS_STR(rhs_in)) {
GET_STR_DATA_LEN(rhs_in, rhs_data, rhs_len); 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)); 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) { while (s < top && splits != 0) {
start = s; start = s;
while (s < top && !is_ws(*s)) 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) { if (s >= top) {
break; break;
} }
@ -384,7 +384,7 @@ STATIC mp_obj_t str_split(uint n_args, const mp_obj_t *args) {
} }
if (s < top) { 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; return res;

33
py/objtuple.c
Wyświetl plik

@ -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 a empty tuple
return mp_const_empty_tuple; return mp_const_empty_tuple;
case 1: case 1: {
{
// 1 argument, an iterable from which we make a new tuple // 1 argument, an iterable from which we make a new tuple
if (MP_OBJ_IS_TYPE(args[0], &mp_type_tuple)) { if (MP_OBJ_IS_TYPE(args[0], &mp_type_tuple)) {
return args[0]; 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; uint len = 0;
mp_obj_t *items = m_new(mp_obj_t, alloc); 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; mp_obj_t item;
while ((item = rt_iternext(iterable)) != MP_OBJ_NULL) { while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
if (len >= alloc) { if (len >= alloc) {
items = m_renew(mp_obj_t, items, alloc, alloc * 2); items = m_renew(mp_obj_t, items, alloc, alloc * 2);
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) { 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)); assert(MP_OBJ_IS_TYPE(self_in, &mp_type_tuple));
if (!MP_OBJ_IS_TYPE(another_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_t tuple_unary_op(int op, mp_obj_t self_in) {
mp_obj_tuple_t *self = self_in; mp_obj_tuple_t *self = self_in;
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: return MP_BOOL(self->len != 0); case MP_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_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
default: return MP_OBJ_NULL; // op not supported for None 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_t tuple_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_tuple_t *o = lhs; mp_obj_tuple_t *o = lhs;
switch (op) { switch (op) {
case RT_BINARY_OP_SUBSCR: case MP_BINARY_OP_SUBSCR:
{ {
#if MICROPY_ENABLE_SLICE #if MICROPY_ENABLE_SLICE
if (MP_OBJ_IS_TYPE(rhs, &mp_type_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); uint index = mp_get_index(o->base.type, o->len, rhs, false);
return o->items[index]; 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)) { if (!mp_obj_is_subclass_fast(mp_obj_get_type(rhs), (mp_obj_t)&mp_type_tuple)) {
return NULL; 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); m_seq_cat(s->items, o->items, o->len, p->items, p->len, mp_obj_t);
return s; return s;
} }
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
{ {
if (!MP_OBJ_IS_SMALL_INT(rhs)) { if (!MP_OBJ_IS_SMALL_INT(rhs)) {
return NULL; 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); mp_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items);
return s; return s;
} }
case RT_BINARY_OP_EQUAL: case MP_BINARY_OP_EQUAL:
case RT_BINARY_OP_LESS: case MP_BINARY_OP_LESS:
case RT_BINARY_OP_LESS_EQUAL: case MP_BINARY_OP_LESS_EQUAL:
case RT_BINARY_OP_MORE: case MP_BINARY_OP_MORE:
case RT_BINARY_OP_MORE_EQUAL: case MP_BINARY_OP_MORE_EQUAL:
return MP_BOOL(tuple_cmp_helper(op, lhs, rhs)); return MP_BOOL(tuple_cmp_helper(op, lhs, rhs));
case RT_BINARY_OP_NOT_EQUAL: case MP_BINARY_OP_NOT_EQUAL:
return MP_BOOL(!tuple_cmp_helper(RT_BINARY_OP_EQUAL, lhs, rhs)); return MP_BOOL(!tuple_cmp_helper(MP_BINARY_OP_EQUAL, lhs, rhs));
default: default:
// op not supported // op not supported

92
py/objtype.c
Wyświetl plik

@ -76,7 +76,7 @@ STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *en
} }
if (member != MP_OBJ_NULL) { 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); mp_obj_print_helper(print, env, r, PRINT_STR);
return; 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 // call __init__ function
mp_obj_t init_ret; mp_obj_t init_ret;
if (n_args == 0 && n_kw == 0) { 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 { } else {
mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw); mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw);
args2[0] = o; args2[0] = o;
memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t)); 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); m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
} }
if (init_ret != mp_const_none) { 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[] = { STATIC const qstr unary_op_method_name[] = {
[RT_UNARY_OP_BOOL] = MP_QSTR___bool__, [MP_UNARY_OP_BOOL] = MP_QSTR___bool__,
[RT_UNARY_OP_LEN] = MP_QSTR___len__, [MP_UNARY_OP_LEN] = MP_QSTR___len__,
//[RT_UNARY_OP_POSITIVE, //[MP_UNARY_OP_POSITIVE,
//[RT_UNARY_OP_NEGATIVE, //[MP_UNARY_OP_NEGATIVE,
//[RT_UNARY_OP_INVERT, //[MP_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_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) { 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); mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name);
if (member != MP_OBJ_NULL) { if (member != MP_OBJ_NULL) {
return rt_call_function_1(member, self_in); return mp_call_function_1(member, self_in);
} else { } else {
return MP_OBJ_NULL; return MP_OBJ_NULL;
} }
} }
STATIC const qstr binary_op_method_name[] = { 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, MP_BINARY_OP_OR,
RT_BINARY_OP_XOR, MP_BINARY_OP_XOR,
RT_BINARY_OP_AND, MP_BINARY_OP_AND,
RT_BINARY_OP_LSHIFT, MP_BINARY_OP_LSHIFT,
RT_BINARY_OP_RSHIFT, MP_BINARY_OP_RSHIFT,
*/ */
[RT_BINARY_OP_ADD] = MP_QSTR___add__, [MP_BINARY_OP_ADD] = MP_QSTR___add__,
[RT_BINARY_OP_SUBTRACT] = MP_QSTR___sub__, [MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
/* /*
RT_BINARY_OP_MULTIPLY, MP_BINARY_OP_MULTIPLY,
RT_BINARY_OP_FLOOR_DIVIDE, MP_BINARY_OP_FLOOR_DIVIDE,
RT_BINARY_OP_TRUE_DIVIDE, MP_BINARY_OP_TRUE_DIVIDE,
RT_BINARY_OP_MODULO, MP_BINARY_OP_MODULO,
RT_BINARY_OP_POWER, MP_BINARY_OP_POWER,
RT_BINARY_OP_INPLACE_OR, MP_BINARY_OP_INPLACE_OR,
RT_BINARY_OP_INPLACE_XOR, MP_BINARY_OP_INPLACE_XOR,
RT_BINARY_OP_INPLACE_AND, MP_BINARY_OP_INPLACE_AND,
RT_BINARY_OP_INPLACE_LSHIFT, MP_BINARY_OP_INPLACE_LSHIFT,
RT_BINARY_OP_INPLACE_RSHIFT, MP_BINARY_OP_INPLACE_RSHIFT,
RT_BINARY_OP_INPLACE_ADD, MP_BINARY_OP_INPLACE_ADD,
RT_BINARY_OP_INPLACE_SUBTRACT, MP_BINARY_OP_INPLACE_SUBTRACT,
RT_BINARY_OP_INPLACE_MULTIPLY, MP_BINARY_OP_INPLACE_MULTIPLY,
RT_BINARY_OP_INPLACE_FLOOR_DIVIDE, MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
RT_BINARY_OP_INPLACE_TRUE_DIVIDE, MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
RT_BINARY_OP_INPLACE_MODULO, MP_BINARY_OP_INPLACE_MODULO,
RT_BINARY_OP_INPLACE_POWER, MP_BINARY_OP_INPLACE_POWER,
RT_BINARY_OP_LESS, MP_BINARY_OP_LESS,
RT_BINARY_OP_MORE, MP_BINARY_OP_MORE,
RT_BINARY_OP_EQUAL, MP_BINARY_OP_EQUAL,
RT_BINARY_OP_LESS_EQUAL, MP_BINARY_OP_LESS_EQUAL,
RT_BINARY_OP_MORE_EQUAL, MP_BINARY_OP_MORE_EQUAL,
RT_BINARY_OP_NOT_EQUAL, MP_BINARY_OP_NOT_EQUAL,
RT_BINARY_OP_IN, MP_BINARY_OP_IN,
RT_BINARY_OP_IS, 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) { 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); mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name);
if (member != MP_OBJ_NULL) { 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 { } else {
return MP_OBJ_NULL; 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__); mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__);
if (member != MP_OBJ_NULL) { if (member != MP_OBJ_NULL) {
mp_obj_t args[3] = {self_in, index, value}; 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; return true;
} else { } else {
return false; return false;

4
py/objzip.c
Wyświetl plik

@ -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->base.type = &mp_type_zip;
o->n_iters = n_args; o->n_iters = n_args;
for (int i = 0; i < n_args; i++) { for (int i = 0; i < n_args; i++) {
o->iters[i] = rt_getiter(args[i]); o->iters[i] = mp_getiter(args[i]);
} }
return o; return o;
} }
@ -40,7 +40,7 @@ STATIC mp_obj_t zip_iternext(mp_obj_t self_in) {
mp_obj_tuple_get(o, NULL, &items); mp_obj_tuple_get(o, NULL, &items);
for (int i = 0; i < self->n_iters; i++) { 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) { if (next == MP_OBJ_NULL) {
mp_obj_tuple_del(o); mp_obj_tuple_del(o);
return MP_OBJ_NULL; return MP_OBJ_NULL;

310
py/runtime.c
Wyświetl plik

@ -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; 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(); mp_emit_glue_init();
// locals = globals for outer module (see Objects/frameobject.c/PyFrame_New()) // locals = globals for outer module (see Objects/frameobject.c/PyFrame_New())
@ -60,86 +60,52 @@ void rt_init(void) {
#endif #endif
// init sys.path // init sys.path
// for efficiency, left to platform-specific startup code // for efficiency, left to platform-specific startup code
//sys_path = mp_obj_new_list(0, NULL); //mp_sys_path = mp_obj_new_list(0, NULL);
//rt_store_attr(m_sys, MP_QSTR_path, sys_path); //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_free(map_globals);
mp_map_deinit(&map_builtins); mp_map_deinit(&map_builtins);
mp_module_deinit(); mp_module_deinit();
mp_emit_glue_deinit(); mp_emit_glue_deinit();
} }
int rt_is_true(mp_obj_t arg) { mp_obj_t mp_list_append(mp_obj_t self_in, 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) {
return mp_obj_list_append(self_in, 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)); DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
uint len; uint len;
const byte* data = qstr_data(qstr, &len); const byte* data = qstr_data(qstr, &len);
return mp_parse_num_decimal((const char*)data, len, true, false); 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)); DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
return MP_OBJ_NEW_QSTR(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)); DEBUG_OP_printf("load b'%s'\n", qstr_str(qstr));
uint len; uint len;
const byte *data = qstr_data(qstr, &len); const byte *data = qstr_data(qstr, &len);
return mp_obj_new_bytes(data, 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 // logic: search locals, globals, builtins
DEBUG_OP_printf("load name %s\n", qstr_str(qstr)); 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); mp_map_elem_t *elem = mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP);
if (elem != NULL) { if (elem != NULL) {
return elem->value; return elem->value;
} else { } 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 // logic: search globals, builtins
DEBUG_OP_printf("load global %s\n", qstr_str(qstr)); 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); 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; 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"); DEBUG_OP_printf("load_build_class\n");
// lookup __build_class__ in dynamic table of builtins first // 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); 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); 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); 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); 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; 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)); 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); 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); 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_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); DEBUG_OP_printf("unary %d %p\n", op, arg);
if (MP_OBJ_IS_SMALL_INT(arg)) { if (MP_OBJ_IS_SMALL_INT(arg)) {
mp_small_int_t val = MP_OBJ_SMALL_INT_VALUE(arg); mp_small_int_t val = MP_OBJ_SMALL_INT_VALUE(arg);
switch (op) { switch (op) {
case RT_UNARY_OP_BOOL: case MP_UNARY_OP_BOOL:
return MP_BOOL(val != 0); return MP_BOOL(val != 0);
case RT_UNARY_OP_POSITIVE: case MP_UNARY_OP_POSITIVE:
return arg; return arg;
case RT_UNARY_OP_NEGATIVE: case MP_UNARY_OP_NEGATIVE:
// check for overflow // check for overflow
if (val == MP_SMALL_INT_MIN) { if (val == MP_SMALL_INT_MIN) {
return mp_obj_new_int(-val); return mp_obj_new_int(-val);
} else { } else {
return MP_OBJ_NEW_SMALL_INT(-val); return MP_OBJ_NEW_SMALL_INT(-val);
} }
case RT_UNARY_OP_INVERT: case MP_UNARY_OP_INVERT:
return MP_OBJ_NEW_SMALL_INT(~val); return MP_OBJ_NEW_SMALL_INT(~val);
default: default:
assert(0); 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); DEBUG_OP_printf("binary %d %p %p\n", op, lhs, rhs);
// TODO correctly distinguish inplace operators for mutable objects // 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 += // note that list does not implement + or +=, so that inplace_concat is reached first for +=
// deal with is // deal with is
if (op == RT_BINARY_OP_IS) { if (op == MP_BINARY_OP_IS) {
return MP_BOOL(lhs == rhs); return MP_BOOL(lhs == rhs);
} }
// deal with == and != for all types // 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 (mp_obj_equal(lhs, rhs)) {
if (op == RT_BINARY_OP_EQUAL) { if (op == MP_BINARY_OP_EQUAL) {
return mp_const_true; return mp_const_true;
} else { } else {
return mp_const_false; return mp_const_false;
} }
} else { } else {
if (op == RT_BINARY_OP_EQUAL) { if (op == MP_BINARY_OP_EQUAL) {
return mp_const_false; return mp_const_false;
} else { } else {
return mp_const_true; 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 // 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) // rhs must be issubclass(rhs, BaseException)
if (mp_obj_is_exception_type(rhs)) { if (mp_obj_is_exception_type(rhs)) {
// if lhs is an instance of an exception, then extract and use its type // 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 // % if lhs=MIN and rhs=-1; result always fits in machine_int_t, then handled by SMALL_INT check
// << checked explicitly // << checked explicitly
switch (op) { switch (op) {
case RT_BINARY_OP_OR: case MP_BINARY_OP_OR:
case RT_BINARY_OP_INPLACE_OR: lhs_val |= rhs_val; break; case MP_BINARY_OP_INPLACE_OR: lhs_val |= rhs_val; break;
case RT_BINARY_OP_XOR: case MP_BINARY_OP_XOR:
case RT_BINARY_OP_INPLACE_XOR: lhs_val ^= rhs_val; break; case MP_BINARY_OP_INPLACE_XOR: lhs_val ^= rhs_val; break;
case RT_BINARY_OP_AND: case MP_BINARY_OP_AND:
case RT_BINARY_OP_INPLACE_AND: lhs_val &= rhs_val; break; case MP_BINARY_OP_INPLACE_AND: lhs_val &= rhs_val; break;
case RT_BINARY_OP_LSHIFT: case MP_BINARY_OP_LSHIFT:
case RT_BINARY_OP_INPLACE_LSHIFT: { case MP_BINARY_OP_INPLACE_LSHIFT: {
if (rhs_val < 0) { if (rhs_val < 0) {
// negative shift not allowed // negative shift not allowed
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count")); 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; break;
} }
case RT_BINARY_OP_RSHIFT: case MP_BINARY_OP_RSHIFT:
case RT_BINARY_OP_INPLACE_RSHIFT: case MP_BINARY_OP_INPLACE_RSHIFT:
if (rhs_val < 0) { if (rhs_val < 0) {
// negative shift not allowed // negative shift not allowed
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count")); 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; lhs_val >>= rhs_val;
} }
break; break;
case RT_BINARY_OP_ADD: case MP_BINARY_OP_ADD:
case RT_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break; case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
case RT_BINARY_OP_SUBTRACT: case MP_BINARY_OP_SUBTRACT:
case RT_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break; case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
case RT_BINARY_OP_MULTIPLY: case MP_BINARY_OP_MULTIPLY:
case RT_BINARY_OP_INPLACE_MULTIPLY: { case MP_BINARY_OP_INPLACE_MULTIPLY: {
// If long long type exists and is larger than machine_int_t, then // If long long type exists and is larger than machine_int_t, then
// we can use the following code to perform overflow-checked multiplication. // 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; break;
} }
case RT_BINARY_OP_FLOOR_DIVIDE: case MP_BINARY_OP_FLOOR_DIVIDE:
case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
{ {
lhs_val = python_floor_divide(lhs_val, rhs_val); lhs_val = python_floor_divide(lhs_val, rhs_val);
break; break;
} }
#if MICROPY_ENABLE_FLOAT #if MICROPY_ENABLE_FLOAT
case RT_BINARY_OP_TRUE_DIVIDE: case MP_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_INPLACE_TRUE_DIVIDE: return mp_obj_new_float((mp_float_t)lhs_val / (mp_float_t)rhs_val);
#endif #endif
case RT_BINARY_OP_MODULO: case MP_BINARY_OP_MODULO:
case RT_BINARY_OP_INPLACE_MODULO: case MP_BINARY_OP_INPLACE_MODULO:
{ {
lhs_val = python_modulo(lhs_val, rhs_val); lhs_val = python_modulo(lhs_val, rhs_val);
break; break;
} }
case RT_BINARY_OP_POWER: case MP_BINARY_OP_POWER:
case RT_BINARY_OP_INPLACE_POWER: case MP_BINARY_OP_INPLACE_POWER:
if (rhs_val < 0) { if (rhs_val < 0) {
#if MICROPY_ENABLE_FLOAT #if MICROPY_ENABLE_FLOAT
lhs = mp_obj_new_float(lhs_val); 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; lhs_val = ans;
} }
break; break;
case RT_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val); break; case MP_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 MP_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 MP_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_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val); break;
default: assert(0); 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 * NOTE `a in b` is `b.__contains__(a)`, hence why the generic dispatch
* needs to go below with swapped arguments * 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); mp_obj_type_t *type = mp_obj_get_type(rhs);
if (type->binary_op != NULL) { if (type->binary_op != NULL) {
mp_obj_t res = type->binary_op(op, rhs, lhs); 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) { if (type->getiter != NULL) {
/* second attempt, walk the iterator */ /* second attempt, walk the iterator */
mp_obj_t next = NULL; mp_obj_t next = NULL;
mp_obj_t iter = rt_getiter(rhs); mp_obj_t iter = mp_getiter(rhs);
while ((next = rt_iternext(iter)) != MP_OBJ_NULL) { while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
if (mp_obj_equal(next, lhs)) { if (mp_obj_equal(next, lhs)) {
return mp_const_true; return mp_const_true;
} }
@ -491,29 +457,29 @@ generic_binary_op:
return mp_const_none; return mp_const_none;
} }
mp_obj_t rt_call_function_0(mp_obj_t fun) { mp_obj_t mp_call_function_0(mp_obj_t fun) {
return rt_call_function_n_kw(fun, 0, 0, NULL); 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) { mp_obj_t mp_call_function_1(mp_obj_t fun, mp_obj_t arg) {
return rt_call_function_n_kw(fun, 1, 0, &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]; mp_obj_t args[2];
args[0] = arg1; args[0] = arg1;
args[1] = arg2; 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 // wrapper that accepts n_args and n_kw in one argument
// native emitter can only pass at most 3 arguments to a function // 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) { 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 rt_call_function_n_kw(fun_in, n_args_kw & 0xff, (n_args_kw >> 8) & 0xff, 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 // 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, // 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 // 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) // 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 // 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); 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; 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); 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); 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); 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); mp_obj_set_store(set, item);
return set; return set;
} }
// unpacked items are stored in reverse order into the array pointed to by items // 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; uint seq_len;
if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(seq_in, &mp_type_list)) { if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(seq_in, &mp_type_list)) {
mp_obj_t *seq_items; 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]; items[i] = seq_items[num - 1 - i];
} }
} else { } 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++) { 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) { if (el == MP_OBJ_NULL) {
goto too_short; goto too_short;
} }
items[num - 1 - seq_len] = el; items[num - 1 - seq_len] = el;
} }
if (rt_iternext(iterable) != MP_OBJ_NULL) { if (mp_iternext(iterable) != MP_OBJ_NULL) {
goto too_long; 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)); 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); 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 // map should always be a dict
return mp_obj_dict_store(map, key, value); 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)); DEBUG_OP_printf("load attr %p.%s\n", base, qstr_str(attr));
// use load_method // use load_method
mp_obj_t dest[2]; mp_obj_t dest[2];
rt_load_method(base, attr, dest); mp_load_method(base, attr, dest);
if (dest[1] == MP_OBJ_NULL) { if (dest[1] == MP_OBJ_NULL) {
// load_method returned just a normal attribute // load_method returned just a normal attribute
return dest[0]; 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 // 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 // normal attribute found, returns: dest[0] == <attribute>, dest[1] == MP_OBJ_NULL
// method attribute found, returns: dest[0] == <method>, dest[1] == <self> // 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 // clear output to indicate no attribute/method found yet
dest[0] = MP_OBJ_NULL; dest[0] = MP_OBJ_NULL;
dest[1] = 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)); 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) { if (dest[0] == MP_OBJ_NULL) {
// no attribute/method called attr // 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); DEBUG_OP_printf("store attr %p.%s <- %p\n", base, qstr_str(attr), value);
mp_obj_type_t *type = mp_obj_get_type(base); mp_obj_type_t *type = mp_obj_get_type(base);
if (type->store_attr != NULL) { 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))); 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); DEBUG_OP_printf("store subscr %p[%p] <- %p\n", base, index, value);
if (MP_OBJ_IS_TYPE(base, &mp_type_list)) { if (MP_OBJ_IS_TYPE(base, &mp_type_list)) {
// list store // 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); mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->getiter != NULL) { if (type->getiter != NULL) {
return type->getiter(o_in); return type->getiter(o_in);
} else { } else {
// check for __iter__ method // check for __iter__ method
mp_obj_t dest[2]; 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) { if (dest[0] != MP_OBJ_NULL) {
// __iter__ exists, call it and return its result // __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 { } 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) { if (dest[0] != MP_OBJ_NULL) {
// __getitem__ exists, create an iterator // __getitem__ exists, create an iterator
return mp_obj_new_getitem_iter(dest); 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 return MP_OBJ_NULL as an optimisation instead of raise StopIteration()
// may also 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); mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->iternext != NULL) { if (type->iternext != NULL) {
return type->iternext(o_in); return type->iternext(o_in);
} else { } else {
// check for __next__ method // check for __next__ method
mp_obj_t dest[2]; 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) { if (dest[0] != MP_OBJ_NULL) {
// __next__ exists, call it and return its result // __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 { } 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))); 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) // will always return MP_OBJ_NULL instead of raising StopIteration() (or any subclass thereof)
// may raise other exceptions // 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); mp_obj_type_t *type = mp_obj_get_type(o_in);
if (type->iternext != NULL) { if (type->iternext != NULL) {
return type->iternext(o_in); return type->iternext(o_in);
} else { } else {
// check for __next__ method // check for __next__ method
mp_obj_t dest[2]; 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) { if (dest[0] != MP_OBJ_NULL) {
// __next__ exists, call it and return its result // __next__ exists, call it and return its result
nlr_buf_t nlr; nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) { 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(); nlr_pop();
return ret; return ret;
} else { } 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); DEBUG_printf("raise %p\n", o);
if (mp_obj_is_exception_type(o)) { if (mp_obj_is_exception_type(o)) {
// o is an exception type (it is derived from BaseException (or is BaseException)) // o is an exception type (it is derived from BaseException (or is BaseException))
// create and return a new exception instance by calling o // create and return a new exception instance by calling o
// TODO could have an option to disable traceback, then builtin exceptions (eg TypeError) // TODO could have an option to disable traceback, then builtin exceptions (eg TypeError)
// could have const instances in ROM which we return here instead // 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)) { } else if (mp_obj_is_exception_instance(o)) {
// o is an instance of an exception, so use it as the exception // o is an instance of an exception, so use it as the exception
return o; 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)); DEBUG_printf("import name %s\n", qstr_str(name));
// build args array // 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); 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)); 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 /* TODO convert AttributeError to ImportError
if (fail) { if (fail) {
(ImportError, "cannot import name %s", qstr_str(name), NULL) (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; 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); DEBUG_printf("import all %p\n", module);
mp_map_t *map = mp_obj_module_get_globals(module); mp_map_t *map = mp_obj_module_get_globals(module);
for (uint i = 0; i < map->alloc; i++) { for (uint i = 0; i < map->alloc; i++) {
if (map->table[i].key != MP_OBJ_NULL) { 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; return map_locals;
} }
void rt_locals_set(mp_map_t *m) { void mp_locals_set(mp_map_t *m) {
DEBUG_OP_printf("rt_locals_set(%p)\n", m); DEBUG_OP_printf("mp_locals_set(%p)\n", m);
map_locals = m; map_locals = m;
} }
mp_map_t *rt_globals_get(void) { mp_map_t *mp_globals_get(void) {
return map_globals; return map_globals;
} }
void rt_globals_set(mp_map_t *m) { void mp_globals_set(mp_map_t *m) {
DEBUG_OP_printf("rt_globals_set(%p)\n", m); DEBUG_OP_printf("mp_globals_set(%p)\n", m);
map_globals = m; map_globals = m;
} }
// these must correspond to the respective enum // these must correspond to the respective enum
void *const rt_fun_table[RT_F_NUMBER_OF] = { void *const mp_fun_table[MP_F_NUMBER_OF] = {
rt_load_const_dec, mp_load_const_dec,
rt_load_const_str, mp_load_const_str,
rt_load_name, mp_load_name,
rt_load_global, mp_load_global,
rt_load_build_class, mp_load_build_class,
rt_load_attr, mp_load_attr,
rt_load_method, mp_load_method,
rt_store_name, mp_store_name,
rt_store_attr, mp_store_attr,
rt_store_subscr, mp_store_subscr,
rt_is_true, mp_obj_is_true,
rt_unary_op, mp_unary_op,
rt_binary_op, mp_binary_op,
rt_build_tuple, mp_build_tuple,
rt_build_list, mp_build_list,
rt_list_append, mp_list_append,
rt_build_map, mp_build_map,
rt_store_map, mp_store_map,
rt_build_set, mp_build_set,
rt_store_set, mp_store_set,
rt_make_function_from_id, mp_make_function_from_id,
rt_call_function_n_kw_for_native, mp_call_function_n_kw_for_native,
rt_call_method_n_kw, mp_call_method_n_kw,
rt_getiter, mp_getiter,
rt_iternext, mp_iternext,
}; };
/* /*
void rt_f_vector(rt_fun_kind_t fun_kind) { void mp_f_vector(mp_fun_kind_t fun_kind) {
(rt_f_table[fun_kind])(); (mp_f_table[fun_kind])();
} }
*/ */

114
py/runtime.h
Wyświetl plik

@ -1,58 +1,64 @@
void rt_init(void); void mp_init(void);
void rt_deinit(void); void mp_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); 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);
int rt_is_true(mp_obj_t arg); 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 rt_load_const_dec(qstr qstr); mp_obj_t mp_load_name(qstr qstr);
mp_obj_t rt_load_const_str(qstr qstr); mp_obj_t mp_load_global(qstr qstr);
mp_obj_t rt_load_const_bytes(qstr qstr); mp_obj_t mp_load_build_class(void);
mp_obj_t rt_load_name(qstr qstr); void mp_store_name(qstr qstr, mp_obj_t obj);
mp_obj_t rt_load_global(qstr qstr); void mp_store_global(qstr qstr, mp_obj_t obj);
mp_obj_t rt_load_build_class(void); void mp_delete_name(qstr qstr);
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; mp_obj_t mp_unary_op(int op, mp_obj_t arg);
struct _mp_map_t *rt_locals_get(void); mp_obj_t mp_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs);
void rt_locals_set(struct _mp_map_t *m);
struct _mp_map_t *rt_globals_get(void); mp_obj_t mp_load_const_dec(qstr qstr);
void rt_globals_set(struct _mp_map_t *m); mp_obj_t mp_load_const_str(qstr qstr);
struct _mp_map_t *rt_loaded_modules_get(void); mp_obj_t mp_load_const_bytes(qstr qstr);
extern mp_obj_t sys_path;
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);

144
py/runtime0.h
Wyświetl plik

@ -13,83 +13,83 @@
#define MP_SCOPE_FLAG_NOFREE 0x40 #define MP_SCOPE_FLAG_NOFREE 0x40
typedef enum { typedef enum {
RT_UNARY_OP_BOOL, // __bool__ MP_UNARY_OP_BOOL, // __bool__
RT_UNARY_OP_LEN, // __len__ MP_UNARY_OP_LEN, // __len__
RT_UNARY_OP_POSITIVE, MP_UNARY_OP_POSITIVE,
RT_UNARY_OP_NEGATIVE, MP_UNARY_OP_NEGATIVE,
RT_UNARY_OP_INVERT, MP_UNARY_OP_INVERT,
// these are not supported by the runtime and must be synthesised by the emitter // these are not supported by the runtime and must be synthesised by the emitter
RT_UNARY_OP_NOT, MP_UNARY_OP_NOT,
} rt_unary_op_t; } mp_unary_op_t;
typedef enum { typedef enum {
RT_BINARY_OP_SUBSCR, MP_BINARY_OP_SUBSCR,
RT_BINARY_OP_OR, MP_BINARY_OP_OR,
RT_BINARY_OP_XOR, MP_BINARY_OP_XOR,
RT_BINARY_OP_AND, MP_BINARY_OP_AND,
RT_BINARY_OP_LSHIFT, MP_BINARY_OP_LSHIFT,
RT_BINARY_OP_RSHIFT, MP_BINARY_OP_RSHIFT,
RT_BINARY_OP_ADD, MP_BINARY_OP_ADD,
RT_BINARY_OP_SUBTRACT, MP_BINARY_OP_SUBTRACT,
RT_BINARY_OP_MULTIPLY, MP_BINARY_OP_MULTIPLY,
RT_BINARY_OP_FLOOR_DIVIDE, MP_BINARY_OP_FLOOR_DIVIDE,
RT_BINARY_OP_TRUE_DIVIDE, MP_BINARY_OP_TRUE_DIVIDE,
RT_BINARY_OP_MODULO, MP_BINARY_OP_MODULO,
RT_BINARY_OP_POWER, MP_BINARY_OP_POWER,
RT_BINARY_OP_INPLACE_OR, MP_BINARY_OP_INPLACE_OR,
RT_BINARY_OP_INPLACE_XOR, MP_BINARY_OP_INPLACE_XOR,
RT_BINARY_OP_INPLACE_AND, MP_BINARY_OP_INPLACE_AND,
RT_BINARY_OP_INPLACE_LSHIFT, MP_BINARY_OP_INPLACE_LSHIFT,
RT_BINARY_OP_INPLACE_RSHIFT, MP_BINARY_OP_INPLACE_RSHIFT,
RT_BINARY_OP_INPLACE_ADD, MP_BINARY_OP_INPLACE_ADD,
RT_BINARY_OP_INPLACE_SUBTRACT, MP_BINARY_OP_INPLACE_SUBTRACT,
RT_BINARY_OP_INPLACE_MULTIPLY, MP_BINARY_OP_INPLACE_MULTIPLY,
RT_BINARY_OP_INPLACE_FLOOR_DIVIDE, MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
RT_BINARY_OP_INPLACE_TRUE_DIVIDE, MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
RT_BINARY_OP_INPLACE_MODULO, MP_BINARY_OP_INPLACE_MODULO,
RT_BINARY_OP_INPLACE_POWER, MP_BINARY_OP_INPLACE_POWER,
// these should return a bool // these should return a bool
RT_BINARY_OP_LESS, MP_BINARY_OP_LESS,
RT_BINARY_OP_MORE, MP_BINARY_OP_MORE,
RT_BINARY_OP_EQUAL, MP_BINARY_OP_EQUAL,
RT_BINARY_OP_LESS_EQUAL, MP_BINARY_OP_LESS_EQUAL,
RT_BINARY_OP_MORE_EQUAL, MP_BINARY_OP_MORE_EQUAL,
RT_BINARY_OP_NOT_EQUAL, MP_BINARY_OP_NOT_EQUAL,
RT_BINARY_OP_IN, MP_BINARY_OP_IN,
RT_BINARY_OP_IS, MP_BINARY_OP_IS,
RT_BINARY_OP_EXCEPTION_MATCH, MP_BINARY_OP_EXCEPTION_MATCH,
// these are not supported by the runtime and must be synthesised by the emitter // these are not supported by the runtime and must be synthesised by the emitter
RT_BINARY_OP_NOT_IN, MP_BINARY_OP_NOT_IN,
RT_BINARY_OP_IS_NOT, MP_BINARY_OP_IS_NOT,
} rt_binary_op_t; } mp_binary_op_t;
typedef enum { typedef enum {
RT_F_LOAD_CONST_DEC = 0, MP_F_LOAD_CONST_DEC = 0,
RT_F_LOAD_CONST_STR, MP_F_LOAD_CONST_STR,
RT_F_LOAD_NAME, MP_F_LOAD_NAME,
RT_F_LOAD_GLOBAL, MP_F_LOAD_GLOBAL,
RT_F_LOAD_BUILD_CLASS, MP_F_LOAD_BUILD_CLASS,
RT_F_LOAD_ATTR, MP_F_LOAD_ATTR,
RT_F_LOAD_METHOD, MP_F_LOAD_METHOD,
RT_F_STORE_NAME, MP_F_STORE_NAME,
RT_F_STORE_ATTR, MP_F_STORE_ATTR,
RT_F_STORE_SUBSCR, MP_F_STORE_SUBSCR,
RT_F_IS_TRUE, MP_F_OBJ_IS_TRUE,
RT_F_UNARY_OP, MP_F_UNARY_OP,
RT_F_BINARY_OP, MP_F_BINARY_OP,
RT_F_BUILD_TUPLE, MP_F_BUILD_TUPLE,
RT_F_BUILD_LIST, MP_F_BUILD_LIST,
RT_F_LIST_APPEND, MP_F_LIST_APPEND,
RT_F_BUILD_MAP, MP_F_BUILD_MAP,
RT_F_STORE_MAP, MP_F_STORE_MAP,
RT_F_BUILD_SET, MP_F_BUILD_SET,
RT_F_STORE_SET, MP_F_STORE_SET,
RT_F_MAKE_FUNCTION_FROM_ID, MP_F_MAKE_FUNCTION_FROM_ID,
RT_F_CALL_FUNCTION_N_KW_FOR_NATIVE, MP_F_CALL_FUNCTION_N_KW_FOR_NATIVE,
RT_F_CALL_METHOD_N_KW, MP_F_CALL_METHOD_N_KW,
RT_F_GETITER, MP_F_GETITER,
RT_F_ITERNEXT, MP_F_ITERNEXT,
RT_F_NUMBER_OF, MP_F_NUMBER_OF,
} rt_fun_kind_t; } mp_fun_kind_t;
extern void *const rt_fun_table[RT_F_NUMBER_OF]; extern void *const mp_fun_table[MP_F_NUMBER_OF];

30
py/sequence.c
Wyświetl plik

@ -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 // 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) { bool mp_seq_cmp_bytes(int op, const byte *data1, uint len1, const byte *data2, uint len2) {
// Let's deal only with > & >= // 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(const byte*, data1, data2);
SWAP(uint, len1, len2); SWAP(uint, len1, len2);
if (op == RT_BINARY_OP_LESS) { if (op == MP_BINARY_OP_LESS) {
op = RT_BINARY_OP_MORE; op = MP_BINARY_OP_MORE;
} else { } else {
op = RT_BINARY_OP_MORE_EQUAL; op = MP_BINARY_OP_MORE_EQUAL;
} }
} }
uint min_len = len1 < len2 ? len1 : len2; 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 >) // ... then longer list length wins (we deal only with >)
return false; 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 // Otherwise, if we have strict relation, equality means failure
return false; 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 // 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) { 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; return false;
} }
// Let's deal only with > & >= // 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(const mp_obj_t *, items1, items2);
SWAP(uint, len1, len2); SWAP(uint, len1, len2);
if (op == RT_BINARY_OP_LESS) { if (op == MP_BINARY_OP_LESS) {
op = RT_BINARY_OP_MORE; op = MP_BINARY_OP_MORE;
} else { } 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; bool rel_status;
for (int i = 0; i < len; i++) { for (int i = 0; i < len; i++) {
eq_status = mp_obj_equal(items1[i], items2[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; 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) { if (!eq_status && !rel_status) {
return false; 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 >) // ... then longer list length wins (we deal only with >)
return false; 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 // Otherwise, if we have strict relation, equality means failure
return false; return false;
} }

104
py/vm.c
Wyświetl plik

@ -157,7 +157,7 @@ outer_dispatch_loop:
if (inject_exc != MP_OBJ_NULL && *ip != MP_BC_YIELD_FROM) { if (inject_exc != MP_OBJ_NULL && *ip != MP_BC_YIELD_FROM) {
mp_obj_t t = inject_exc; mp_obj_t t = inject_exc;
inject_exc = MP_OBJ_NULL; inject_exc = MP_OBJ_NULL;
nlr_jump(rt_make_raise_obj(t)); nlr_jump(mp_make_raise_obj(t));
} }
// loop to execute byte code // loop to execute byte code
for (;;) { for (;;) {
@ -201,22 +201,22 @@ dispatch_loop:
case MP_BC_LOAD_CONST_DEC: case MP_BC_LOAD_CONST_DEC:
DECODE_QSTR; DECODE_QSTR;
PUSH(rt_load_const_dec(qst)); PUSH(mp_load_const_dec(qst));
break; break;
case MP_BC_LOAD_CONST_ID: case MP_BC_LOAD_CONST_ID:
DECODE_QSTR; DECODE_QSTR;
PUSH(rt_load_const_str(qst)); // TODO PUSH(mp_load_const_str(qst)); // TODO
break; break;
case MP_BC_LOAD_CONST_BYTES: case MP_BC_LOAD_CONST_BYTES:
DECODE_QSTR; DECODE_QSTR;
PUSH(rt_load_const_bytes(qst)); PUSH(mp_load_const_bytes(qst));
break; break;
case MP_BC_LOAD_CONST_STRING: case MP_BC_LOAD_CONST_STRING:
DECODE_QSTR; DECODE_QSTR;
PUSH(rt_load_const_str(qst)); PUSH(mp_load_const_str(qst));
break; break;
case MP_BC_LOAD_FAST_0: case MP_BC_LOAD_FAST_0:
@ -238,32 +238,32 @@ dispatch_loop:
case MP_BC_LOAD_DEREF: case MP_BC_LOAD_DEREF:
DECODE_UINT; DECODE_UINT;
PUSH(rt_get_cell(fastn[-unum])); PUSH(mp_get_cell(fastn[-unum]));
break; break;
case MP_BC_LOAD_NAME: case MP_BC_LOAD_NAME:
DECODE_QSTR; DECODE_QSTR;
PUSH(rt_load_name(qst)); PUSH(mp_load_name(qst));
break; break;
case MP_BC_LOAD_GLOBAL: case MP_BC_LOAD_GLOBAL:
DECODE_QSTR; DECODE_QSTR;
PUSH(rt_load_global(qst)); PUSH(mp_load_global(qst));
break; break;
case MP_BC_LOAD_ATTR: case MP_BC_LOAD_ATTR:
DECODE_QSTR; DECODE_QSTR;
SET_TOP(rt_load_attr(TOP(), qst)); SET_TOP(mp_load_attr(TOP(), qst));
break; break;
case MP_BC_LOAD_METHOD: case MP_BC_LOAD_METHOD:
DECODE_QSTR; DECODE_QSTR;
rt_load_method(*sp, qst, sp); mp_load_method(*sp, qst, sp);
sp += 1; sp += 1;
break; break;
case MP_BC_LOAD_BUILD_CLASS: case MP_BC_LOAD_BUILD_CLASS:
PUSH(rt_load_build_class()); PUSH(mp_load_build_class());
break; break;
case MP_BC_STORE_FAST_0: case MP_BC_STORE_FAST_0:
@ -285,33 +285,33 @@ dispatch_loop:
case MP_BC_STORE_DEREF: case MP_BC_STORE_DEREF:
DECODE_UINT; DECODE_UINT;
rt_set_cell(fastn[-unum], POP()); mp_set_cell(fastn[-unum], POP());
break; break;
case MP_BC_STORE_NAME: case MP_BC_STORE_NAME:
DECODE_QSTR; DECODE_QSTR;
rt_store_name(qst, POP()); mp_store_name(qst, POP());
break; break;
case MP_BC_STORE_GLOBAL: case MP_BC_STORE_GLOBAL:
DECODE_QSTR; DECODE_QSTR;
rt_store_global(qst, POP()); mp_store_global(qst, POP());
break; break;
case MP_BC_STORE_ATTR: case MP_BC_STORE_ATTR:
DECODE_QSTR; DECODE_QSTR;
rt_store_attr(sp[0], qst, sp[-1]); mp_store_attr(sp[0], qst, sp[-1]);
sp -= 2; sp -= 2;
break; break;
case MP_BC_STORE_SUBSCR: 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; sp -= 3;
break; break;
case MP_BC_DELETE_NAME: case MP_BC_DELETE_NAME:
DECODE_QSTR; DECODE_QSTR;
rt_delete_name(qst); mp_delete_name(qst);
break; break;
case MP_BC_DUP_TOP: case MP_BC_DUP_TOP:
@ -349,21 +349,21 @@ dispatch_loop:
case MP_BC_POP_JUMP_IF_TRUE: case MP_BC_POP_JUMP_IF_TRUE:
DECODE_SLABEL; DECODE_SLABEL;
if (rt_is_true(POP())) { if (mp_obj_is_true(POP())) {
ip += unum; ip += unum;
} }
break; break;
case MP_BC_POP_JUMP_IF_FALSE: case MP_BC_POP_JUMP_IF_FALSE:
DECODE_SLABEL; DECODE_SLABEL;
if (!rt_is_true(POP())) { if (!mp_obj_is_true(POP())) {
ip += unum; ip += unum;
} }
break; break;
case MP_BC_JUMP_IF_TRUE_OR_POP: case MP_BC_JUMP_IF_TRUE_OR_POP:
DECODE_SLABEL; DECODE_SLABEL;
if (rt_is_true(TOP())) { if (mp_obj_is_true(TOP())) {
ip += unum; ip += unum;
} else { } else {
sp--; sp--;
@ -372,7 +372,7 @@ dispatch_loop:
case MP_BC_JUMP_IF_FALSE_OR_POP: case MP_BC_JUMP_IF_FALSE_OR_POP:
DECODE_SLABEL; DECODE_SLABEL;
if (rt_is_true(TOP())) { if (mp_obj_is_true(TOP())) {
sp--; sp--;
} else { } else {
ip += unum; ip += unum;
@ -388,9 +388,9 @@ dispatch_loop:
case MP_BC_SETUP_WITH: case MP_BC_SETUP_WITH:
obj1 = TOP(); obj1 = TOP();
SET_TOP(rt_load_attr(obj1, MP_QSTR___exit__)); SET_TOP(mp_load_attr(obj1, MP_QSTR___exit__));
rt_load_method(obj1, MP_QSTR___enter__, sp + 1); mp_load_method(obj1, MP_QSTR___enter__, sp + 1);
obj2 = rt_call_method_n_kw(0, 0, sp + 1); obj2 = mp_call_method_n_kw(0, 0, sp + 1);
PUSH_EXC_BLOCK(); PUSH_EXC_BLOCK();
PUSH(obj2); PUSH(obj2);
break; break;
@ -405,19 +405,19 @@ dispatch_loop:
sp--; sp--;
obj1 = TOP(); obj1 = TOP();
SET_TOP(mp_const_none); 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())) { } else if (MP_OBJ_IS_SMALL_INT(TOP())) {
mp_obj_t cause = POP(); mp_obj_t cause = POP();
switch (MP_OBJ_SMALL_INT_VALUE(cause)) { switch (MP_OBJ_SMALL_INT_VALUE(cause)) {
case UNWIND_RETURN: { case UNWIND_RETURN: {
mp_obj_t retval = POP(); 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); SET_TOP(retval);
PUSH(cause); PUSH(cause);
break; break;
} }
case UNWIND_JUMP: { 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] // Pop __exit__ boundmethod at sp[-2]
sp[-2] = sp[-1]; sp[-2] = sp[-1];
sp[-1] = sp[0]; sp[-1] = sp[0];
@ -429,14 +429,14 @@ dispatch_loop:
} }
} else if (mp_obj_is_exception_type(TOP())) { } else if (mp_obj_is_exception_type(TOP())) {
mp_obj_t args[3] = {sp[0], sp[-1], sp[-2]}; 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] // Pop __exit__ boundmethod at sp[-3]
// TODO: Once semantics is proven, optimize for case when obj2 == True // TODO: Once semantics is proven, optimize for case when obj2 == True
sp[-3] = sp[-2]; sp[-3] = sp[-2];
sp[-2] = sp[-1]; sp[-2] = sp[-1];
sp[-1] = sp[0]; sp[-1] = sp[0];
sp--; sp--;
if (rt_is_true(obj2)) { if (mp_obj_is_true(obj2)) {
// This is what CPython does // This is what CPython does
//PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_SILENCED)); //PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_SILENCED));
// But what we need to do is - pop exception from value stack... // But what we need to do is - pop exception from value stack...
@ -514,12 +514,12 @@ unwind_jump:
break; break;
case MP_BC_GET_ITER: case MP_BC_GET_ITER:
SET_TOP(rt_getiter(TOP())); SET_TOP(mp_getiter(TOP()));
break; break;
case MP_BC_FOR_ITER: case MP_BC_FOR_ITER:
DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward 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) { if (obj1 == MP_OBJ_NULL) {
--sp; // pop the exhausted iterator --sp; // pop the exhausted iterator
ip += unum; // jump to after for-block ip += unum; // jump to after for-block
@ -557,62 +557,62 @@ unwind_jump:
case MP_BC_UNARY_OP: case MP_BC_UNARY_OP:
unum = *ip++; unum = *ip++;
SET_TOP(rt_unary_op(unum, TOP())); SET_TOP(mp_unary_op(unum, TOP()));
break; break;
case MP_BC_BINARY_OP: case MP_BC_BINARY_OP:
unum = *ip++; unum = *ip++;
obj2 = POP(); obj2 = POP();
obj1 = TOP(); obj1 = TOP();
SET_TOP(rt_binary_op(unum, obj1, obj2)); SET_TOP(mp_binary_op(unum, obj1, obj2));
break; break;
case MP_BC_BUILD_TUPLE: case MP_BC_BUILD_TUPLE:
DECODE_UINT; DECODE_UINT;
sp -= unum - 1; sp -= unum - 1;
SET_TOP(rt_build_tuple(unum, sp)); SET_TOP(mp_build_tuple(unum, sp));
break; break;
case MP_BC_BUILD_LIST: case MP_BC_BUILD_LIST:
DECODE_UINT; DECODE_UINT;
sp -= unum - 1; sp -= unum - 1;
SET_TOP(rt_build_list(unum, sp)); SET_TOP(mp_build_list(unum, sp));
break; break;
case MP_BC_LIST_APPEND: case MP_BC_LIST_APPEND:
DECODE_UINT; DECODE_UINT;
// I think it's guaranteed by the compiler that sp[unum] is a list // 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--; sp--;
break; break;
case MP_BC_BUILD_MAP: case MP_BC_BUILD_MAP:
DECODE_UINT; DECODE_UINT;
PUSH(rt_build_map(unum)); PUSH(mp_build_map(unum));
break; break;
case MP_BC_STORE_MAP: case MP_BC_STORE_MAP:
sp -= 2; sp -= 2;
rt_store_map(sp[0], sp[2], sp[1]); mp_store_map(sp[0], sp[2], sp[1]);
break; break;
case MP_BC_MAP_ADD: case MP_BC_MAP_ADD:
DECODE_UINT; DECODE_UINT;
// I think it's guaranteed by the compiler that sp[-unum - 1] is a map // 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; sp -= 2;
break; break;
case MP_BC_BUILD_SET: case MP_BC_BUILD_SET:
DECODE_UINT; DECODE_UINT;
sp -= unum - 1; sp -= unum - 1;
SET_TOP(rt_build_set(unum, sp)); SET_TOP(mp_build_set(unum, sp));
break; break;
case MP_BC_SET_ADD: case MP_BC_SET_ADD:
DECODE_UINT; DECODE_UINT;
// I think it's guaranteed by the compiler that sp[-unum] is a set // 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--; sp--;
break; break;
@ -632,29 +632,29 @@ unwind_jump:
case MP_BC_UNPACK_SEQUENCE: case MP_BC_UNPACK_SEQUENCE:
DECODE_UINT; DECODE_UINT;
rt_unpack_sequence(sp[0], unum, sp); mp_unpack_sequence(sp[0], unum, sp);
sp += unum - 1; sp += unum - 1;
break; break;
case MP_BC_MAKE_FUNCTION: case MP_BC_MAKE_FUNCTION:
DECODE_UINT; 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; break;
case MP_BC_MAKE_FUNCTION_DEFARGS: case MP_BC_MAKE_FUNCTION_DEFARGS:
DECODE_UINT; DECODE_UINT;
SET_TOP(rt_make_function_from_id(unum, false, TOP())); SET_TOP(mp_make_function_from_id(unum, false, TOP()));
break; break;
case MP_BC_MAKE_CLOSURE: case MP_BC_MAKE_CLOSURE:
DECODE_UINT; 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; break;
case MP_BC_MAKE_CLOSURE_DEFARGS: case MP_BC_MAKE_CLOSURE_DEFARGS:
DECODE_UINT; DECODE_UINT;
obj1 = POP(); obj1 = POP();
SET_TOP(rt_make_closure_from_id(unum, obj1, TOP())); SET_TOP(mp_make_closure_from_id(unum, obj1, TOP()));
break; break;
case MP_BC_CALL_FUNCTION: case MP_BC_CALL_FUNCTION:
@ -662,7 +662,7 @@ unwind_jump:
// unum & 0xff == n_positional // unum & 0xff == n_positional
// (unum >> 8) & 0xff == n_keyword // (unum >> 8) & 0xff == n_keyword
sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe); 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; break;
case MP_BC_CALL_METHOD: case MP_BC_CALL_METHOD:
@ -670,7 +670,7 @@ unwind_jump:
// unum & 0xff == n_positional // unum & 0xff == n_positional
// (unum >> 8) & 0xff == n_keyword // (unum >> 8) & 0xff == n_keyword
sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1; 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; break;
case MP_BC_RETURN_VALUE: case MP_BC_RETURN_VALUE:
@ -714,7 +714,7 @@ unwind_return:
} else { } else {
obj1 = POP(); obj1 = POP();
} }
nlr_jump(rt_make_raise_obj(obj1)); nlr_jump(mp_make_raise_obj(obj1));
case MP_BC_YIELD_VALUE: case MP_BC_YIELD_VALUE:
yield: yield:
@ -778,17 +778,17 @@ yield:
case MP_BC_IMPORT_NAME: case MP_BC_IMPORT_NAME:
DECODE_QSTR; DECODE_QSTR;
obj1 = POP(); obj1 = POP();
SET_TOP(rt_import_name(qst, obj1, TOP())); SET_TOP(mp_import_name(qst, obj1, TOP()));
break; break;
case MP_BC_IMPORT_FROM: case MP_BC_IMPORT_FROM:
DECODE_QSTR; DECODE_QSTR;
obj1 = rt_import_from(TOP(), qst); obj1 = mp_import_from(TOP(), qst);
PUSH(obj1); PUSH(obj1);
break; break;
case MP_BC_IMPORT_STAR: case MP_BC_IMPORT_STAR:
rt_import_all(POP()); mp_import_all(POP());
break; break;
default: default:

4
stm/accel.c
Wyświetl plik

@ -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[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); 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); 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()); 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); MP_DEFINE_CONST_FUN_OBJ_0(pyb_accel_read_all_obj, pyb_accel_read_all);

4
stm/exti.c
Wyświetl plik

@ -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) { 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 // 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); exti_obj_t *self = m_new_obj(exti_obj_t);
self->base.type = type_in; self->base.type = type_in;
@ -336,7 +336,7 @@ static void Handle_EXTI_Irq(uint32_t line) {
if (line < EXTI_NUM_VECTORS) { if (line < EXTI_NUM_VECTORS) {
exti_vector_t *v = &exti_vector[line]; exti_vector_t *v = &exti_vector[line];
if (v->callback_obj != mp_const_none) { 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));
} }
} }
} }

2
stm/gpio.c
Wyświetl plik

@ -46,7 +46,7 @@ mp_obj_t pyb_gpio(uint n_args, mp_obj_t *args) {
} }
} else { } else {
// set pin // set pin
if (rt_is_true(args[1])) { if (mp_obj_is_true(args[1])) {
// set pin high // set pin high
port->BSRRL = pin_mask; port->BSRRL = pin_mask;
} else { } else {

20
stm/lcd.c
Wyświetl plik

@ -209,7 +209,7 @@ mp_obj_t lcd_print(mp_obj_t text) {
mp_obj_t lcd_light(mp_obj_t value) { mp_obj_t lcd_light(mp_obj_t value) {
#if defined(PYB_LCD_BL_PORT) #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 PYB_LCD_BL_PORT->BSRRL = PYB_LCD_BL_PIN; // set pin high to turn backlight on
} else { } else {
PYB_LCD_BL_PORT->BSRRH = PYB_LCD_BL_PIN; // set pin low to turn backlight off 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 // Micro Python interface
mp_obj_t o = mp_obj_new_type(MP_QSTR_LCD, mp_const_empty_tuple, mp_obj_new_dict(0)); 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)); mp_store_attr(o, qstr_from_str("lcd8"), mp_make_function_n(2, lcd_draw_pixel_8));
rt_store_attr(o, qstr_from_str("clear"), rt_make_function_n(0, lcd_pix_clear)); mp_store_attr(o, qstr_from_str("clear"), mp_make_function_n(0, lcd_pix_clear));
rt_store_attr(o, qstr_from_str("get"), rt_make_function_n(2, lcd_pix_get)); mp_store_attr(o, qstr_from_str("get"), mp_make_function_n(2, lcd_pix_get));
rt_store_attr(o, qstr_from_str("set"), rt_make_function_n(2, lcd_pix_set)); mp_store_attr(o, qstr_from_str("set"), mp_make_function_n(2, lcd_pix_set));
rt_store_attr(o, qstr_from_str("reset"), rt_make_function_n(2, lcd_pix_reset)); mp_store_attr(o, qstr_from_str("reset"), mp_make_function_n(2, lcd_pix_reset));
rt_store_attr(o, qstr_from_str("show"), rt_make_function_n(0, lcd_pix_show)); mp_store_attr(o, qstr_from_str("show"), mp_make_function_n(0, lcd_pix_show));
rt_store_attr(o, qstr_from_str("text"), rt_make_function_n(1, lcd_print)); mp_store_attr(o, qstr_from_str("text"), mp_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("light"), mp_make_function_n(1, lcd_light));
mp_lcd = o; mp_lcd = o;
return 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) { void lcd_init(void) {
mp_lcd = MP_OBJ_NULL; 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) { void lcd_print_str(const char *str) {

8
stm/main.c
Wyświetl plik

@ -233,12 +233,12 @@ soft_reset:
// Micro Python init // Micro Python init
qstr_init(); qstr_init();
rt_init(); mp_init();
mp_obj_t def_path[3]; mp_obj_t def_path[3];
def_path[0] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_); 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[1] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_src);
def_path[2] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_lib); 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(); exti_init();
@ -270,8 +270,8 @@ soft_reset:
pin_map_init(); pin_map_init();
// add some functions to the builtin Python namespace // add some functions to the builtin 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));
rt_store_name(MP_QSTR_open, rt_make_function_n(2, pyb_io_open)); mp_store_name(MP_QSTR_open, mp_make_function_n(2, pyb_io_open));
// load the pyb module // load the pyb module
mp_module_register(MP_QSTR_pyb, (mp_obj_t)&pyb_module); mp_module_register(MP_QSTR_pyb, (mp_obj_t)&pyb_module);

6
stm/pin_map.c
Wyświetl plik

@ -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) { 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; 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 (n_args > 1) {
if (!self->map_dict) { 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) { static mp_obj_t pin_map_obj_debug(uint n_args, mp_obj_t *args) {
pin_map_obj_t *self = args[0]; pin_map_obj_t *self = args[0];
if (n_args > 1) { 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_const_none;
} }
return MP_BOOL(self->debug); 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) { 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 (pin_obj != mp_const_none) {
if (!MP_OBJ_IS_TYPE(pin_obj, &pin_obj_type)) { 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")); nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "Pin.mapper didn't return a Pin object"));

6
stm/pyexec.c
Wyświetl plik

@ -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; uint32_t start = sys_tick_counter;
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
usb_vcp_set_interrupt_char(VCP_CHAR_CTRL_C); // allow ctrl-C to interrupt us 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 usb_vcp_set_interrupt_char(VCP_CHAR_NONE); // disable interrupt
nlr_pop(); nlr_pop();
ret = true; ret = true;
@ -238,8 +238,8 @@ raw_repl_reset:
void pyexec_repl(void) { void pyexec_repl(void) {
#if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD #if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
// in host mode, we enable the LCD for the repl // 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"))); mp_obj_t lcd_o = mp_call_function_0(mp_load_name(qstr_from_str("LCD")));
rt_call_function_1(rt_load_attr(lcd_o, qstr_from_str("light")), mp_const_true); mp_call_function_1(mp_load_attr(lcd_o, qstr_from_str("light")), mp_const_true);
#endif #endif
stdout_tx_str("Micro Python build <git hash> on 25/1/2014; " MICROPY_HW_BOARD_NAME " with STM32F405RG\r\n"); stdout_tx_str("Micro Python build <git hash> on 25/1/2014; " MICROPY_HW_BOARD_NAME " with STM32F405RG\r\n");

2
stm/sdcard.c
Wyświetl plik

@ -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) { static mp_obj_t sd_power(mp_obj_t self, mp_obj_t state) {
bool result; bool result;
if (rt_is_true(state)) { if (mp_obj_is_true(state)) {
result = sdcard_power_on(); result = sdcard_power_on();
} else { } else {
sdcard_power_off(); sdcard_power_off();

12
stm/timer.c
Wyświetl plik

@ -74,11 +74,11 @@ void timer_init(void) {
// Python interface // Python interface
mp_obj_t m = mp_obj_new_module(QSTR_FROM_STR_STATIC("timer")); 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)); mp_store_attr(m, QSTR_FROM_STR_STATIC("callback"), mp_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)); mp_store_attr(m, QSTR_FROM_STR_STATIC("period"), mp_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)); mp_store_attr(m, QSTR_FROM_STR_STATIC("prescaler"), mp_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)); mp_store_attr(m, QSTR_FROM_STR_STATIC("value"), mp_make_function_n(0, timer_py_get_value));
rt_store_name(QSTR_FROM_STR_STATIC("timer"), m); mp_store_name(QSTR_FROM_STR_STATIC("timer"), m);
} }
void timer_interrupt(void) { void timer_interrupt(void) {
@ -86,7 +86,7 @@ void timer_interrupt(void) {
nlr_buf_t nlr; nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
// XXX what to do if the GC is in the middle of running?? // 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(); nlr_pop();
} else { } else {
// uncaught exception // uncaught exception

2
stm/usrsw.c
Wyświetl plik

@ -33,7 +33,7 @@ static mp_obj_t switch_user_callback_obj;
static mp_obj_t switch_callback(mp_obj_t line) { static mp_obj_t switch_callback(mp_obj_t line) {
if (switch_user_callback_obj != mp_const_none) { 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; return mp_const_none;
} }

4
stmhal/accel.c
Wyświetl plik

@ -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) { 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 // 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 // init accel object
pyb_accel_obj.base.type = &pyb_accel_type; 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); 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); STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_accel_filtered_xyz_obj, pyb_accel_filtered_xyz);

2
stmhal/adc.c
Wyświetl plik

@ -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) { 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 // 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 // 1st argument is the pin name
mp_obj_t pin_obj = args[0]; mp_obj_t pin_obj = args[0];

2
stmhal/dac.c
Wyświetl plik

@ -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) { 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 // 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]); machine_int_t dac_id = mp_obj_get_int(args[0]);
uint32_t pin; uint32_t pin;

4
stmhal/exti.c
Wyświetl plik

@ -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) { 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 // 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); exti_obj_t *self = m_new_obj(exti_obj_t);
self->base.type = type_in; self->base.type = type_in;
@ -305,7 +305,7 @@ void Handle_EXTI_Irq(uint32_t line) {
exti_vector_t *v = &exti_vector[line]; exti_vector_t *v = &exti_vector[line];
if (v->callback_obj != mp_const_none) { if (v->callback_obj != mp_const_none) {
// TODO need to wrap this in an nlr_buf; really need a general function for this // 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));
} }
} }
} }

2
stmhal/gpio.c
Wyświetl plik

@ -27,7 +27,7 @@ mp_obj_t pyb_gpio(uint n_args, mp_obj_t *args) {
} }
// set pin // 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; return mp_const_none;
} }

2
stmhal/i2c.c
Wyświetl plik

@ -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) { 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 // 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 // get i2c number
machine_int_t i2c_id = mp_obj_get_int(args[0]) - 1; machine_int_t i2c_id = mp_obj_get_int(args[0]) - 1;

20
stmhal/lcd.c
Wyświetl plik

@ -214,7 +214,7 @@ mp_obj_t lcd_print(mp_obj_t text) {
mp_obj_t lcd_light(mp_obj_t value) { mp_obj_t lcd_light(mp_obj_t value) {
#if defined(PYB_LCD_BL_PORT) #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 PYB_LCD_BL_PORT->BSRRL = PYB_LCD_BL_PIN; // set pin high to turn backlight on
} else { } else {
PYB_LCD_BL_PORT->BSRRH = PYB_LCD_BL_PIN; // set pin low to turn backlight off 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 // Micro Python interface
mp_obj_t o = mp_obj_new_type(MP_QSTR_LCD, mp_const_empty_tuple, mp_obj_new_dict(0)); 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)); mp_store_attr(o, qstr_from_str("lcd8"), mp_make_function_n(2, lcd_draw_pixel_8));
rt_store_attr(o, qstr_from_str("clear"), rt_make_function_n(0, lcd_pix_clear)); mp_store_attr(o, qstr_from_str("clear"), mp_make_function_n(0, lcd_pix_clear));
rt_store_attr(o, qstr_from_str("get"), rt_make_function_n(2, lcd_pix_get)); mp_store_attr(o, qstr_from_str("get"), mp_make_function_n(2, lcd_pix_get));
rt_store_attr(o, qstr_from_str("set"), rt_make_function_n(2, lcd_pix_set)); mp_store_attr(o, qstr_from_str("set"), mp_make_function_n(2, lcd_pix_set));
rt_store_attr(o, qstr_from_str("reset"), rt_make_function_n(2, lcd_pix_reset)); mp_store_attr(o, qstr_from_str("reset"), mp_make_function_n(2, lcd_pix_reset));
rt_store_attr(o, qstr_from_str("show"), rt_make_function_n(0, lcd_pix_show)); mp_store_attr(o, qstr_from_str("show"), mp_make_function_n(0, lcd_pix_show));
rt_store_attr(o, qstr_from_str("text"), rt_make_function_n(1, lcd_print)); mp_store_attr(o, qstr_from_str("text"), mp_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("light"), mp_make_function_n(1, lcd_light));
mp_lcd = o; mp_lcd = o;
return 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) { void lcd_init(void) {
mp_lcd = MP_OBJ_NULL; 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) { void lcd_print_str(const char *str) {

2
stmhal/led.c
Wyświetl plik

@ -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) { 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 // 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 // get led number
machine_int_t led_id = mp_obj_get_int(args[0]) - 1; machine_int_t led_id = mp_obj_get_int(args[0]) - 1;

4
stmhal/main.c
Wyświetl plik

@ -251,12 +251,12 @@ soft_reset:
// Micro Python init // Micro Python init
qstr_init(); qstr_init();
rt_init(); mp_init();
mp_obj_t def_path[3]; mp_obj_t def_path[3];
def_path[0] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_); 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[1] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_src);
def_path[2] = MP_OBJ_NEW_QSTR(MP_QSTR_0_colon__slash_lib); 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(); readline_init();

6
stmhal/pin_map.c
Wyświetl plik

@ -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) { 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; 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 (n_args > 1) {
if (!self->map_dict) { 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) { static mp_obj_t pin_map_obj_debug(uint n_args, mp_obj_t *args) {
pin_map_obj_t *self = args[0]; pin_map_obj_t *self = args[0];
if (n_args > 1) { 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_const_none;
} }
return MP_BOOL(self->debug); 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) { 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 (pin_obj != mp_const_none) {
if (!MP_OBJ_IS_TYPE(pin_obj, &pin_obj_type)) { 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")); nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "Pin.mapper didn't return a Pin object"));

6
stmhal/pyexec.c
Wyświetl plik

@ -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(); uint32_t start = HAL_GetTick();
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
usb_vcp_set_interrupt_char(VCP_CHAR_CTRL_C); // allow ctrl-C to interrupt us 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 usb_vcp_set_interrupt_char(VCP_CHAR_NONE); // disable interrupt
nlr_pop(); nlr_pop();
ret = true; ret = true;
@ -151,8 +151,8 @@ int pyexec_friendly_repl(void) {
#if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD #if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
// in host mode, we enable the LCD for the repl // 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"))); mp_obj_t lcd_o = mp_call_function_0(mp_load_name(qstr_from_str("LCD")));
rt_call_function_1(rt_load_attr(lcd_o, qstr_from_str("light")), mp_const_true); mp_call_function_1(mp_load_attr(lcd_o, qstr_from_str("light")), mp_const_true);
#endif #endif
friendly_repl_reset: friendly_repl_reset:

2
stmhal/sdcard.c
Wyświetl plik

@ -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) { static mp_obj_t sd_power(mp_obj_t self, mp_obj_t state) {
bool result; bool result;
if (rt_is_true(state)) { if (mp_obj_is_true(state)) {
result = sdcard_power_on(); result = sdcard_power_on();
} else { } else {
sdcard_power_off(); sdcard_power_off();

2
stmhal/servo.c
Wyświetl plik

@ -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) { 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 // 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 // get servo number
machine_int_t servo_id = mp_obj_get_int(args[0]) - 1; machine_int_t servo_id = mp_obj_get_int(args[0]) - 1;

2
stmhal/usrsw.c
Wyświetl plik

@ -33,7 +33,7 @@ static mp_obj_t switch_user_callback_obj;
static mp_obj_t switch_callback(mp_obj_t line) { static mp_obj_t switch_callback(mp_obj_t line) {
if (switch_user_callback_obj != mp_const_none) { 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; return mp_const_none;
} }

42
teensy/main.c
Wyświetl plik

@ -186,7 +186,7 @@ mp_obj_t pyb_gpio(int n_args, mp_obj_t *args) {
// set pin // set pin
pinMode(pin, OUTPUT); pinMode(pin, OUTPUT);
digitalWrite(pin, rt_is_true(args[1])); digitalWrite(pin, mp_obj_is_true(args[1]));
return mp_const_none; return mp_const_none;
pin_error: pin_error:
@ -237,7 +237,7 @@ mp_obj_t pyb_delay(mp_obj_t count) {
} }
mp_obj_t pyb_led(mp_obj_t state) { 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; return state;
} }
@ -368,7 +368,7 @@ bool do_file(const char *filename) {
nlr_buf_t nlr; nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
rt_call_function_0(module_fun); mp_call_function_0(module_fun);
nlr_pop(); nlr_pop();
return true; return true;
} else { } else {
@ -427,7 +427,7 @@ void do_repl(void) {
nlr_buf_t nlr; nlr_buf_t nlr;
uint32_t start = micros(); uint32_t start = micros();
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
rt_call_function_0(module_fun); mp_call_function_0(module_fun);
nlr_pop(); nlr_pop();
// optional timing // optional timing
if (0) { if (0) {
@ -468,28 +468,28 @@ soft_reset:
gc_init(&_heap_start, (void*)HEAP_END); gc_init(&_heap_start, (void*)HEAP_END);
qstr_init(); qstr_init();
rt_init(); mp_init();
// add some functions to the python namespace // 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); 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)); mp_store_attr(m, MP_QSTR_info, mp_make_function_n(0, pyb_info));
rt_store_attr(m, MP_QSTR_source_dir, rt_make_function_n(1, pyb_source_dir)); mp_store_attr(m, MP_QSTR_source_dir, mp_make_function_n(1, pyb_source_dir));
rt_store_attr(m, MP_QSTR_main, rt_make_function_n(1, pyb_main)); mp_store_attr(m, MP_QSTR_main, mp_make_function_n(1, pyb_main));
rt_store_attr(m, MP_QSTR_gc, rt_make_function_n(0, pyb_gc)); mp_store_attr(m, MP_QSTR_gc, mp_make_function_n(0, pyb_gc));
rt_store_attr(m, MP_QSTR_delay, rt_make_function_n(1, pyb_delay)); mp_store_attr(m, MP_QSTR_delay, mp_make_function_n(1, pyb_delay));
rt_store_attr(m, MP_QSTR_led, rt_make_function_n(1, pyb_led)); mp_store_attr(m, MP_QSTR_led, mp_make_function_n(1, pyb_led));
rt_store_attr(m, MP_QSTR_Led, rt_make_function_n(1, pyb_Led)); mp_store_attr(m, MP_QSTR_Led, mp_make_function_n(1, pyb_Led));
rt_store_attr(m, MP_QSTR_analogRead, rt_make_function_n(1, pyb_analog_read)); mp_store_attr(m, MP_QSTR_analogRead, mp_make_function_n(1, pyb_analog_read));
rt_store_attr(m, MP_QSTR_analogWrite, rt_make_function_n(2, pyb_analog_write)); mp_store_attr(m, MP_QSTR_analogWrite, mp_make_function_n(2, pyb_analog_write));
rt_store_attr(m, MP_QSTR_analogWriteResolution, rt_make_function_n(1, pyb_analog_write_resolution)); mp_store_attr(m, MP_QSTR_analogWriteResolution, mp_make_function_n(1, pyb_analog_write_resolution));
rt_store_attr(m, MP_QSTR_analogWriteFrequency, rt_make_function_n(2, pyb_analog_write_frequency)); mp_store_attr(m, MP_QSTR_analogWriteFrequency, mp_make_function_n(2, pyb_analog_write_frequency));
rt_store_attr(m, MP_QSTR_gpio, (mp_obj_t)&pyb_gpio_obj); mp_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)); mp_store_attr(m, MP_QSTR_Servo, mp_make_function_n(0, pyb_Servo));
rt_store_name(MP_QSTR_pyb, m); mp_store_name(MP_QSTR_pyb, m);
rt_store_name(MP_QSTR_run, rt_make_function_n(1, pyb_run)); mp_store_name(MP_QSTR_run, mp_make_function_n(1, pyb_run));
} }
printf("About execute /boot.py\n"); printf("About execute /boot.py\n");

4
unix-cpy/main.c
Wyświetl plik

@ -61,7 +61,7 @@ void do_file(const char *file) {
int main(int argc, char **argv) { int main(int argc, char **argv) {
qstr_init(); qstr_init();
rt_init(); mp_init();
if (argc == 2) { if (argc == 2) {
do_file(argv[1]); do_file(argv[1]);
@ -69,7 +69,7 @@ int main(int argc, char **argv) {
printf("usage: py [<file>]\n"); printf("usage: py [<file>]\n");
return 1; return 1;
} }
rt_deinit(); mp_deinit();
return 0; return 0;
} }

16
unix/ffi.c
Wyświetl plik

@ -128,10 +128,10 @@ STATIC mp_obj_t ffimod_func(uint n_args, const mp_obj_t *args) {
o->func = sym; o->func = sym;
o->rettype = *rettype; o->rettype = *rettype;
mp_obj_t iterable = rt_getiter(args[3]); mp_obj_t iterable = mp_getiter(args[3]);
mp_obj_t item; mp_obj_t item;
int i = 0; 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); 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++) { for (int i = 0; i < cif->nargs; i++) {
pyargs[i] = mp_obj_new_int(*(int*)args[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); *(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; o->rettype = *rettype;
mp_obj_t iterable = rt_getiter(paramtypes_in); mp_obj_t iterable = mp_getiter(paramtypes_in);
mp_obj_t item; mp_obj_t item;
int i = 0; 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); 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() { void ffi_init() {
mp_obj_t m = mp_obj_new_module(QSTR_FROM_STR_STATIC("ffi")); 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); mp_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, 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! // 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);
} }

6
unix/file.c
Wyświetl plik

@ -140,7 +140,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_open_obj, 1, 2, mp_builtin_open);
void file_init() { void file_init() {
mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys); mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys);
rt_store_attr(m_sys, MP_QSTR_stdin, fdfile_new(STDIN_FILENO)); mp_store_attr(m_sys, MP_QSTR_stdin, fdfile_new(STDIN_FILENO));
rt_store_attr(m_sys, MP_QSTR_stdout, fdfile_new(STDOUT_FILENO)); mp_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_stderr, fdfile_new(STDERR_FILENO));
} }

28
unix/main.c
Wyświetl plik

@ -85,7 +85,7 @@ static void execute_from_lexer(mp_lexer_t *lex, mp_parse_input_kind_t input_kind
// execute it // execute it
nlr_buf_t nlr; nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
rt_call_function_0(module_fun); mp_call_function_0(module_fun);
nlr_pop(); nlr_pop();
} else { } else {
// uncaught exception // uncaught exception
@ -278,7 +278,7 @@ int main(int argc, char **argv) {
#endif #endif
qstr_init(); qstr_init();
rt_init(); mp_init();
char *home = getenv("HOME"); char *home = getenv("HOME");
char *path = getenv("MICROPYPATH"); char *path = getenv("MICROPYPATH");
@ -292,9 +292,9 @@ int main(int argc, char **argv) {
p++; 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_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_); path_items[0] = MP_OBJ_NEW_QSTR(MP_QSTR_);
char *p = path; char *p = path;
for (int i = 1; i < path_num; i++) { 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); 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); 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)); mp_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)); mp_store_name(qstr_from_str("mem_info"), mp_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("qstr_info"), mp_make_function_n(0, qstr_info));
#if MICROPY_ENABLE_GC #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 #endif
file_init(); file_init();
@ -344,8 +344,8 @@ int main(int argc, char **argv) {
// test_obj.attr = 42 // test_obj.attr = 42
mp_obj_t test_class_type, test_class_instance; 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)); 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)); mp_store_name(QSTR_FROM_STR_STATIC("test_obj"), test_class_instance = mp_call_function_0(test_class_type));
rt_store_attr(test_class_instance, QSTR_FROM_STR_STATIC("attr"), mp_obj_new_int(42)); mp_store_attr(test_class_instance, QSTR_FROM_STR_STATIC("attr"), mp_obj_new_int(42));
/* /*
printf("bytes:\n"); printf("bytes:\n");
@ -378,7 +378,7 @@ int main(int argc, char **argv) {
free(basedir); free(basedir);
} }
for (int i = a; i < argc; i++) { 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]); do_file(argv[a]);
executed = true; executed = true;
@ -390,7 +390,7 @@ int main(int argc, char **argv) {
do_repl(); do_repl();
} }
rt_deinit(); mp_deinit();
//printf("total bytes = %d\n", m_get_total_bytes_allocated()); //printf("total bytes = %d\n", m_get_total_bytes_allocated());
return 0; return 0;

18
unix/socket.c
Wyświetl plik

@ -314,7 +314,7 @@ static mp_obj_t mod_socket_getaddrinfo(uint n_args, const mp_obj_t *args) {
} }
assert(addr); 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) { for (; addr; addr = addr->ai_next) {
mp_obj_tuple_t *t = mp_obj_new_tuple(5, NULL); 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); 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[3] = mp_const_none;
} }
t->items[4] = mp_obj_new_bytearray(addr->ai_addrlen, addr->ai_addr); 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; return list;
} }
@ -366,15 +366,15 @@ static const struct sym_entry {
void microsocket_init() { void microsocket_init() {
mp_obj_t m = mp_obj_new_module(MP_QSTR_microsocket); mp_obj_t m = mp_obj_new_module(MP_QSTR_microsocket);
rt_store_attr(m, MP_QSTR_socket, (mp_obj_t)&microsocket_type); mp_store_attr(m, MP_QSTR_socket, (mp_obj_t)&microsocket_type);
#if MICROPY_SOCKET_EXTRA #if MICROPY_SOCKET_EXTRA
rt_store_attr(m, MP_QSTR_sockaddr_in, (mp_obj_t)&sockaddr_in_type); mp_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); mp_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); mp_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_gethostbyname, (mp_obj_t)&mod_socket_gethostbyname_obj);
#endif #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++) { 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));
} }
} }

6
unix/time.c
Wyświetl plik

@ -43,7 +43,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(mod_time_sleep_obj, mod_time_sleep);
void time_init() { void time_init() {
mp_obj_t m = mp_obj_new_module(QSTR_FROM_STR_STATIC("time")); 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); mp_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); mp_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("sleep"), (mp_obj_t)&mod_time_sleep_obj);
} }

14
windows/main.c
Wyświetl plik

@ -69,7 +69,7 @@ static void execute_from_lexer(mp_lexer_t *lex, mp_parse_input_kind_t input_kind
// execute it // execute it
nlr_buf_t nlr; nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) { if (nlr_push(&nlr) == 0) {
rt_call_function_0(module_fun); mp_call_function_0(module_fun);
nlr_pop(); nlr_pop();
} else { } else {
// uncaught exception // uncaught exception
@ -183,14 +183,14 @@ mp_obj_t qstr_info(void) {
int main(int argc, char **argv) { int main(int argc, char **argv) {
qstr_init(); qstr_init();
rt_init(); mp_init();
mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys); mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys);
mp_obj_t py_argv = mp_obj_new_list(0, NULL); 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)); mp_store_name(qstr_from_str("mem_info"), mp_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("qstr_info"), mp_make_function_n(0, qstr_info));
file_init(); file_init();
@ -217,7 +217,7 @@ int main(int argc, char **argv) {
} }
} else { } else {
for (int i = a; i < argc; i++) { 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]); do_file(argv[a]);
break; 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()); //printf("total bytes = %d\n", m_get_total_bytes_allocated());
return 0; return 0;