diff --git a/py/compile.c b/py/compile.c index 7056c3496..c584f0cf5 100644 --- a/py/compile.c +++ b/py/compile.c @@ -975,12 +975,12 @@ STATIC void close_over_variables_etc(compiler_t *comp, scope_t *this_scope, int if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) { for (int j = 0; j < this_scope->id_info_len; j++) { id_info_t *id2 = &this_scope->id_info[j]; - if (id2->kind == ID_INFO_KIND_FREE && id->qstr == id2->qstr) { + if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) { #if MICROPY_EMIT_CPYTHON - EMIT_ARG(load_closure, id->qstr, id->local_num); + EMIT_ARG(load_closure, id->qst, id->local_num); #else // in Micro Python we load closures using LOAD_FAST - EMIT_ARG(load_fast, id->qstr, id->flags, id->local_num); + EMIT_ARG(load_fast, id->qst, id->flags, id->local_num); #endif nfree += 1; } @@ -3446,7 +3446,7 @@ STATIC void compile_scope_compute_things(compiler_t *comp, scope_t *scope) { scope->num_locals = 0; for (int i = 0; i < scope->id_info_len; i++) { id_info_t *id = &scope->id_info[i]; - if (scope->kind == SCOPE_CLASS && id->qstr == MP_QSTR___class__) { + if (scope->kind == SCOPE_CLASS && id->qst == MP_QSTR___class__) { // __class__ is not counted as a local; if it's used then it becomes a ID_INFO_KIND_CELL continue; } @@ -3491,7 +3491,7 @@ STATIC void compile_scope_compute_things(compiler_t *comp, scope_t *scope) { if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) { for (int j = 0; j < scope->id_info_len; j++) { id_info_t *id2 = &scope->id_info[j]; - if (id2->kind == ID_INFO_KIND_FREE && id->qstr == id2->qstr) { + if (id2->kind == ID_INFO_KIND_FREE && id->qst == id2->qst) { assert(!(id2->flags & ID_FLAG_IS_PARAM)); // free vars should not be params #if MICROPY_EMIT_CPYTHON // in CPython the frees are numbered after the cells diff --git a/py/emit.h b/py/emit.h index 2c0f1bca9..1f1798fdf 100644 --- a/py/emit.h +++ b/py/emit.h @@ -57,84 +57,84 @@ typedef struct _emit_method_table_t { void (*start_pass)(emit_t *emit, pass_kind_t pass, scope_t *scope); void (*end_pass)(emit_t *emit); bool (*last_emit_was_return_value)(emit_t *emit); - void (*adjust_stack_size)(emit_t *emit, int delta); - void (*set_line_number)(emit_t *emit, int line); + void (*adjust_stack_size)(emit_t *emit, mp_int_t delta); + void (*set_line_number)(emit_t *emit, mp_uint_t line); - void (*load_id)(emit_t *emit, qstr qstr); - void (*store_id)(emit_t *emit, qstr qstr); - void (*delete_id)(emit_t *emit, qstr qstr); + void (*load_id)(emit_t *emit, qstr qst); + void (*store_id)(emit_t *emit, qstr qst); + void (*delete_id)(emit_t *emit, qstr qst); - void (*label_assign)(emit_t *emit, uint l); - void (*import_name)(emit_t *emit, qstr qstr); - void (*import_from)(emit_t *emit, qstr qstr); + void (*label_assign)(emit_t *emit, mp_uint_t l); + void (*import_name)(emit_t *emit, qstr qst); + void (*import_from)(emit_t *emit, qstr qst); void (*import_star)(emit_t *emit); void (*load_const_tok)(emit_t *emit, mp_token_kind_t tok); void (*load_const_small_int)(emit_t *emit, mp_int_t arg); - void (*load_const_int)(emit_t *emit, qstr qstr); - void (*load_const_dec)(emit_t *emit, qstr qstr); - void (*load_const_str)(emit_t *emit, qstr qstr, bool bytes); + void (*load_const_int)(emit_t *emit, qstr qst); + void (*load_const_dec)(emit_t *emit, qstr qst); + void (*load_const_str)(emit_t *emit, qstr qst, bool bytes); void (*load_null)(emit_t *emit); - void (*load_fast)(emit_t *emit, qstr qstr, uint id_flags, int local_num); - void (*load_deref)(emit_t *emit, qstr qstr, int local_num); - void (*load_name)(emit_t *emit, qstr qstr); - void (*load_global)(emit_t *emit, qstr qstr); - void (*load_attr)(emit_t *emit, qstr qstr); - void (*load_method)(emit_t *emit, qstr qstr); + void (*load_fast)(emit_t *emit, qstr qst, mp_uint_t id_flags, mp_uint_t local_num); + void (*load_deref)(emit_t *emit, qstr qst, mp_uint_t local_num); + void (*load_name)(emit_t *emit, qstr qst); + void (*load_global)(emit_t *emit, qstr qst); + void (*load_attr)(emit_t *emit, qstr qst); + void (*load_method)(emit_t *emit, qstr qst); void (*load_build_class)(emit_t *emit); void (*load_subscr)(emit_t *emit); - void (*store_fast)(emit_t *emit, qstr qstr, int local_num); - void (*store_deref)(emit_t *emit, qstr qstr, int local_num); - void (*store_name)(emit_t *emit, qstr qstr); - void (*store_global)(emit_t *emit, qstr qstr); - void (*store_attr)(emit_t *emit, qstr qstr); + void (*store_fast)(emit_t *emit, qstr qst, mp_uint_t local_num); + void (*store_deref)(emit_t *emit, qstr qst, mp_uint_t local_num); + void (*store_name)(emit_t *emit, qstr qst); + void (*store_global)(emit_t *emit, qstr qst); + void (*store_attr)(emit_t *emit, qstr qst); void (*store_subscr)(emit_t *emit); - void (*delete_fast)(emit_t *emit, qstr qstr, int local_num); - void (*delete_deref)(emit_t *emit, qstr qstr, int local_num); - void (*delete_name)(emit_t *emit, qstr qstr); - void (*delete_global)(emit_t *emit, qstr qstr); - void (*delete_attr)(emit_t *emit, qstr qstr); + void (*delete_fast)(emit_t *emit, qstr qst, mp_uint_t local_num); + void (*delete_deref)(emit_t *emit, qstr qst, mp_uint_t local_num); + void (*delete_name)(emit_t *emit, qstr qst); + void (*delete_global)(emit_t *emit, qstr qst); + void (*delete_attr)(emit_t *emit, qstr qst); void (*delete_subscr)(emit_t *emit); void (*dup_top)(emit_t *emit); void (*dup_top_two)(emit_t *emit); void (*pop_top)(emit_t *emit); void (*rot_two)(emit_t *emit); void (*rot_three)(emit_t *emit); - void (*jump)(emit_t *emit, uint label); - void (*pop_jump_if_true)(emit_t *emit, uint label); - void (*pop_jump_if_false)(emit_t *emit, uint label); - void (*jump_if_true_or_pop)(emit_t *emit, uint label); - void (*jump_if_false_or_pop)(emit_t *emit, uint label); - void (*break_loop)(emit_t *emit, uint label, int except_depth); - void (*continue_loop)(emit_t *emit, uint label, int except_depth); - void (*setup_with)(emit_t *emit, uint label); + void (*jump)(emit_t *emit, mp_uint_t label); + void (*pop_jump_if_true)(emit_t *emit, mp_uint_t label); + void (*pop_jump_if_false)(emit_t *emit, mp_uint_t label); + void (*jump_if_true_or_pop)(emit_t *emit, mp_uint_t label); + void (*jump_if_false_or_pop)(emit_t *emit, mp_uint_t label); + void (*break_loop)(emit_t *emit, mp_uint_t label, mp_uint_t except_depth); + void (*continue_loop)(emit_t *emit, mp_uint_t label, mp_uint_t except_depth); + void (*setup_with)(emit_t *emit, mp_uint_t label); void (*with_cleanup)(emit_t *emit); - void (*setup_except)(emit_t *emit, uint label); - void (*setup_finally)(emit_t *emit, uint label); + void (*setup_except)(emit_t *emit, mp_uint_t label); + void (*setup_finally)(emit_t *emit, mp_uint_t label); void (*end_finally)(emit_t *emit); void (*get_iter)(emit_t *emit); - void (*for_iter)(emit_t *emit, uint label); + void (*for_iter)(emit_t *emit, mp_uint_t label); void (*for_iter_end)(emit_t *emit); void (*pop_block)(emit_t *emit); void (*pop_except)(emit_t *emit); void (*unary_op)(emit_t *emit, mp_unary_op_t op); void (*binary_op)(emit_t *emit, mp_binary_op_t op); - void (*build_tuple)(emit_t *emit, int n_args); - void (*build_list)(emit_t *emit, int n_args); - void (*list_append)(emit_t *emit, int list_stack_index); - void (*build_map)(emit_t *emit, int n_args); + void (*build_tuple)(emit_t *emit, mp_uint_t n_args); + void (*build_list)(emit_t *emit, mp_uint_t n_args); + void (*list_append)(emit_t *emit, mp_uint_t list_stack_index); + void (*build_map)(emit_t *emit, mp_uint_t n_args); void (*store_map)(emit_t *emit); - void (*map_add)(emit_t *emit, int map_stack_index); - void (*build_set)(emit_t *emit, int n_args); - void (*set_add)(emit_t *emit, int set_stack_index); - void (*build_slice)(emit_t *emit, int n_args); - void (*unpack_sequence)(emit_t *emit, int n_args); - void (*unpack_ex)(emit_t *emit, int n_left, int n_right); - void (*make_function)(emit_t *emit, scope_t *scope, uint n_pos_defaults, uint n_kw_defaults); - void (*make_closure)(emit_t *emit, scope_t *scope, uint n_closed_over, uint n_pos_defaults, uint n_kw_defaults); - void (*call_function)(emit_t *emit, int n_positional, int n_keyword, uint star_flags); - void (*call_method)(emit_t *emit, int n_positional, int n_keyword, uint star_flags); + void (*map_add)(emit_t *emit, mp_uint_t map_stack_index); + void (*build_set)(emit_t *emit, mp_uint_t n_args); + void (*set_add)(emit_t *emit, mp_uint_t set_stack_index); + void (*build_slice)(emit_t *emit, mp_uint_t n_args); + void (*unpack_sequence)(emit_t *emit, mp_uint_t n_args); + void (*unpack_ex)(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right); + void (*make_function)(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults); + void (*make_closure)(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults); + void (*call_function)(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags); + void (*call_method)(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags); void (*return_value)(emit_t *emit); - void (*raise_varargs)(emit_t *emit, int n_args); + void (*raise_varargs)(emit_t *emit, mp_uint_t n_args); void (*yield_value)(emit_t *emit); void (*yield_from)(emit_t *emit); @@ -146,15 +146,15 @@ typedef struct _emit_method_table_t { #if MICROPY_EMIT_CPYTHON // these methods are only needed for emitcpy void (*load_const_verbatim_str)(emit_t *emit, const char *str); - void (*load_closure)(emit_t *emit, qstr qstr, int local_num); - void (*setup_loop)(emit_t *emit, uint label); + void (*load_closure)(emit_t *emit, qstr qst, mp_uint_t local_num); + void (*setup_loop)(emit_t *emit, mp_uint_t label); #endif } emit_method_table_t; -void emit_common_load_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qstr); -void emit_common_store_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qstr); -void emit_common_delete_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qstr); +void emit_common_load_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qst); +void emit_common_store_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qst); +void emit_common_delete_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qst); extern const emit_method_table_t emit_pass1_method_table; extern const emit_method_table_t emit_cpython_method_table; @@ -165,12 +165,12 @@ extern const emit_method_table_t emit_native_thumb_method_table; extern const emit_method_table_t emit_native_arm_method_table; emit_t *emit_pass1_new(void); -emit_t *emit_cpython_new(uint max_num_labels); -emit_t *emit_bc_new(uint max_num_labels); -emit_t *emit_native_x64_new(uint max_num_labels); -emit_t *emit_native_x86_new(uint max_num_labels); -emit_t *emit_native_thumb_new(uint max_num_labels); -emit_t *emit_native_arm_new(uint max_num_labels); +emit_t *emit_cpython_new(mp_uint_t max_num_labels); +emit_t *emit_bc_new(mp_uint_t max_num_labels); +emit_t *emit_native_x64_new(mp_uint_t max_num_labels); +emit_t *emit_native_x86_new(mp_uint_t max_num_labels); +emit_t *emit_native_thumb_new(mp_uint_t max_num_labels); +emit_t *emit_native_arm_new(mp_uint_t max_num_labels); void emit_pass1_free(emit_t *emit); void emit_bc_free(emit_t *emit); @@ -184,15 +184,14 @@ typedef struct _emit_inline_asm_t emit_inline_asm_t; typedef struct _emit_inline_asm_method_table_t { void (*start_pass)(emit_inline_asm_t *emit, pass_kind_t pass, scope_t *scope); bool (*end_pass)(emit_inline_asm_t *emit); - int (*count_params)(emit_inline_asm_t *emit, int n_params, mp_parse_node_t *pn_params); - void (*label)(emit_inline_asm_t *emit, uint label_num, qstr label_id); - void (*align)(emit_inline_asm_t *emit, uint align); - void (*data)(emit_inline_asm_t *emit, uint bytesize, uint val); - void (*op)(emit_inline_asm_t *emit, qstr op, int n_args, mp_parse_node_t *pn_args); + mp_uint_t (*count_params)(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params); + void (*label)(emit_inline_asm_t *emit, mp_uint_t label_num, qstr label_id); + void (*align)(emit_inline_asm_t *emit, mp_uint_t align); + void (*data)(emit_inline_asm_t *emit, mp_uint_t bytesize, mp_uint_t val); + void (*op)(emit_inline_asm_t *emit, qstr op, mp_uint_t n_args, mp_parse_node_t *pn_args); } emit_inline_asm_method_table_t; extern const emit_inline_asm_method_table_t emit_inline_thumb_method_table; -emit_inline_asm_t *emit_inline_thumb_new(uint max_num_labels); +emit_inline_asm_t *emit_inline_thumb_new(mp_uint_t max_num_labels); void emit_inline_thumb_free(emit_inline_asm_t *emit); - diff --git a/py/emitbc.c b/py/emitbc.c index eada190e6..05dc79ef4 100644 --- a/py/emitbc.c +++ b/py/emitbc.c @@ -49,39 +49,39 @@ struct _emit_t { pass_kind_t pass : 8; - uint last_emit_was_return_value : 8; + mp_uint_t last_emit_was_return_value : 8; int stack_size; scope_t *scope; - uint last_source_line_offset; - uint last_source_line; + mp_uint_t last_source_line_offset; + mp_uint_t last_source_line; - uint max_num_labels; - uint *label_offsets; + mp_uint_t max_num_labels; + mp_uint_t *label_offsets; - uint code_info_offset; - uint code_info_size; - uint bytecode_offset; - uint bytecode_size; + mp_uint_t code_info_offset; + mp_uint_t code_info_size; + mp_uint_t bytecode_offset; + mp_uint_t bytecode_size; byte *code_base; // stores both byte code and code info - // Accessed as uint, so must be aligned as such + // Accessed as mp_uint_t, so must be aligned as such byte dummy_data[DUMMY_DATA_SIZE]; }; STATIC void emit_bc_rot_two(emit_t *emit); STATIC void emit_bc_rot_three(emit_t *emit); -emit_t *emit_bc_new(uint max_num_labels) { +emit_t *emit_bc_new(mp_uint_t max_num_labels) { emit_t *emit = m_new0(emit_t, 1); emit->max_num_labels = max_num_labels; - emit->label_offsets = m_new(uint, emit->max_num_labels); + emit->label_offsets = m_new(mp_uint_t, emit->max_num_labels); return emit; } void emit_bc_free(emit_t *emit) { - m_del(uint, emit->label_offsets, emit->max_num_labels); + m_del(mp_uint_t, emit->label_offsets, emit->max_num_labels); m_del_obj(emit_t, emit); } @@ -128,7 +128,7 @@ STATIC void emit_write_code_info_qstr(emit_t* emit, qstr qst) { } #if MICROPY_ENABLE_SOURCE_LINE -STATIC void emit_write_code_info_bytes_lines(emit_t* emit, uint bytes_to_skip, uint lines_to_skip) { +STATIC void emit_write_code_info_bytes_lines(emit_t* emit, mp_uint_t bytes_to_skip, mp_uint_t lines_to_skip) { assert(bytes_to_skip > 0 || lines_to_skip > 0); //printf(" %d %d\n", bytes_to_skip, lines_to_skip); while (bytes_to_skip > 0 || lines_to_skip > 0) { @@ -179,7 +179,7 @@ STATIC void emit_write_bytecode_uint(emit_t* emit, mp_uint_t val) { emit_write_uint(emit, emit_get_cur_to_write_bytecode, val); } -STATIC void emit_write_bytecode_byte_byte(emit_t* emit, byte b1, uint b2) { +STATIC void emit_write_bytecode_byte_byte(emit_t* emit, byte b1, byte b2) { assert((b2 & (~0xff)) == 0); byte* c = emit_get_cur_to_write_bytecode(emit, 2); c[0] = b1; @@ -229,20 +229,20 @@ STATIC void emit_write_bytecode_byte_ptr(emit_t* emit, byte b, void *ptr) { } /* currently unused -STATIC void emit_write_bytecode_byte_uint_uint(emit_t* emit, byte b, uint num1, uint num2) { +STATIC void emit_write_bytecode_byte_uint_uint(emit_t* emit, byte b, mp_uint_t num1, mp_uint_t num2) { emit_write_bytecode_byte(emit, b); emit_write_bytecode_byte_uint(emit, num1); emit_write_bytecode_byte_uint(emit, num2); } */ -STATIC void emit_write_bytecode_byte_qstr(emit_t* emit, byte b, qstr qstr) { - emit_write_bytecode_byte_uint(emit, b, qstr); +STATIC void emit_write_bytecode_byte_qstr(emit_t* emit, byte b, qstr qst) { + emit_write_bytecode_byte_uint(emit, b, qst); } // unsigned labels are relative to ip following this instruction, stored as 16 bits -STATIC void emit_write_bytecode_byte_unsigned_label(emit_t* emit, byte b1, uint label) { - uint bytecode_offset; +STATIC void emit_write_bytecode_byte_unsigned_label(emit_t* emit, byte b1, mp_uint_t label) { + mp_uint_t bytecode_offset; if (emit->pass < MP_PASS_EMIT) { bytecode_offset = 0; } else { @@ -255,7 +255,7 @@ STATIC void emit_write_bytecode_byte_unsigned_label(emit_t* emit, byte b1, uint } // signed labels are relative to ip following this instruction, stored as 16 bits, in excess -STATIC void emit_write_bytecode_byte_signed_label(emit_t* emit, byte b1, uint label) { +STATIC void emit_write_bytecode_byte_signed_label(emit_t* emit, byte b1, mp_uint_t label) { int bytecode_offset; if (emit->pass < MP_PASS_EMIT) { bytecode_offset = 0; @@ -279,7 +279,7 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) { emit->last_source_line_offset = 0; emit->last_source_line = 1; if (pass < MP_PASS_EMIT) { - memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(uint)); + memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(mp_uint_t)); } emit->bytecode_offset = 0; emit->code_info_offset = 0; @@ -296,7 +296,7 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) { // bytecode prelude: local state size and exception stack size; 16 bit uints for now { - uint n_state = scope->num_locals + scope->stack_size; + mp_uint_t n_state = scope->num_locals + scope->stack_size; if (n_state == 0) { // Need at least 1 entry in the state, in the case an exception is // propagated through this function, the exception is returned in @@ -360,7 +360,7 @@ STATIC void emit_bc_end_pass(emit_t *emit) { } else if (emit->pass == MP_PASS_EMIT) { qstr *arg_names = m_new(qstr, emit->scope->num_pos_args + emit->scope->num_kwonly_args); for (int i = 0; i < emit->scope->num_pos_args + emit->scope->num_kwonly_args; i++) { - arg_names[i] = emit->scope->id_info[i].qstr; + arg_names[i] = emit->scope->id_info[i].qst; } mp_emit_glue_assign_bytecode(emit->scope->raw_code, emit->code_base, emit->code_info_size + emit->bytecode_size, @@ -373,11 +373,11 @@ STATIC bool emit_bc_last_emit_was_return_value(emit_t *emit) { return emit->last_emit_was_return_value; } -STATIC void emit_bc_adjust_stack_size(emit_t *emit, int delta) { +STATIC void emit_bc_adjust_stack_size(emit_t *emit, mp_int_t delta) { emit->stack_size += delta; } -STATIC void emit_bc_set_source_line(emit_t *emit, int source_line) { +STATIC void emit_bc_set_source_line(emit_t *emit, mp_uint_t source_line) { //printf("source: line %d -> %d offset %d -> %d\n", emit->last_source_line, source_line, emit->last_source_line_offset, emit->bytecode_offset); #if MICROPY_ENABLE_SOURCE_LINE if (mp_optimise_value >= 3) { @@ -385,8 +385,8 @@ STATIC void emit_bc_set_source_line(emit_t *emit, int source_line) { return; } if (source_line > emit->last_source_line) { - uint bytes_to_skip = emit->bytecode_offset - emit->last_source_line_offset; - uint lines_to_skip = source_line - emit->last_source_line; + mp_uint_t bytes_to_skip = emit->bytecode_offset - emit->last_source_line_offset; + mp_uint_t lines_to_skip = source_line - emit->last_source_line; emit_write_code_info_bytes_lines(emit, bytes_to_skip, lines_to_skip); emit->last_source_line_offset = emit->bytecode_offset; emit->last_source_line = source_line; @@ -394,20 +394,20 @@ STATIC void emit_bc_set_source_line(emit_t *emit, int source_line) { #endif } -STATIC void emit_bc_load_id(emit_t *emit, qstr qstr) { - emit_common_load_id(emit, &emit_bc_method_table, emit->scope, qstr); +STATIC void emit_bc_load_id(emit_t *emit, qstr qst) { + emit_common_load_id(emit, &emit_bc_method_table, emit->scope, qst); } -STATIC void emit_bc_store_id(emit_t *emit, qstr qstr) { - emit_common_store_id(emit, &emit_bc_method_table, emit->scope, qstr); +STATIC void emit_bc_store_id(emit_t *emit, qstr qst) { + emit_common_store_id(emit, &emit_bc_method_table, emit->scope, qst); } -STATIC void emit_bc_delete_id(emit_t *emit, qstr qstr) { - emit_common_delete_id(emit, &emit_bc_method_table, emit->scope, qstr); +STATIC void emit_bc_delete_id(emit_t *emit, qstr qst) { + emit_common_delete_id(emit, &emit_bc_method_table, emit->scope, qst); } -STATIC void emit_bc_pre(emit_t *emit, int stack_size_delta) { - assert((int)emit->stack_size + stack_size_delta >= 0); +STATIC void emit_bc_pre(emit_t *emit, mp_int_t stack_size_delta) { + assert((mp_int_t)emit->stack_size + stack_size_delta >= 0); emit->stack_size += stack_size_delta; if (emit->stack_size > emit->scope->stack_size) { emit->scope->stack_size = emit->stack_size; @@ -415,7 +415,7 @@ STATIC void emit_bc_pre(emit_t *emit, int stack_size_delta) { emit->last_emit_was_return_value = false; } -STATIC void emit_bc_label_assign(emit_t *emit, uint l) { +STATIC void emit_bc_label_assign(emit_t *emit, mp_uint_t l) { emit_bc_pre(emit, 0); assert(l < emit->max_num_labels); if (emit->pass < MP_PASS_EMIT) { @@ -429,14 +429,14 @@ STATIC void emit_bc_label_assign(emit_t *emit, uint l) { } } -STATIC void emit_bc_import_name(emit_t *emit, qstr qstr) { +STATIC void emit_bc_import_name(emit_t *emit, qstr qst) { emit_bc_pre(emit, -1); - emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_NAME, qst); } -STATIC void emit_bc_import_from(emit_t *emit, qstr qstr) { +STATIC void emit_bc_import_from(emit_t *emit, qstr qst) { emit_bc_pre(emit, 1); - emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_FROM, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_FROM, qst); } STATIC void emit_bc_import_star(emit_t *emit) { @@ -460,22 +460,22 @@ STATIC void emit_bc_load_const_small_int(emit_t *emit, mp_int_t arg) { emit_write_bytecode_byte_int(emit, MP_BC_LOAD_CONST_SMALL_INT, arg); } -STATIC void emit_bc_load_const_int(emit_t *emit, qstr qstr) { +STATIC void emit_bc_load_const_int(emit_t *emit, qstr qst) { emit_bc_pre(emit, 1); - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qst); } -STATIC void emit_bc_load_const_dec(emit_t *emit, qstr qstr) { +STATIC void emit_bc_load_const_dec(emit_t *emit, qstr qst) { emit_bc_pre(emit, 1); - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qst); } -STATIC void emit_bc_load_const_str(emit_t *emit, qstr qstr, bool bytes) { +STATIC void emit_bc_load_const_str(emit_t *emit, qstr qst, bool bytes) { emit_bc_pre(emit, 1); if (bytes) { - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qst); } else { - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qst); } } @@ -484,7 +484,7 @@ STATIC void emit_bc_load_null(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_LOAD_NULL); }; -STATIC void emit_bc_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_num) { +STATIC void emit_bc_load_fast(emit_t *emit, qstr qst, mp_uint_t id_flags, mp_uint_t local_num) { assert(local_num >= 0); emit_bc_pre(emit, 1); switch (local_num) { @@ -495,29 +495,29 @@ STATIC void emit_bc_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_ } } -STATIC void emit_bc_load_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_bc_load_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_bc_pre(emit, 1); emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_DEREF, local_num); } -STATIC void emit_bc_load_name(emit_t *emit, qstr qstr) { +STATIC void emit_bc_load_name(emit_t *emit, qstr qst) { emit_bc_pre(emit, 1); - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_NAME, qst); } -STATIC void emit_bc_load_global(emit_t *emit, qstr qstr) { +STATIC void emit_bc_load_global(emit_t *emit, qstr qst) { emit_bc_pre(emit, 1); - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qst); } -STATIC void emit_bc_load_attr(emit_t *emit, qstr qstr) { +STATIC void emit_bc_load_attr(emit_t *emit, qstr qst) { emit_bc_pre(emit, 0); - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_ATTR, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_ATTR, qst); } -STATIC void emit_bc_load_method(emit_t *emit, qstr qstr) { +STATIC void emit_bc_load_method(emit_t *emit, qstr qst) { emit_bc_pre(emit, 1); - emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_METHOD, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_METHOD, qst); } STATIC void emit_bc_load_build_class(emit_t *emit) { @@ -530,7 +530,7 @@ STATIC void emit_bc_load_subscr(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_LOAD_SUBSCR); } -STATIC void emit_bc_store_fast(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_bc_store_fast(emit_t *emit, qstr qst, mp_uint_t local_num) { assert(local_num >= 0); emit_bc_pre(emit, -1); switch (local_num) { @@ -541,24 +541,24 @@ STATIC void emit_bc_store_fast(emit_t *emit, qstr qstr, int local_num) { } } -STATIC void emit_bc_store_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_bc_store_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_bc_pre(emit, -1); emit_write_bytecode_byte_uint(emit, MP_BC_STORE_DEREF, local_num); } -STATIC void emit_bc_store_name(emit_t *emit, qstr qstr) { +STATIC void emit_bc_store_name(emit_t *emit, qstr qst) { emit_bc_pre(emit, -1); - emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_NAME, qst); } -STATIC void emit_bc_store_global(emit_t *emit, qstr qstr) { +STATIC void emit_bc_store_global(emit_t *emit, qstr qst) { emit_bc_pre(emit, -1); - emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_GLOBAL, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_GLOBAL, qst); } -STATIC void emit_bc_store_attr(emit_t *emit, qstr qstr) { +STATIC void emit_bc_store_attr(emit_t *emit, qstr qst) { emit_bc_pre(emit, -2); - emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_ATTR, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_ATTR, qst); } STATIC void emit_bc_store_subscr(emit_t *emit) { @@ -566,28 +566,28 @@ STATIC void emit_bc_store_subscr(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_STORE_SUBSCR); } -STATIC void emit_bc_delete_fast(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_bc_delete_fast(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_write_bytecode_byte_uint(emit, MP_BC_DELETE_FAST, local_num); } -STATIC void emit_bc_delete_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_bc_delete_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_write_bytecode_byte_uint(emit, MP_BC_DELETE_DEREF, local_num); } -STATIC void emit_bc_delete_name(emit_t *emit, qstr qstr) { +STATIC void emit_bc_delete_name(emit_t *emit, qstr qst) { emit_bc_pre(emit, 0); - emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_NAME, qst); } -STATIC void emit_bc_delete_global(emit_t *emit, qstr qstr) { +STATIC void emit_bc_delete_global(emit_t *emit, qstr qst) { emit_bc_pre(emit, 0); - emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qst); } -STATIC void emit_bc_delete_attr(emit_t *emit, qstr qstr) { +STATIC void emit_bc_delete_attr(emit_t *emit, qstr qst) { emit_bc_load_null(emit); emit_bc_rot_two(emit); - emit_bc_store_attr(emit, qstr); + emit_bc_store_attr(emit, qst); } STATIC void emit_bc_delete_subscr(emit_t *emit) { @@ -621,32 +621,32 @@ STATIC void emit_bc_rot_three(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_ROT_THREE); } -STATIC void emit_bc_jump(emit_t *emit, uint label) { +STATIC void emit_bc_jump(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, 0); emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP, label); } -STATIC void emit_bc_pop_jump_if_true(emit_t *emit, uint label) { +STATIC void emit_bc_pop_jump_if_true(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, -1); emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label); } -STATIC void emit_bc_pop_jump_if_false(emit_t *emit, uint label) { +STATIC void emit_bc_pop_jump_if_false(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, -1); emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label); } -STATIC void emit_bc_jump_if_true_or_pop(emit_t *emit, uint label) { +STATIC void emit_bc_jump_if_true_or_pop(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, -1); emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label); } -STATIC void emit_bc_jump_if_false_or_pop(emit_t *emit, uint label) { +STATIC void emit_bc_jump_if_false_or_pop(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, -1); emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label); } -STATIC void emit_bc_unwind_jump(emit_t *emit, uint label, int except_depth) { +STATIC void emit_bc_unwind_jump(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) { if (except_depth == 0) { emit_bc_pre(emit, 0); if (label & MP_EMIT_BREAK_FROM_FOR) { @@ -660,7 +660,7 @@ STATIC void emit_bc_unwind_jump(emit_t *emit, uint label, int except_depth) { } } -STATIC void emit_bc_setup_with(emit_t *emit, uint label) { +STATIC void emit_bc_setup_with(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, 7); emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_WITH, label); } @@ -670,12 +670,12 @@ STATIC void emit_bc_with_cleanup(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_WITH_CLEANUP); } -STATIC void emit_bc_setup_except(emit_t *emit, uint label) { +STATIC void emit_bc_setup_except(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, 0); emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label); } -STATIC void emit_bc_setup_finally(emit_t *emit, uint label) { +STATIC void emit_bc_setup_finally(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, 0); emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_FINALLY, label); } @@ -690,7 +690,7 @@ STATIC void emit_bc_get_iter(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_GET_ITER); } -STATIC void emit_bc_for_iter(emit_t *emit, uint label) { +STATIC void emit_bc_for_iter(emit_t *emit, mp_uint_t label) { emit_bc_pre(emit, 1); emit_write_bytecode_byte_unsigned_label(emit, MP_BC_FOR_ITER, label); } @@ -738,26 +738,22 @@ STATIC void emit_bc_binary_op(emit_t *emit, mp_binary_op_t op) { } } -STATIC void emit_bc_build_tuple(emit_t *emit, int n_args) { - assert(n_args >= 0); +STATIC void emit_bc_build_tuple(emit_t *emit, mp_uint_t n_args) { emit_bc_pre(emit, 1 - n_args); emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_TUPLE, n_args); } -STATIC void emit_bc_build_list(emit_t *emit, int n_args) { - assert(n_args >= 0); +STATIC void emit_bc_build_list(emit_t *emit, mp_uint_t n_args) { emit_bc_pre(emit, 1 - n_args); emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_LIST, n_args); } -STATIC void emit_bc_list_append(emit_t *emit, int list_stack_index) { - assert(list_stack_index >= 0); +STATIC void emit_bc_list_append(emit_t *emit, mp_uint_t list_stack_index) { emit_bc_pre(emit, -1); emit_write_bytecode_byte_uint(emit, MP_BC_LIST_APPEND, list_stack_index); } -STATIC void emit_bc_build_map(emit_t *emit, int n_args) { - assert(n_args >= 0); +STATIC void emit_bc_build_map(emit_t *emit, mp_uint_t n_args) { emit_bc_pre(emit, 1); emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_MAP, n_args); } @@ -767,43 +763,37 @@ STATIC void emit_bc_store_map(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_STORE_MAP); } -STATIC void emit_bc_map_add(emit_t *emit, int map_stack_index) { - assert(map_stack_index >= 0); +STATIC void emit_bc_map_add(emit_t *emit, mp_uint_t map_stack_index) { emit_bc_pre(emit, -2); emit_write_bytecode_byte_uint(emit, MP_BC_MAP_ADD, map_stack_index); } -STATIC void emit_bc_build_set(emit_t *emit, int n_args) { - assert(n_args >= 0); +STATIC void emit_bc_build_set(emit_t *emit, mp_uint_t n_args) { emit_bc_pre(emit, 1 - n_args); emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_SET, n_args); } -STATIC void emit_bc_set_add(emit_t *emit, int set_stack_index) { - assert(set_stack_index >= 0); +STATIC void emit_bc_set_add(emit_t *emit, mp_uint_t set_stack_index) { emit_bc_pre(emit, -1); emit_write_bytecode_byte_uint(emit, MP_BC_SET_ADD, set_stack_index); } -STATIC void emit_bc_build_slice(emit_t *emit, int n_args) { - assert(n_args >= 0); +STATIC void emit_bc_build_slice(emit_t *emit, mp_uint_t n_args) { emit_bc_pre(emit, 1 - n_args); emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_SLICE, n_args); } -STATIC void emit_bc_unpack_sequence(emit_t *emit, int n_args) { - assert(n_args >= 0); +STATIC void emit_bc_unpack_sequence(emit_t *emit, mp_uint_t n_args) { emit_bc_pre(emit, -1 + n_args); emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_SEQUENCE, n_args); } -STATIC void emit_bc_unpack_ex(emit_t *emit, int n_left, int n_right) { - assert(n_left >=0 && n_right >= 0); +STATIC void emit_bc_unpack_ex(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right) { emit_bc_pre(emit, -1 + n_left + n_right + 1); emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_EX, n_left | (n_right << 8)); } -STATIC void emit_bc_make_function(emit_t *emit, scope_t *scope, uint n_pos_defaults, uint n_kw_defaults) { +STATIC void emit_bc_make_function(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) { if (n_pos_defaults == 0 && n_kw_defaults == 0) { emit_bc_pre(emit, 1); emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_FUNCTION, scope->raw_code); @@ -813,7 +803,7 @@ STATIC void emit_bc_make_function(emit_t *emit, scope_t *scope, uint n_pos_defau } } -STATIC void emit_bc_make_closure(emit_t *emit, scope_t *scope, uint n_closed_over, uint n_pos_defaults, uint n_kw_defaults) { +STATIC void emit_bc_make_closure(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) { if (n_pos_defaults == 0 && n_kw_defaults == 0) { emit_bc_pre(emit, -n_closed_over + 1); emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_CLOSURE, scope->raw_code); @@ -826,7 +816,7 @@ STATIC void emit_bc_make_closure(emit_t *emit, scope_t *scope, uint n_closed_ove } } -STATIC void emit_bc_call_function_method_helper(emit_t *emit, int stack_adj, uint bytecode_base, int n_positional, int n_keyword, uint star_flags) { +STATIC void emit_bc_call_function_method_helper(emit_t *emit, mp_int_t stack_adj, mp_uint_t bytecode_base, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) { if (star_flags) { if (!(star_flags & MP_EMIT_STAR_FLAG_SINGLE)) { // load dummy entry for non-existent pos_seq @@ -836,19 +826,19 @@ STATIC void emit_bc_call_function_method_helper(emit_t *emit, int stack_adj, uin // load dummy entry for non-existent kw_dict emit_bc_load_null(emit); } - emit_bc_pre(emit, stack_adj - n_positional - 2 * n_keyword - 2); + emit_bc_pre(emit, stack_adj - (mp_int_t)n_positional - 2 * (mp_int_t)n_keyword - 2); emit_write_bytecode_byte_uint(emit, bytecode_base + 1, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints? } else { - emit_bc_pre(emit, stack_adj - n_positional - 2 * n_keyword); + emit_bc_pre(emit, stack_adj - (mp_int_t)n_positional - 2 * (mp_int_t)n_keyword); emit_write_bytecode_byte_uint(emit, bytecode_base, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints? } } -STATIC void emit_bc_call_function(emit_t *emit, int n_positional, int n_keyword, uint star_flags) { +STATIC void emit_bc_call_function(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) { emit_bc_call_function_method_helper(emit, 0, MP_BC_CALL_FUNCTION, n_positional, n_keyword, star_flags); } -STATIC void emit_bc_call_method(emit_t *emit, int n_positional, int n_keyword, uint star_flags) { +STATIC void emit_bc_call_method(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) { emit_bc_call_function_method_helper(emit, -1, MP_BC_CALL_METHOD, n_positional, n_keyword, star_flags); } @@ -858,7 +848,7 @@ STATIC void emit_bc_return_value(emit_t *emit) { emit_write_bytecode_byte(emit, MP_BC_RETURN_VALUE); } -STATIC void emit_bc_raise_varargs(emit_t *emit, int n_args) { +STATIC void emit_bc_raise_varargs(emit_t *emit, mp_uint_t n_args) { assert(0 <= n_args && n_args <= 2); emit_bc_pre(emit, -n_args); emit_write_bytecode_byte_byte(emit, MP_BC_RAISE_VARARGS, n_args); diff --git a/py/emitcommon.c b/py/emitcommon.c index 464979313..e199bc6e9 100644 --- a/py/emitcommon.c +++ b/py/emitcommon.c @@ -41,61 +41,61 @@ #define EMIT(fun, ...) (emit_method_table->fun(emit, __VA_ARGS__)) -void emit_common_load_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qstr) { +void emit_common_load_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qst) { // assumes pass is greater than 1, ie that all identifiers are defined in the scope - id_info_t *id = scope_find(scope, qstr); + id_info_t *id = scope_find(scope, qst); assert(id != NULL); // TODO can this ever fail? // call the emit backend with the correct code if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) { - EMIT(load_name, qstr); + EMIT(load_name, qst); } else if (id->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) { - EMIT(load_global, qstr); + EMIT(load_global, qst); } else if (id->kind == ID_INFO_KIND_LOCAL) { - EMIT(load_fast, qstr, id->flags, id->local_num); + EMIT(load_fast, qst, id->flags, id->local_num); } else if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) { - EMIT(load_deref, qstr, id->local_num); + EMIT(load_deref, qst, id->local_num); } else { assert(0); } } -void emit_common_store_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qstr) { +void emit_common_store_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qst) { // assumes pass is greater than 1, ie that all identifiers are defined in the scope - id_info_t *id = scope_find(scope, qstr); + id_info_t *id = scope_find(scope, qst); assert(id != NULL); // TODO can this ever fail? // call the emit backend with the correct code if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) { - EMIT(store_name, qstr); + EMIT(store_name, qst); } else if (id->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) { - EMIT(store_global, qstr); + EMIT(store_global, qst); } else if (id->kind == ID_INFO_KIND_LOCAL) { - EMIT(store_fast, qstr, id->local_num); + EMIT(store_fast, qst, id->local_num); } else if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) { - EMIT(store_deref, qstr, id->local_num); + EMIT(store_deref, qst, id->local_num); } else { assert(0); } } -void emit_common_delete_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qstr) { +void emit_common_delete_id(emit_t *emit, const emit_method_table_t *emit_method_table, scope_t *scope, qstr qst) { // assumes pass is greater than 1, ie that all identifiers are defined in the scope - id_info_t *id = scope_find(scope, qstr); + id_info_t *id = scope_find(scope, qst); assert(id != NULL); // TODO can this ever fail? // call the emit backend with the correct code if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) { - EMIT(delete_name, qstr); + EMIT(delete_name, qst); } else if (id->kind == ID_INFO_KIND_GLOBAL_EXPLICIT) { - EMIT(delete_global, qstr); + EMIT(delete_global, qst); } else if (id->kind == ID_INFO_KIND_LOCAL) { - EMIT(delete_fast, qstr, id->local_num); + EMIT(delete_fast, qst, id->local_num); } else if (id->kind == ID_INFO_KIND_CELL || id->kind == ID_INFO_KIND_FREE) { - EMIT(delete_deref, qstr, id->local_num); + EMIT(delete_deref, qst, id->local_num); } else { assert(0); } diff --git a/py/emitcpy.c b/py/emitcpy.c index 4d0c08522..bcf8a22c3 100644 --- a/py/emitcpy.c +++ b/py/emitcpy.c @@ -52,14 +52,14 @@ struct _emit_t { scope_t *scope; - uint max_num_labels; - int *label_offsets; + mp_uint_t max_num_labels; + mp_uint_t *label_offsets; }; -emit_t *emit_cpython_new(uint max_num_labels) { +emit_t *emit_cpython_new(mp_uint_t max_num_labels) { emit_t *emit = m_new(emit_t, 1); emit->max_num_labels = max_num_labels; - emit->label_offsets = m_new(int, max_num_labels); + emit->label_offsets = m_new(mp_uint_t, max_num_labels); return emit; } @@ -73,7 +73,7 @@ STATIC void emit_cpy_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) emit->last_emit_was_return_value = false; emit->scope = scope; if (pass < MP_PASS_EMIT) { - memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(int)); + memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(mp_uint_t)); } } @@ -88,23 +88,23 @@ STATIC bool emit_cpy_last_emit_was_return_value(emit_t *emit) { return emit->last_emit_was_return_value; } -STATIC void emit_cpy_adjust_stack_size(emit_t *emit, int delta) { +STATIC void emit_cpy_adjust_stack_size(emit_t *emit, mp_int_t delta) { emit->stack_size += delta; } -STATIC void emit_cpy_set_source_line(emit_t *emit, int source_line) { +STATIC void emit_cpy_set_source_line(emit_t *emit, mp_uint_t source_line) { } -STATIC void emit_cpy_load_id(emit_t *emit, qstr qstr) { - emit_common_load_id(emit, &emit_cpython_method_table, emit->scope, qstr); +STATIC void emit_cpy_load_id(emit_t *emit, qstr qst) { + emit_common_load_id(emit, &emit_cpython_method_table, emit->scope, qst); } -STATIC void emit_cpy_store_id(emit_t *emit, qstr qstr) { - emit_common_store_id(emit, &emit_cpython_method_table, emit->scope, qstr); +STATIC void emit_cpy_store_id(emit_t *emit, qstr qst) { + emit_common_store_id(emit, &emit_cpython_method_table, emit->scope, qst); } -STATIC void emit_cpy_delete_id(emit_t *emit, qstr qstr) { - emit_common_delete_id(emit, &emit_cpython_method_table, emit->scope, qstr); +STATIC void emit_cpy_delete_id(emit_t *emit, qstr qst) { + emit_common_delete_id(emit, &emit_cpython_method_table, emit->scope, qst); } // TODO: module-polymorphic function (read: name clash if made global) @@ -124,7 +124,7 @@ static void emit_pre(emit_t *emit, int stack_size_delta, int bytecode_size) { emit->bytecode_offset += bytecode_size; } -STATIC void emit_cpy_label_assign(emit_t *emit, uint l) { +STATIC void emit_cpy_label_assign(emit_t *emit, mp_uint_t l) { emit_pre(emit, 0, 0); assert(l < emit->max_num_labels); if (emit->pass < MP_PASS_EMIT) { @@ -138,17 +138,17 @@ STATIC void emit_cpy_label_assign(emit_t *emit, uint l) { } } -STATIC void emit_cpy_import_name(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_import_name(emit_t *emit, qstr qst) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("IMPORT_NAME %s\n", qstr_str(qstr)); + printf("IMPORT_NAME %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_import_from(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_import_from(emit_t *emit, qstr qst) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("IMPORT_FROM %s\n", qstr_str(qstr)); + printf("IMPORT_FROM %s\n", qstr_str(qst)); } } @@ -180,22 +180,22 @@ STATIC void emit_cpy_load_const_small_int(emit_t *emit, mp_int_t arg) { } } -STATIC void emit_cpy_load_const_int(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_load_const_int(emit_t *emit, qstr qst) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_CONST %s\n", qstr_str(qstr)); + printf("LOAD_CONST %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_load_const_dec(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_load_const_dec(emit_t *emit, qstr qst) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_CONST %s\n", qstr_str(qstr)); + printf("LOAD_CONST %s\n", qstr_str(qst)); } } -STATIC void print_quoted_str(qstr qstr, bool bytes) { - const char *str = qstr_str(qstr); +STATIC void print_quoted_str(qstr qst, bool bytes) { + const char *str = qstr_str(qst); int len = strlen(str); bool has_single_quote = false; bool has_double_quote = false; @@ -231,11 +231,11 @@ STATIC void print_quoted_str(qstr qstr, bool bytes) { printf("%c", quote_char); } -STATIC void emit_cpy_load_const_str(emit_t *emit, qstr qstr, bool bytes) { +STATIC void emit_cpy_load_const_str(emit_t *emit, qstr qst, bool bytes) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { printf("LOAD_CONST "); - print_quoted_str(qstr, bytes); + print_quoted_str(qst, bytes); printf("\n"); } } @@ -245,43 +245,43 @@ STATIC void emit_cpy_load_null(emit_t *emit) { assert(0); } -STATIC void emit_cpy_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_num) { +STATIC void emit_cpy_load_fast(emit_t *emit, qstr qst, mp_uint_t id_flags, mp_uint_t local_num) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_FAST %d %s\n", local_num, qstr_str(qstr)); + printf("LOAD_FAST " UINT_FMT " %s\n", local_num, qstr_str(qst)); } } -STATIC void emit_cpy_load_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_cpy_load_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_DEREF %d %s\n", local_num, qstr_str(qstr)); + printf("LOAD_DEREF " UINT_FMT " %s\n", local_num, qstr_str(qst)); } } -STATIC void emit_cpy_load_name(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_load_name(emit_t *emit, qstr qst) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_NAME %s\n", qstr_str(qstr)); + printf("LOAD_NAME %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_load_global(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_load_global(emit_t *emit, qstr qst) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_GLOBAL %s\n", qstr_str(qstr)); + printf("LOAD_GLOBAL %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_load_attr(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_load_attr(emit_t *emit, qstr qst) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_ATTR %s\n", qstr_str(qstr)); + printf("LOAD_ATTR %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_load_method(emit_t *emit, qstr qstr) { - emit_cpy_load_attr(emit, qstr); +STATIC void emit_cpy_load_method(emit_t *emit, qstr qst) { + emit_cpy_load_attr(emit, qst); } STATIC void emit_cpy_load_build_class(emit_t *emit) { @@ -298,38 +298,38 @@ STATIC void emit_cpy_load_subscr(emit_t *emit) { } } -STATIC void emit_cpy_store_fast(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_cpy_store_fast(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("STORE_FAST %d %s\n", local_num, qstr_str(qstr)); + printf("STORE_FAST " UINT_FMT " %s\n", local_num, qstr_str(qst)); } } -STATIC void emit_cpy_store_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_cpy_store_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("STORE_DEREF %d %s\n", local_num, qstr_str(qstr)); + printf("STORE_DEREF " UINT_FMT " %s\n", local_num, qstr_str(qst)); } } -STATIC void emit_cpy_store_name(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_store_name(emit_t *emit, qstr qst) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("STORE_NAME %s\n", qstr_str(qstr)); + printf("STORE_NAME %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_store_global(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_store_global(emit_t *emit, qstr qst) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("STORE_GLOBAL %s\n", qstr_str(qstr)); + printf("STORE_GLOBAL %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_store_attr(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_store_attr(emit_t *emit, qstr qst) { emit_pre(emit, -2, 3); if (emit->pass == MP_PASS_EMIT) { - printf("STORE_ATTR %s\n", qstr_str(qstr)); + printf("STORE_ATTR %s\n", qstr_str(qst)); } } @@ -340,38 +340,38 @@ STATIC void emit_cpy_store_subscr(emit_t *emit) { } } -STATIC void emit_cpy_delete_fast(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_cpy_delete_fast(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("DELETE_FAST %d %s\n", local_num, qstr_str(qstr)); + printf("DELETE_FAST " UINT_FMT " %s\n", local_num, qstr_str(qst)); } } -STATIC void emit_cpy_delete_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_cpy_delete_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("DELETE_DEREF %d %s\n", local_num, qstr_str(qstr)); + printf("DELETE_DEREF " UINT_FMT " %s\n", local_num, qstr_str(qst)); } } -STATIC void emit_cpy_delete_name(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_delete_name(emit_t *emit, qstr qst) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("DELETE_NAME %s\n", qstr_str(qstr)); + printf("DELETE_NAME %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_delete_global(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_delete_global(emit_t *emit, qstr qst) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("DELETE_GLOBAL %s\n", qstr_str(qstr)); + printf("DELETE_GLOBAL %s\n", qstr_str(qst)); } } -STATIC void emit_cpy_delete_attr(emit_t *emit, qstr qstr) { +STATIC void emit_cpy_delete_attr(emit_t *emit, qstr qst) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("DELETE_ATTR %s\n", qstr_str(qstr)); + printf("DELETE_ATTR %s\n", qstr_str(qst)); } } @@ -417,68 +417,68 @@ STATIC void emit_cpy_rot_three(emit_t *emit) { } } -STATIC void emit_cpy_jump(emit_t *emit, uint label) { +STATIC void emit_cpy_jump(emit_t *emit, mp_uint_t label) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { int dest = emit->label_offsets[label]; if (dest < emit->bytecode_offset) { - printf("JUMP_ABSOLUTE %d\n", emit->label_offsets[label]); + printf("JUMP_ABSOLUTE " UINT_FMT "\n", emit->label_offsets[label]); } else { - printf("JUMP_FORWARD %d\n", emit->label_offsets[label]); + printf("JUMP_FORWARD " UINT_FMT "\n", emit->label_offsets[label]); } } } -STATIC void emit_cpy_pop_jump_if_true(emit_t *emit, uint label) { +STATIC void emit_cpy_pop_jump_if_true(emit_t *emit, mp_uint_t label) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("POP_JUMP_IF_TRUE %d\n", emit->label_offsets[label]); + printf("POP_JUMP_IF_TRUE " UINT_FMT "\n", emit->label_offsets[label]); } } -STATIC void emit_cpy_pop_jump_if_false(emit_t *emit, uint label) { +STATIC void emit_cpy_pop_jump_if_false(emit_t *emit, mp_uint_t label) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("POP_JUMP_IF_FALSE %d\n", emit->label_offsets[label]); + printf("POP_JUMP_IF_FALSE " UINT_FMT "\n", emit->label_offsets[label]); } } -STATIC void emit_cpy_jump_if_true_or_pop(emit_t *emit, uint label) { +STATIC void emit_cpy_jump_if_true_or_pop(emit_t *emit, mp_uint_t label) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("JUMP_IF_TRUE_OR_POP %d\n", emit->label_offsets[label]); + printf("JUMP_IF_TRUE_OR_POP " UINT_FMT "\n", emit->label_offsets[label]); } } -STATIC void emit_cpy_jump_if_false_or_pop(emit_t *emit, uint label) { +STATIC void emit_cpy_jump_if_false_or_pop(emit_t *emit, mp_uint_t label) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("JUMP_IF_FALSE_OR_POP %d\n", emit->label_offsets[label]); + printf("JUMP_IF_FALSE_OR_POP " UINT_FMT "\n", emit->label_offsets[label]); } } -STATIC void emit_cpy_break_loop(emit_t *emit, uint label, int except_depth) { +STATIC void emit_cpy_break_loop(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) { emit_pre(emit, 0, 1); if (emit->pass == MP_PASS_EMIT) { printf("BREAK_LOOP\n"); } } -STATIC void emit_cpy_continue_loop(emit_t *emit, uint label, int except_depth) { +STATIC void emit_cpy_continue_loop(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) { if (except_depth == 0) { emit_cpy_jump(emit, label); } else { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("CONTINUE_LOOP %d\n", emit->label_offsets[label]); + printf("CONTINUE_LOOP " UINT_FMT "\n", emit->label_offsets[label]); } } } -STATIC void emit_cpy_setup_with(emit_t *emit, uint label) { +STATIC void emit_cpy_setup_with(emit_t *emit, mp_uint_t label) { emit_pre(emit, 7, 3); if (emit->pass == MP_PASS_EMIT) { - printf("SETUP_WITH %d\n", emit->label_offsets[label]); + printf("SETUP_WITH " UINT_FMT "\n", emit->label_offsets[label]); } } @@ -489,17 +489,17 @@ STATIC void emit_cpy_with_cleanup(emit_t *emit) { } } -STATIC void emit_cpy_setup_except(emit_t *emit, uint label) { +STATIC void emit_cpy_setup_except(emit_t *emit, mp_uint_t label) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("SETUP_EXCEPT %d\n", emit->label_offsets[label]); + printf("SETUP_EXCEPT " UINT_FMT "\n", emit->label_offsets[label]); } } -STATIC void emit_cpy_setup_finally(emit_t *emit, uint label) { +STATIC void emit_cpy_setup_finally(emit_t *emit, mp_uint_t label) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("SETUP_FINALLY %d\n", emit->label_offsets[label]); + printf("SETUP_FINALLY " UINT_FMT "\n", emit->label_offsets[label]); } } @@ -517,10 +517,10 @@ STATIC void emit_cpy_get_iter(emit_t *emit) { } } -STATIC void emit_cpy_for_iter(emit_t *emit, uint label) { +STATIC void emit_cpy_for_iter(emit_t *emit, mp_uint_t label) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("FOR_ITER %d\n", emit->label_offsets[label]); + printf("FOR_ITER " UINT_FMT "\n", emit->label_offsets[label]); } } @@ -605,31 +605,31 @@ STATIC void emit_cpy_binary_op(emit_t *emit, mp_binary_op_t op) { } } -STATIC void emit_cpy_build_tuple(emit_t *emit, int n_args) { +STATIC void emit_cpy_build_tuple(emit_t *emit, mp_uint_t n_args) { emit_pre(emit, 1 - n_args, 3); if (emit->pass == MP_PASS_EMIT) { - printf("BUILD_TUPLE %d\n", n_args); + printf("BUILD_TUPLE " UINT_FMT "\n", n_args); } } -STATIC void emit_cpy_build_list(emit_t *emit, int n_args) { +STATIC void emit_cpy_build_list(emit_t *emit, mp_uint_t n_args) { emit_pre(emit, 1 - n_args, 3); if (emit->pass == MP_PASS_EMIT) { - printf("BUILD_LIST %d\n", n_args); + printf("BUILD_LIST " UINT_FMT "\n", n_args); } } -STATIC void emit_cpy_list_append(emit_t *emit, int list_index) { +STATIC void emit_cpy_list_append(emit_t *emit, mp_uint_t list_index) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LIST_APPEND %d\n", list_index); + printf("LIST_APPEND " UINT_FMT "\n", list_index); } } -STATIC void emit_cpy_build_map(emit_t *emit, int n_args) { +STATIC void emit_cpy_build_map(emit_t *emit, mp_uint_t n_args) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("BUILD_MAP %d\n", n_args); + printf("BUILD_MAP " UINT_FMT "\n", n_args); } } @@ -640,57 +640,57 @@ STATIC void emit_cpy_store_map(emit_t *emit) { } } -STATIC void emit_cpy_map_add(emit_t *emit, int map_index) { +STATIC void emit_cpy_map_add(emit_t *emit, mp_uint_t map_index) { emit_pre(emit, -2, 3); if (emit->pass == MP_PASS_EMIT) { - printf("MAP_ADD %d\n", map_index); + printf("MAP_ADD " UINT_FMT "\n", map_index); } } -STATIC void emit_cpy_build_set(emit_t *emit, int n_args) { +STATIC void emit_cpy_build_set(emit_t *emit, mp_uint_t n_args) { emit_pre(emit, 1 - n_args, 3); if (emit->pass == MP_PASS_EMIT) { - printf("BUILD_SET %d\n", n_args); + printf("BUILD_SET " UINT_FMT "\n", n_args); } } -STATIC void emit_cpy_set_add(emit_t *emit, int set_index) { +STATIC void emit_cpy_set_add(emit_t *emit, mp_uint_t set_index) { emit_pre(emit, -1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("SET_ADD %d\n", set_index); + printf("SET_ADD " UINT_FMT "\n", set_index); } } -STATIC void emit_cpy_build_slice(emit_t *emit, int n_args) { +STATIC void emit_cpy_build_slice(emit_t *emit, mp_uint_t n_args) { emit_pre(emit, 1 - n_args, 3); if (emit->pass == MP_PASS_EMIT) { - printf("BUILD_SLICE %d\n", n_args); + printf("BUILD_SLICE " UINT_FMT "\n", n_args); } } -STATIC void emit_cpy_unpack_sequence(emit_t *emit, int n_args) { +STATIC void emit_cpy_unpack_sequence(emit_t *emit, mp_uint_t n_args) { emit_pre(emit, -1 + n_args, 3); if (emit->pass == MP_PASS_EMIT) { - printf("UNPACK_SEQUENCE %d\n", n_args); + printf("UNPACK_SEQUENCE " UINT_FMT "\n", n_args); } } -STATIC void emit_cpy_unpack_ex(emit_t *emit, int n_left, int n_right) { +STATIC void emit_cpy_unpack_ex(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right) { emit_pre(emit, -1 + n_left + n_right + 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("UNPACK_EX %d\n", n_left | (n_right << 8)); + printf("UNPACK_EX " UINT_FMT "\n", n_left | (n_right << 8)); } } -STATIC void emit_cpy_call_function(emit_t *emit, int n_positional, int n_keyword, uint star_flags) { - int s = 0; +STATIC void emit_cpy_call_function(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) { + mp_int_t s = 0; if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) { s += 1; } if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) { s += 1; } - emit_pre(emit, -n_positional - 2 * n_keyword - s, 3); + emit_pre(emit, -(mp_int_t)n_positional - 2 * (mp_int_t)n_keyword - s, 3); if (emit->pass == MP_PASS_EMIT) { if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) { if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) { @@ -705,11 +705,11 @@ STATIC void emit_cpy_call_function(emit_t *emit, int n_positional, int n_keyword printf("CALL_FUNCTION"); } } - printf(" %d, %d\n", n_positional, n_keyword); + printf(" " UINT_FMT ", " UINT_FMT "\n", n_positional, n_keyword); } } -STATIC void emit_cpy_call_method(emit_t *emit, int n_positional, int n_keyword, uint star_flags) { +STATIC void emit_cpy_call_method(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) { emit_cpy_call_function(emit, n_positional, n_keyword, star_flags); } @@ -721,17 +721,17 @@ STATIC void emit_cpy_return_value(emit_t *emit) { } } -STATIC void emit_cpy_raise_varargs(emit_t *emit, int n_args) { +STATIC void emit_cpy_raise_varargs(emit_t *emit, mp_uint_t n_args) { emit_pre(emit, -n_args, 3); if (emit->pass == MP_PASS_EMIT) { - printf("RAISE_VARARGS %d\n", n_args); + printf("RAISE_VARARGS " UINT_FMT "\n", n_args); } } -STATIC void load_cpy_const_code_and_name(emit_t *emit, qstr qstr) { +STATIC void load_cpy_const_code_and_name(emit_t *emit, qstr qst) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_CONST code %s\n", qstr_str(qstr)); + printf("LOAD_CONST code %s\n", qstr_str(qst)); } // load qualified name emit_pre(emit, 1, 3); @@ -755,24 +755,24 @@ STATIC void load_cpy_const_code_and_name(emit_t *emit, qstr qstr) { } } } - printf("%s'\n", qstr_str(qstr)); + printf("%s'\n", qstr_str(qst)); } } -STATIC void emit_cpy_make_function(emit_t *emit, scope_t *scope, uint n_pos_defaults, uint n_kw_defaults) { +STATIC void emit_cpy_make_function(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) { load_cpy_const_code_and_name(emit, scope->simple_name); emit_pre(emit, -1 - n_pos_defaults - 2 * n_kw_defaults, 3); if (emit->pass == MP_PASS_EMIT) { - printf("MAKE_FUNCTION %d\n", (n_kw_defaults << 8) | n_pos_defaults); + printf("MAKE_FUNCTION " UINT_FMT "\n", (n_kw_defaults << 8) | n_pos_defaults); } } -STATIC void emit_cpy_make_closure(emit_t *emit, scope_t *scope, uint n_closed_over, uint n_pos_defaults, uint n_kw_defaults) { +STATIC void emit_cpy_make_closure(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) { emit_cpy_build_tuple(emit, n_closed_over); load_cpy_const_code_and_name(emit, scope->simple_name); emit_pre(emit, -2 - n_pos_defaults - 2 * n_kw_defaults, 3); if (emit->pass == MP_PASS_EMIT) { - printf("MAKE_CLOSURE %d\n", (n_kw_defaults << 8) | n_pos_defaults); + printf("MAKE_CLOSURE " UINT_FMT "\n", (n_kw_defaults << 8) | n_pos_defaults); } } @@ -807,17 +807,17 @@ STATIC void emit_cpy_load_const_verbatim_str(emit_t *emit, const char *str) { } } -STATIC void emit_cpy_load_closure(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_cpy_load_closure(emit_t *emit, qstr qst, mp_uint_t local_num) { emit_pre(emit, 1, 3); if (emit->pass == MP_PASS_EMIT) { - printf("LOAD_CLOSURE %d %s\n", local_num, qstr_str(qstr)); + printf("LOAD_CLOSURE " UINT_FMT " %s\n", local_num, qstr_str(qst)); } } -STATIC void emit_cpy_setup_loop(emit_t *emit, uint label) { +STATIC void emit_cpy_setup_loop(emit_t *emit, mp_uint_t label) { emit_pre(emit, 0, 3); if (emit->pass == MP_PASS_EMIT) { - printf("SETUP_LOOP %d\n", emit->label_offsets[label]); + printf("SETUP_LOOP " UINT_FMT "\n", emit->label_offsets[label]); } } diff --git a/py/emitinlinethumb.c b/py/emitinlinethumb.c index 89e128c08..477b0d75c 100644 --- a/py/emitinlinethumb.c +++ b/py/emitinlinethumb.c @@ -56,7 +56,7 @@ struct _emit_inline_asm_t { uint16_t pass; uint16_t success; scope_t *scope; - uint max_num_labels; + mp_uint_t max_num_labels; qstr *label_lookup; asm_thumb_t *as; }; @@ -70,7 +70,7 @@ void emit_inline_thumb_error(emit_inline_asm_t *emit, const char *fmt, ...) { va_end(ap); } -emit_inline_asm_t *emit_inline_thumb_new(uint max_num_labels) { +emit_inline_asm_t *emit_inline_thumb_new(mp_uint_t max_num_labels) { emit_inline_asm_t *emit = m_new_obj(emit_inline_asm_t); emit->max_num_labels = max_num_labels; emit->label_lookup = m_new(qstr, max_num_labels); @@ -105,12 +105,12 @@ STATIC bool emit_inline_thumb_end_pass(emit_inline_asm_t *emit) { return emit->success; } -STATIC int emit_inline_thumb_count_params(emit_inline_asm_t *emit, int n_params, mp_parse_node_t *pn_params) { +STATIC mp_uint_t emit_inline_thumb_count_params(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params) { if (n_params > 4) { emit_inline_thumb_error(emit, "can only have up to 4 parameters to inline thumb assembly\n"); return 0; } - for (int i = 0; i < n_params; i++) { + for (mp_uint_t i = 0; i < n_params; i++) { if (!MP_PARSE_NODE_IS_ID(pn_params[i])) { emit_inline_thumb_error(emit, "parameter to inline assembler must be an identifier\n"); return 0; @@ -124,17 +124,17 @@ STATIC int emit_inline_thumb_count_params(emit_inline_asm_t *emit, int n_params, return n_params; } -STATIC void emit_inline_thumb_label(emit_inline_asm_t *emit, uint label_num, qstr label_id) { +STATIC void emit_inline_thumb_label(emit_inline_asm_t *emit, mp_uint_t label_num, qstr label_id) { assert(label_num < emit->max_num_labels); emit->label_lookup[label_num] = label_id; asm_thumb_label_assign(emit->as, label_num); } -STATIC void emit_inline_thumb_align(emit_inline_asm_t *emit, uint align) { +STATIC void emit_inline_thumb_align(emit_inline_asm_t *emit, mp_uint_t align) { asm_thumb_align(emit->as, align); } -STATIC void emit_inline_thumb_data(emit_inline_asm_t *emit, uint bytesize, uint val) { +STATIC void emit_inline_thumb_data(emit_inline_asm_t *emit, mp_uint_t bytesize, mp_uint_t val) { asm_thumb_data(emit->as, bytesize, val); } @@ -163,11 +163,11 @@ STATIC const reg_name_t reg_name_table[] = { {15, "pc\0"}, }; -STATIC uint get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn, uint max_reg) { +STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn, mp_uint_t max_reg) { if (MP_PARSE_NODE_IS_ID(pn)) { qstr reg_qstr = MP_PARSE_NODE_LEAF_ARG(pn); const char *reg_str = qstr_str(reg_qstr); - for (uint i = 0; i < MP_ARRAY_SIZE(reg_name_table); i++) { + for (mp_uint_t i = 0; i < MP_ARRAY_SIZE(reg_name_table); i++) { const reg_name_t *r = ®_name_table[i]; if (reg_str[0] == r->name[0] && reg_str[1] == r->name[1] && reg_str[2] == r->name[2] && (reg_str[2] == '\0' || reg_str[3] == '\0')) { if (r->reg > max_reg) { @@ -254,7 +254,7 @@ STATIC const cc_name_t cc_name_table[] = { {THUMB_CC_LE, "le"}, }; -STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, mp_parse_node_t *pn_args) { +STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_args, mp_parse_node_t *pn_args) { // TODO perhaps make two tables: // one_args = // "b", LAB, asm_thumb_b_n, @@ -266,7 +266,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, m // "subs", RLO, RLO, I3, asm_thumb_subs_reg_reg_i3 const char *op_str = qstr_str(op); - uint op_len = strlen(op_str); + mp_uint_t op_len = strlen(op_str); if (n_args == 0) { if (strcmp(op_str, "nop") == 0) { @@ -285,8 +285,8 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, m // TODO check that this succeeded, ie branch was within range asm_thumb_b_n(emit->as, label_num); } else if (op_str[0] == 'b' && op_len == 3) { - uint cc = -1; - for (uint i = 0; i < MP_ARRAY_SIZE(cc_name_table); i++) { + mp_uint_t cc = -1; + for (mp_uint_t i = 0; i < MP_ARRAY_SIZE(cc_name_table); i++) { if (op_str[1] == cc_name_table[i].name[0] && op_str[2] == cc_name_table[i].name[1]) { cc = cc_name_table[i].cc; } @@ -310,14 +310,14 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, m } else if (n_args == 2) { if (MP_PARSE_NODE_IS_ID(pn_args[1])) { // second arg is a register (or should be) - uint op_code; + mp_uint_t op_code; if (strcmp(op_str, "mov") == 0) { - uint reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); - uint reg_src = get_arg_reg(emit, op_str, pn_args[1], 15); + mp_uint_t reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); + mp_uint_t reg_src = get_arg_reg(emit, op_str, pn_args[1], 15); asm_thumb_mov_reg_reg(emit->as, reg_dest, reg_src); } else if (strcmp(op_str, "and_") == 0) { op_code = ASM_THUMB_FORMAT_4_AND; - uint reg_dest, reg_src; + mp_uint_t reg_dest, reg_src; op_format_4: reg_dest = get_arg_reg(emit, op_str, pn_args[0], 7); reg_src = get_arg_reg(emit, op_str, pn_args[1], 7); @@ -343,10 +343,10 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, m } } else { // second arg is not a register - uint op_code; + mp_uint_t op_code; if (strcmp(op_str, "mov") == 0) { op_code = ASM_THUMB_FORMAT_3_MOV; - uint rlo_dest, i8_src; + mp_uint_t rlo_dest, i8_src; op_format_3: rlo_dest = get_arg_reg(emit, op_str, pn_args[0], 7); i8_src = get_arg_i(emit, op_str, pn_args[1], 0xff); @@ -361,23 +361,23 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, m op_code = ASM_THUMB_FORMAT_3_SUB; goto op_format_3; } else if (strcmp(op_str, "movw") == 0) { - uint reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); + mp_uint_t reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); int i_src = get_arg_i(emit, op_str, pn_args[1], 0xffff); asm_thumb_movw_reg_i16(emit->as, reg_dest, i_src); } else if (strcmp(op_str, "movt") == 0) { - uint reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); + mp_uint_t reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); int i_src = get_arg_i(emit, op_str, pn_args[1], 0xffff); asm_thumb_movt_reg_i16(emit->as, reg_dest, i_src); } else if (strcmp(op_str, "movwt") == 0) { // this is a convenience instruction // we clear the MSB since it might be set from extracting the small int value - uint reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); + mp_uint_t reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15); int i_src = get_arg_i(emit, op_str, pn_args[1], 0xffffffff); asm_thumb_movw_reg_i16(emit->as, reg_dest, i_src & 0xffff); asm_thumb_movt_reg_i16(emit->as, reg_dest, (i_src >> 16) & 0x7fff); } else if (strcmp(op_str, "ldr") == 0) { op_code = ASM_THUMB_FORMAT_9_LDR | ASM_THUMB_FORMAT_9_WORD_TRANSFER; - uint rlo_dest, rlo_base, i5; + mp_uint_t rlo_dest, rlo_base, i5; mp_parse_node_t pn_base, pn_offset; op_format_9_10: rlo_dest = get_arg_reg(emit, op_str, pn_args[0], 7); @@ -413,10 +413,10 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, m } } else if (n_args == 3) { - uint op_code; + mp_uint_t op_code; if (strcmp(op_str, "add") == 0) { op_code = ASM_THUMB_FORMAT_2_ADD; - uint rlo_dest, rlo_src; + mp_uint_t rlo_dest, rlo_src; op_format_2: rlo_dest = get_arg_reg(emit, op_str, pn_args[0], 7); rlo_src = get_arg_reg(emit, op_str, pn_args[1], 7); diff --git a/py/emitnative.c b/py/emitnative.c index 849f1f63b..685c6177e 100644 --- a/py/emitnative.c +++ b/py/emitnative.c @@ -432,10 +432,10 @@ struct _emit_t { vtype_kind_t return_vtype; - uint local_vtype_alloc; + mp_uint_t local_vtype_alloc; vtype_kind_t *local_vtype; - uint stack_info_alloc; + mp_uint_t stack_info_alloc; stack_info_t *stack_info; int stack_start; @@ -448,7 +448,7 @@ struct _emit_t { ASM_T *as; }; -emit_t *EXPORT_FUN(new)(uint max_num_labels) { +emit_t *EXPORT_FUN(new)(mp_uint_t max_num_labels) { emit_t *emit = m_new0(emit_t, 1); emit->as = ASM_NEW(max_num_labels); return emit; @@ -636,11 +636,11 @@ STATIC bool emit_native_last_emit_was_return_value(emit_t *emit) { return emit->last_emit_was_return_value; } -STATIC void emit_native_adjust_stack_size(emit_t *emit, int delta) { +STATIC void emit_native_adjust_stack_size(emit_t *emit, mp_int_t delta) { emit->stack_size += delta; } -STATIC void emit_native_set_source_line(emit_t *emit, int source_line) { +STATIC void emit_native_set_source_line(emit_t *emit, mp_uint_t source_line) { } STATIC void adjust_stack(emit_t *emit, int stack_size_delta) { @@ -916,19 +916,19 @@ STATIC void emit_get_stack_pointer_to_reg_for_push(emit_t *emit, mp_uint_t reg_d adjust_stack(emit, n_push); } -STATIC void emit_native_load_id(emit_t *emit, qstr qstr) { - emit_common_load_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr); +STATIC void emit_native_load_id(emit_t *emit, qstr qst) { + emit_common_load_id(emit, &EXPORT_FUN(method_table), emit->scope, qst); } -STATIC void emit_native_store_id(emit_t *emit, qstr qstr) { - emit_common_store_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr); +STATIC void emit_native_store_id(emit_t *emit, qstr qst) { + emit_common_store_id(emit, &EXPORT_FUN(method_table), emit->scope, qst); } -STATIC void emit_native_delete_id(emit_t *emit, qstr qstr) { - emit_common_delete_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr); +STATIC void emit_native_delete_id(emit_t *emit, qstr qst) { + emit_common_delete_id(emit, &EXPORT_FUN(method_table), emit->scope, qst); } -STATIC void emit_native_label_assign(emit_t *emit, uint l) { +STATIC void emit_native_label_assign(emit_t *emit, mp_uint_t l) { emit_native_pre(emit); // need to commit stack because we can jump here from elsewhere need_stack_settled(emit); @@ -1008,25 +1008,25 @@ STATIC void emit_native_load_const_int(emit_t *emit, qstr qst) { emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } -STATIC void emit_native_load_const_dec(emit_t *emit, qstr qstr) { +STATIC void emit_native_load_const_dec(emit_t *emit, qstr qst) { // for viper, a float/complex is just a Python object emit_native_pre(emit); - emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_DEC, qstr, REG_ARG_1); + emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_DEC, qst, REG_ARG_1); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } -STATIC void emit_native_load_const_str(emit_t *emit, qstr qstr, bool bytes) { +STATIC void emit_native_load_const_str(emit_t *emit, qstr qst, bool bytes) { emit_native_pre(emit); if (emit->do_viper_types) { // not implemented properly // load a pointer to the asciiz string? assert(0); - emit_post_push_imm(emit, VTYPE_PTR, (mp_uint_t)qstr_str(qstr)); + emit_post_push_imm(emit, VTYPE_PTR, (mp_uint_t)qstr_str(qst)); } else { if (bytes) { - emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_BYTES, qstr, REG_ARG_1); + emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_BYTES, qst, REG_ARG_1); } else { - emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_STR, qstr, REG_ARG_1); + emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_STR, qst, REG_ARG_1); } emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } @@ -1037,10 +1037,10 @@ STATIC void emit_native_load_null(emit_t *emit) { emit_post_push_imm(emit, VTYPE_PYOBJ, 0); } -STATIC void emit_native_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_num) { +STATIC void emit_native_load_fast(emit_t *emit, qstr qst, mp_uint_t id_flags, mp_uint_t local_num) { vtype_kind_t vtype = emit->local_vtype[local_num]; if (vtype == VTYPE_UNBOUND) { - printf("ViperTypeError: local %s used before type known\n", qstr_str(qstr)); + printf("ViperTypeError: local %s used before type known\n", qstr_str(qst)); } emit_native_pre(emit); #if N_X64 @@ -1096,25 +1096,25 @@ STATIC void emit_native_load_fast(emit_t *emit, qstr qstr, uint id_flags, int lo #endif } -STATIC void emit_native_load_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_native_load_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { // not implemented // in principle could support this quite easily (ldr r0, [r0, #0]) and then get closed over variables! assert(0); } -STATIC void emit_native_load_name(emit_t *emit, qstr qstr) { +STATIC void emit_native_load_name(emit_t *emit, qstr qst) { emit_native_pre(emit); - emit_call_with_imm_arg(emit, MP_F_LOAD_NAME, qstr, REG_ARG_1); + emit_call_with_imm_arg(emit, MP_F_LOAD_NAME, qst, REG_ARG_1); 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 qst) { emit_native_pre(emit); - emit_call_with_imm_arg(emit, MP_F_LOAD_GLOBAL, qstr, REG_ARG_1); + emit_call_with_imm_arg(emit, MP_F_LOAD_GLOBAL, qst, REG_ARG_1); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } -STATIC void emit_native_load_attr(emit_t *emit, qstr qstr) { +STATIC void emit_native_load_attr(emit_t *emit, qstr qst) { // depends on type of subject: // - integer, function, pointer to integers: error // - pointer to structure: get member, quite easy @@ -1122,16 +1122,16 @@ STATIC void emit_native_load_attr(emit_t *emit, qstr qstr) { vtype_kind_t vtype_base; emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base assert(vtype_base == VTYPE_PYOBJ); - emit_call_with_imm_arg(emit, MP_F_LOAD_ATTR, qstr, REG_ARG_2); // arg2 = attribute name + emit_call_with_imm_arg(emit, MP_F_LOAD_ATTR, qst, REG_ARG_2); // arg2 = attribute name emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } -STATIC void emit_native_load_method(emit_t *emit, qstr qstr) { +STATIC void emit_native_load_method(emit_t *emit, qstr qst) { vtype_kind_t vtype_base; emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base assert(vtype_base == VTYPE_PYOBJ); emit_get_stack_pointer_to_reg_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr - emit_call_with_imm_arg(emit, MP_F_LOAD_METHOD, qstr, REG_ARG_2); // arg2 = method name + emit_call_with_imm_arg(emit, MP_F_LOAD_METHOD, qst, REG_ARG_2); // arg2 = method name } STATIC void emit_native_load_build_class(emit_t *emit) { @@ -1151,7 +1151,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) { } } -STATIC void emit_native_store_fast(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_native_store_fast(emit_t *emit, qstr qst, mp_uint_t local_num) { vtype_kind_t vtype; #if N_X64 if (local_num == 0) { @@ -1209,25 +1209,25 @@ STATIC void emit_native_store_fast(emit_t *emit, qstr qstr, int local_num) { emit->local_vtype[local_num] = vtype; } else if (emit->local_vtype[local_num] != vtype) { // type of local is not the same as object stored in it - printf("ViperTypeError: type mismatch, local %s has type %d but source object has type %d\n", qstr_str(qstr), emit->local_vtype[local_num], vtype); + printf("ViperTypeError: type mismatch, local %s has type %d but source object has type %d\n", qstr_str(qst), emit->local_vtype[local_num], vtype); } } -STATIC void emit_native_store_deref(emit_t *emit, qstr qstr, int local_num) { +STATIC void emit_native_store_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { // not implemented assert(0); } -STATIC void emit_native_store_name(emit_t *emit, qstr qstr) { +STATIC void emit_native_store_name(emit_t *emit, qstr qst) { // mp_store_name, but needs conversion of object (maybe have mp_viper_store_name(obj, type)) vtype_kind_t vtype; emit_pre_pop_reg(emit, &vtype, REG_ARG_2); assert(vtype == VTYPE_PYOBJ); - emit_call_with_imm_arg(emit, MP_F_STORE_NAME, qstr, REG_ARG_1); // arg1 = name + emit_call_with_imm_arg(emit, MP_F_STORE_NAME, qst, REG_ARG_1); // arg1 = name emit_post(emit); } -STATIC void emit_native_store_global(emit_t *emit, qstr qstr) { +STATIC void emit_native_store_global(emit_t *emit, qstr qst) { vtype_kind_t vtype = peek_vtype(emit); if (vtype == VTYPE_PYOBJ) { emit_pre_pop_reg(emit, &vtype, REG_ARG_2); @@ -1236,16 +1236,16 @@ STATIC void emit_native_store_global(emit_t *emit, qstr qstr) { emit_call_with_imm_arg(emit, MP_F_CONVERT_NATIVE_TO_OBJ, vtype, REG_ARG_2); // arg2 = type ASM_MOV_REG_TO_REG(emit->as, REG_RET, REG_ARG_2); } - emit_call_with_imm_arg(emit, MP_F_STORE_GLOBAL, qstr, REG_ARG_1); // arg1 = name + emit_call_with_imm_arg(emit, MP_F_STORE_GLOBAL, qst, REG_ARG_1); // arg1 = name emit_post(emit); } -STATIC void emit_native_store_attr(emit_t *emit, qstr qstr) { +STATIC void emit_native_store_attr(emit_t *emit, qstr qst) { vtype_kind_t vtype_base, vtype_val; emit_pre_pop_reg_reg(emit, &vtype_base, REG_ARG_1, &vtype_val, REG_ARG_3); // arg1 = base, arg3 = value assert(vtype_base == VTYPE_PYOBJ); assert(vtype_val == VTYPE_PYOBJ); - emit_call_with_imm_arg(emit, MP_F_STORE_ATTR, qstr, REG_ARG_2); // arg2 = attribute name + emit_call_with_imm_arg(emit, MP_F_STORE_ATTR, qst, REG_ARG_2); // arg2 = attribute name emit_post(emit); } @@ -1262,12 +1262,12 @@ STATIC void emit_native_store_subscr(emit_t *emit) { emit_call(emit, MP_F_OBJ_SUBSCR); } -STATIC void emit_native_delete_fast(emit_t *emit, qstr qst, int local_num) { +STATIC void emit_native_delete_fast(emit_t *emit, qstr qst, mp_uint_t local_num) { // TODO implement me! // could support for Python types, just set to None (so GC can reclaim it) } -STATIC void emit_native_delete_deref(emit_t *emit, qstr qst, int local_num) { +STATIC void emit_native_delete_deref(emit_t *emit, qstr qst, mp_uint_t local_num) { // TODO implement me! } @@ -1328,7 +1328,7 @@ STATIC void emit_native_rot_three(emit_t *emit) { emit_post_push_reg_reg_reg(emit, vtype0, REG_TEMP0, vtype2, REG_TEMP2, vtype1, REG_TEMP1); } -STATIC void emit_native_jump(emit_t *emit, uint label) { +STATIC void emit_native_jump(emit_t *emit, mp_uint_t label) { emit_native_pre(emit); // need to commit stack because we are jumping elsewhere need_stack_settled(emit); @@ -1336,7 +1336,7 @@ STATIC void emit_native_jump(emit_t *emit, uint label) { emit_post(emit); } -STATIC void emit_native_jump_helper(emit_t *emit, uint label, bool pop) { +STATIC void emit_native_jump_helper(emit_t *emit, mp_uint_t label, bool pop) { vtype_kind_t vtype = peek_vtype(emit); if (vtype == VTYPE_BOOL) { emit_pre_pop_reg(emit, &vtype, REG_RET); @@ -1357,41 +1357,41 @@ STATIC void emit_native_jump_helper(emit_t *emit, uint label, bool pop) { need_stack_settled(emit); } -STATIC void emit_native_pop_jump_if_true(emit_t *emit, uint label) { +STATIC void emit_native_pop_jump_if_true(emit_t *emit, mp_uint_t label) { emit_native_jump_helper(emit, label, true); ASM_JUMP_IF_REG_NONZERO(emit->as, REG_RET, label); emit_post(emit); } -STATIC void emit_native_pop_jump_if_false(emit_t *emit, uint label) { +STATIC void emit_native_pop_jump_if_false(emit_t *emit, mp_uint_t label) { emit_native_jump_helper(emit, label, true); ASM_JUMP_IF_REG_ZERO(emit->as, REG_RET, label); emit_post(emit); } -STATIC void emit_native_jump_if_true_or_pop(emit_t *emit, uint label) { +STATIC void emit_native_jump_if_true_or_pop(emit_t *emit, mp_uint_t label) { emit_native_jump_helper(emit, label, false); ASM_JUMP_IF_REG_NONZERO(emit->as, REG_RET, label); adjust_stack(emit, -1); emit_post(emit); } -STATIC void emit_native_jump_if_false_or_pop(emit_t *emit, uint label) { +STATIC void emit_native_jump_if_false_or_pop(emit_t *emit, mp_uint_t label) { emit_native_jump_helper(emit, label, false); ASM_JUMP_IF_REG_ZERO(emit->as, REG_RET, label); adjust_stack(emit, -1); emit_post(emit); } -STATIC void emit_native_break_loop(emit_t *emit, uint label, int except_depth) { +STATIC void emit_native_break_loop(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) { emit_native_jump(emit, label & ~MP_EMIT_BREAK_FROM_FOR); // TODO properly } -STATIC void emit_native_continue_loop(emit_t *emit, uint label, int except_depth) { +STATIC void emit_native_continue_loop(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) { emit_native_jump(emit, label); // TODO properly } -STATIC void emit_native_setup_with(emit_t *emit, uint label) { +STATIC void emit_native_setup_with(emit_t *emit, mp_uint_t label) { // not supported, or could be with runtime call assert(0); } @@ -1400,7 +1400,7 @@ STATIC void emit_native_with_cleanup(emit_t *emit) { assert(0); } -STATIC void emit_native_setup_except(emit_t *emit, uint label) { +STATIC void emit_native_setup_except(emit_t *emit, mp_uint_t label) { emit_native_pre(emit); // need to commit stack because we may jump elsewhere need_stack_settled(emit); @@ -1410,7 +1410,7 @@ STATIC void emit_native_setup_except(emit_t *emit, uint label) { emit_post(emit); } -STATIC void emit_native_setup_finally(emit_t *emit, uint label) { +STATIC void emit_native_setup_finally(emit_t *emit, mp_uint_t label) { emit_native_setup_except(emit, label); } @@ -1430,7 +1430,7 @@ STATIC void emit_native_get_iter(emit_t *emit) { emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } -STATIC void emit_native_for_iter(emit_t *emit, uint label) { +STATIC void emit_native_for_iter(emit_t *emit, mp_uint_t label) { emit_native_pre(emit); vtype_kind_t vtype; emit_access_stack(emit, 1, &vtype, REG_ARG_1); @@ -1527,7 +1527,7 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) { } } -STATIC void emit_native_build_tuple(emit_t *emit, int n_args) { +STATIC void emit_native_build_tuple(emit_t *emit, mp_uint_t n_args) { // for viper: call runtime, with types of args // if wrapped in byte_array, or something, allocates memory and fills it emit_native_pre(emit); @@ -1536,14 +1536,14 @@ STATIC void emit_native_build_tuple(emit_t *emit, int n_args) { 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, mp_uint_t n_args) { emit_native_pre(emit); emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items emit_call_with_imm_arg(emit, MP_F_BUILD_LIST, n_args, REG_ARG_1); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new list } -STATIC void emit_native_list_append(emit_t *emit, int list_index) { +STATIC void emit_native_list_append(emit_t *emit, mp_uint_t list_index) { // only used in list comprehension vtype_kind_t vtype_list, vtype_item; emit_pre_pop_reg(emit, &vtype_item, REG_ARG_2); @@ -1554,7 +1554,7 @@ STATIC void emit_native_list_append(emit_t *emit, int list_index) { emit_post(emit); } -STATIC void emit_native_build_map(emit_t *emit, int n_args) { +STATIC void emit_native_build_map(emit_t *emit, mp_uint_t n_args) { emit_native_pre(emit); emit_call_with_imm_arg(emit, MP_F_BUILD_MAP, n_args, REG_ARG_1); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new map @@ -1570,7 +1570,7 @@ STATIC void emit_native_store_map(emit_t *emit) { emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // map } -STATIC void emit_native_map_add(emit_t *emit, int map_index) { +STATIC void emit_native_map_add(emit_t *emit, mp_uint_t map_index) { // only used in list comprehension vtype_kind_t vtype_map, vtype_key, vtype_value; emit_pre_pop_reg_reg(emit, &vtype_key, REG_ARG_2, &vtype_value, REG_ARG_3); @@ -1582,14 +1582,14 @@ STATIC void emit_native_map_add(emit_t *emit, int map_index) { emit_post(emit); } -STATIC void emit_native_build_set(emit_t *emit, int n_args) { +STATIC void emit_native_build_set(emit_t *emit, mp_uint_t n_args) { emit_native_pre(emit); emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items emit_call_with_imm_arg(emit, MP_F_BUILD_SET, n_args, REG_ARG_1); emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new set } -STATIC void emit_native_set_add(emit_t *emit, int set_index) { +STATIC void emit_native_set_add(emit_t *emit, mp_uint_t set_index) { // only used in set comprehension vtype_kind_t vtype_set, vtype_item; emit_pre_pop_reg(emit, &vtype_item, REG_ARG_2); @@ -1600,7 +1600,7 @@ STATIC void emit_native_set_add(emit_t *emit, int set_index) { emit_post(emit); } -STATIC void emit_native_build_slice(emit_t *emit, int n_args) { +STATIC void emit_native_build_slice(emit_t *emit, mp_uint_t n_args) { DEBUG_printf("build_slice %d\n", n_args); if (n_args == 2) { vtype_kind_t vtype_start, vtype_stop; @@ -1621,7 +1621,7 @@ STATIC void emit_native_build_slice(emit_t *emit, int n_args) { } } -STATIC void emit_native_unpack_sequence(emit_t *emit, int n_args) { +STATIC void emit_native_unpack_sequence(emit_t *emit, mp_uint_t n_args) { DEBUG_printf("unpack_sequence %d\n", n_args); vtype_kind_t vtype_base; emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = seq @@ -1630,7 +1630,7 @@ STATIC void emit_native_unpack_sequence(emit_t *emit, int n_args) { emit_call_with_imm_arg(emit, MP_F_UNPACK_SEQUENCE, n_args, REG_ARG_2); // arg2 = n_args } -STATIC void emit_native_unpack_ex(emit_t *emit, int n_left, int n_right) { +STATIC void emit_native_unpack_ex(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right) { DEBUG_printf("unpack_ex %d %d\n", n_left, n_right); vtype_kind_t vtype_base; emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = seq @@ -1639,7 +1639,7 @@ STATIC void emit_native_unpack_ex(emit_t *emit, int n_left, int n_right) { emit_call_with_imm_arg(emit, MP_F_UNPACK_EX, n_left | (n_right << 8), REG_ARG_2); // arg2 = n_left + n_right } -STATIC void emit_native_make_function(emit_t *emit, scope_t *scope, uint n_pos_defaults, uint n_kw_defaults) { +STATIC void emit_native_make_function(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) { // call runtime, with type info for args, or don't support dict/default params, or only support Python objects for them emit_native_pre(emit); if (n_pos_defaults == 0 && n_kw_defaults == 0) { @@ -1654,11 +1654,11 @@ STATIC void emit_native_make_function(emit_t *emit, scope_t *scope, uint n_pos_d emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } -STATIC void emit_native_make_closure(emit_t *emit, scope_t *scope, uint n_closed_over, uint n_pos_defaults, uint n_kw_defaults) { +STATIC void emit_native_make_closure(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) { assert(0); } -STATIC void emit_native_call_function(emit_t *emit, int n_positional, int n_keyword, uint star_flags) { +STATIC void emit_native_call_function(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) { // call special viper runtime routine with type info for args, and wanted type info for return assert(!star_flags); @@ -1697,7 +1697,7 @@ STATIC void emit_native_call_function(emit_t *emit, int n_positional, int n_keyw emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); } -STATIC void emit_native_call_method(emit_t *emit, int n_positional, int n_keyword, uint star_flags) { +STATIC void emit_native_call_method(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) { assert(!star_flags); /* @@ -1743,7 +1743,7 @@ STATIC void emit_native_return_value(emit_t *emit) { ASM_EXIT(emit->as); } -STATIC void emit_native_raise_varargs(emit_t *emit, int n_args) { +STATIC void emit_native_raise_varargs(emit_t *emit, mp_uint_t n_args) { assert(n_args == 1); vtype_kind_t vtype_exc; emit_pre_pop_reg(emit, &vtype_exc, REG_ARG_1); // arg1 = object to raise diff --git a/py/emitpass1.c b/py/emitpass1.c index b39597318..601feb7fd 100644 --- a/py/emitpass1.c +++ b/py/emitpass1.c @@ -67,13 +67,13 @@ STATIC bool emit_pass1_last_emit_was_return_value(emit_t *emit) { return false; } -STATIC void emit_pass1_load_id(emit_t *emit, qstr qstr) { +STATIC void emit_pass1_load_id(emit_t *emit, qstr qst) { // name adding/lookup bool added; - id_info_t *id = scope_find_or_add_id(emit->scope, qstr, &added); + id_info_t *id = scope_find_or_add_id(emit->scope, qst, &added); if (added) { #if MICROPY_EMIT_CPYTHON - if (qstr == MP_QSTR_super && emit->scope->kind == SCOPE_FUNCTION) { + if (qst == MP_QSTR_super && emit->scope->kind == SCOPE_FUNCTION) { // special case, super is a global, and also counts as use of __class__ id->kind = ID_INFO_KIND_GLOBAL_EXPLICIT; id_info_t *id2 = scope_find_local_in_parent(emit->scope, MP_QSTR___class__); @@ -87,10 +87,10 @@ STATIC void emit_pass1_load_id(emit_t *emit, qstr qstr) { } else #endif { - id_info_t *id2 = scope_find_local_in_parent(emit->scope, qstr); + id_info_t *id2 = scope_find_local_in_parent(emit->scope, qst); if (id2 != NULL && (id2->kind == ID_INFO_KIND_LOCAL || id2->kind == ID_INFO_KIND_CELL || id2->kind == ID_INFO_KIND_FREE)) { id->kind = ID_INFO_KIND_FREE; - scope_close_over_in_parents(emit->scope, qstr); + scope_close_over_in_parents(emit->scope, qst); } else { id->kind = ID_INFO_KIND_GLOBAL_IMPLICIT; } @@ -98,10 +98,10 @@ STATIC void emit_pass1_load_id(emit_t *emit, qstr qstr) { } } -STATIC id_info_t *get_id_for_modification(scope_t *scope, qstr qstr) { +STATIC id_info_t *get_id_for_modification(scope_t *scope, qstr qst) { // name adding/lookup bool added; - id_info_t *id = scope_find_or_add_id(scope, qstr, &added); + id_info_t *id = scope_find_or_add_id(scope, qst, &added); if (added) { if (scope->kind == SCOPE_MODULE || scope->kind == SCOPE_CLASS) { id->kind = ID_INFO_KIND_GLOBAL_IMPLICIT; @@ -118,12 +118,12 @@ STATIC id_info_t *get_id_for_modification(scope_t *scope, qstr qstr) { return id; } -STATIC void emit_pass1_store_id(emit_t *emit, qstr qstr) { - get_id_for_modification(emit->scope, qstr); +STATIC void emit_pass1_store_id(emit_t *emit, qstr qst) { + get_id_for_modification(emit->scope, qst); } -STATIC void emit_pass1_delete_id(emit_t *emit, qstr qstr) { - id_info_t *id = get_id_for_modification(emit->scope, qstr); +STATIC void emit_pass1_delete_id(emit_t *emit, qstr qst) { + id_info_t *id = get_id_for_modification(emit->scope, qst); // this flag is unused //id->flags |= ID_FLAG_IS_DELETED; (void)id; // suppress compiler warning diff --git a/py/scope.c b/py/scope.c index c6b8636be..d55099fec 100644 --- a/py/scope.c +++ b/py/scope.c @@ -82,8 +82,8 @@ void scope_free(scope_t *scope) { m_del(scope_t, scope, 1); } -id_info_t *scope_find_or_add_id(scope_t *scope, qstr qstr, bool *added) { - id_info_t *id_info = scope_find(scope, qstr); +id_info_t *scope_find_or_add_id(scope_t *scope, qstr qst, bool *added) { + id_info_t *id_info = scope_find(scope, qst); if (id_info != NULL) { *added = false; return id_info; @@ -103,33 +103,33 @@ id_info_t *scope_find_or_add_id(scope_t *scope, qstr qstr, bool *added) { id_info->kind = 0; id_info->flags = 0; id_info->local_num = 0; - id_info->qstr = qstr; + id_info->qst = qst; *added = true; return id_info; } -id_info_t *scope_find(scope_t *scope, qstr qstr) { +id_info_t *scope_find(scope_t *scope, qstr qst) { for (mp_uint_t i = 0; i < scope->id_info_len; i++) { - if (scope->id_info[i].qstr == qstr) { + if (scope->id_info[i].qst == qst) { return &scope->id_info[i]; } } return NULL; } -id_info_t *scope_find_global(scope_t *scope, qstr qstr) { +id_info_t *scope_find_global(scope_t *scope, qstr qst) { while (scope->parent != NULL) { scope = scope->parent; } - return scope_find(scope, qstr); + return scope_find(scope, qst); } -id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qstr) { +id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qst) { if (scope->parent == NULL) { return NULL; } for (scope_t *s = scope->parent; s->parent != NULL; s = s->parent) { - id_info_t *id = scope_find(s, qstr); + id_info_t *id = scope_find(s, qst); if (id != NULL) { return id; } @@ -137,11 +137,11 @@ id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qstr) { return NULL; } -void scope_close_over_in_parents(scope_t *scope, qstr qstr) { +void scope_close_over_in_parents(scope_t *scope, qstr qst) { assert(scope->parent != NULL); // we should have at least 1 parent for (scope_t *s = scope->parent; s->parent != NULL; s = s->parent) { bool added; - id_info_t *id = scope_find_or_add_id(s, qstr, &added); + id_info_t *id = scope_find_or_add_id(s, qst, &added); if (added) { // variable not previously declared in this scope, so declare it as free and keep searching parents id->kind = ID_INFO_KIND_FREE; @@ -159,13 +159,13 @@ void scope_close_over_in_parents(scope_t *scope, qstr qstr) { assert(0); // we should have found the variable in one of the parents } -void scope_declare_global(scope_t *scope, qstr qstr) { +void scope_declare_global(scope_t *scope, qstr qst) { if (scope->kind == SCOPE_MODULE) { printf("SyntaxError?: can't declare global in outer code\n"); return; } bool added; - id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added); + id_info_t *id_info = scope_find_or_add_id(scope, qst, &added); if (!added) { printf("SyntaxError?: identifier already declared something\n"); return; @@ -173,30 +173,30 @@ void scope_declare_global(scope_t *scope, qstr qstr) { id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT; // if the id exists in the global scope, set its kind to EXPLICIT_GLOBAL - id_info = scope_find_global(scope, qstr); + id_info = scope_find_global(scope, qst); if (id_info != NULL) { id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT; } } -void scope_declare_nonlocal(scope_t *scope, qstr qstr) { +void scope_declare_nonlocal(scope_t *scope, qstr qst) { if (scope->kind == SCOPE_MODULE) { printf("SyntaxError?: can't declare nonlocal in outer code\n"); return; } bool added; - id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added); + id_info_t *id_info = scope_find_or_add_id(scope, qst, &added); if (!added) { printf("SyntaxError?: identifier already declared something\n"); return; } - id_info_t *id_info2 = scope_find_local_in_parent(scope, qstr); + id_info_t *id_info2 = scope_find_local_in_parent(scope, qst); if (id_info2 == NULL || !(id_info2->kind == ID_INFO_KIND_LOCAL || id_info2->kind == ID_INFO_KIND_CELL || id_info2->kind == ID_INFO_KIND_FREE)) { - printf("SyntaxError: no binding for nonlocal '%s' found\n", qstr_str(qstr)); + printf("SyntaxError: no binding for nonlocal '%s' found\n", qstr_str(qst)); return; } id_info->kind = ID_INFO_KIND_FREE; - scope_close_over_in_parents(scope, qstr); + scope_close_over_in_parents(scope, qst); } #if MICROPY_EMIT_CPYTHON @@ -220,28 +220,28 @@ void scope_print_info(scope_t *s) { printf("var global:"); for (int i = 0; i < s->id_info_len; i++) { if (s->id_info[i].kind == ID_INFO_KIND_GLOBAL_EXPLICIT) { - printf(" %s", qstr_str(s->id_info[i].qstr)); + printf(" %s", qstr_str(s->id_info[i].qst)); } } printf("\n"); printf("var name:"); for (int i = 0; i < s->id_info_len; i++) { if (s->id_info[i].kind == ID_INFO_KIND_GLOBAL_IMPLICIT) { - printf(" %s", qstr_str(s->id_info[i].qstr)); + printf(" %s", qstr_str(s->id_info[i].qst)); } } printf("\n"); printf("var local:"); for (int i = 0; i < s->id_info_len; i++) { if (s->id_info[i].kind == ID_INFO_KIND_LOCAL) { - printf(" %s", qstr_str(s->id_info[i].qstr)); + printf(" %s", qstr_str(s->id_info[i].qst)); } } printf("\n"); printf("var free:"); for (int i = 0; i < s->id_info_len; i++) { if (s->id_info[i].kind == ID_INFO_KIND_FREE) { - printf(" %s", qstr_str(s->id_info[i].qstr)); + printf(" %s", qstr_str(s->id_info[i].qst)); } } printf("\n"); diff --git a/py/scope.h b/py/scope.h index 80834d936..4aa353851 100644 --- a/py/scope.h +++ b/py/scope.h @@ -44,7 +44,7 @@ typedef struct _id_info_t { // when it's an ID_INFO_KIND_LOCAL this is the unique number of the local // whet it's an ID_INFO_KIND_CELL/FREE this is the unique number of the closed over variable uint16_t local_num; - qstr qstr; + qstr qst; } id_info_t; // scope is a "block" in Python parlance