Skip to content

GitLab

Commit 3417bc2f authored by Damien George's avatar Damien George
Browse files

py: Rename byte_code to bytecode everywhere. 

bytecode is the more widely used.  See issue #590.
parent 6e8085b4
Hide whitespace changes
Inline Side-by-side
examples/micropython.py
View file @ 3417bc2f
......@@ -5,4 +5,4 @@
def nodecor(x):
return x
byte_code = native = viper = nodecor
bytecode = native = viper = nodecor
py/bc.h
View file @ 3417bc2f
......@@ -36,10 +36,10 @@ typedef struct _mp_exc_stack {
byte opcode;
} mp_exc_stack_t;
mp_vm_return_kind_t mp_execute_byte_code(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret);
mp_vm_return_kind_t mp_execute_byte_code_2(const byte *code_info, const byte **ip_in_out, mp_obj_t *fastn, mp_obj_t **sp_in_out, mp_exc_stack_t *exc_stack, mp_exc_stack_t **exc_sp_in_out, volatile mp_obj_t inject_exc);
void mp_byte_code_print(const byte *code, int len);
void mp_byte_code_print2(const byte *code, int len);
mp_vm_return_kind_t mp_execute_bytecode(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret);
mp_vm_return_kind_t mp_execute_bytecode2(const byte *code_info, const byte **ip_in_out, mp_obj_t *fastn, mp_obj_t **sp_in_out, mp_exc_stack_t *exc_stack, mp_exc_stack_t **exc_sp_in_out, volatile mp_obj_t inject_exc);
void mp_bytecode_print(const byte *code, int len);
void mp_bytecode_print2(const byte *code, int len);
// Helper macros to access pointer with least significant bit holding a flag
#define MP_TAGPTR_PTR(x) ((void*)((machine_uint_t)(x) & ~((machine_uint_t)1)))
......
py/compile.c
View file @ 3417bc2f
......@@ -1146,7 +1146,7 @@ STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_
}
qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
if (attr == MP_QSTR_byte_code) {
if (attr == MP_QSTR_bytecode) {
*emit_options = MP_EMIT_OPT_BYTE_CODE;
#if MICROPY_EMIT_NATIVE
} else if (attr == MP_QSTR_native) {
......
py/emitbc.c
View file @ 3417bc2f
......@@ -59,8 +59,8 @@ struct _emit_t {
uint code_info_offset;
uint code_info_size;
uint byte_code_offset;
uint byte_code_size;
uint bytecode_offset;
uint bytecode_size;
byte *code_base; // stores both byte code and code info
byte dummy_data[8];
};
......@@ -121,36 +121,36 @@ STATIC void emit_write_code_info_bytes_lines(emit_t* emit, uint bytes_to_skip, u
#endif
// all functions must go through this one to emit byte code
STATIC byte* emit_get_cur_to_write_byte_code(emit_t* emit, int num_bytes_to_write) {
STATIC byte* emit_get_cur_to_write_bytecode(emit_t* emit, int num_bytes_to_write) {
//printf("emit %d\n", num_bytes_to_write);
if (emit->pass < MP_PASS_EMIT) {
emit->byte_code_offset += num_bytes_to_write;
emit->bytecode_offset += num_bytes_to_write;
return emit->dummy_data;
} else {
assert(emit->byte_code_offset + num_bytes_to_write <= emit->byte_code_size);
byte *c = emit->code_base + emit->code_info_size + emit->byte_code_offset;
emit->byte_code_offset += num_bytes_to_write;
assert(emit->bytecode_offset + num_bytes_to_write <= emit->bytecode_size);
byte *c = emit->code_base + emit->code_info_size + emit->bytecode_offset;
emit->bytecode_offset += num_bytes_to_write;
return c;
}
}
STATIC void emit_align_byte_code_to_machine_word(emit_t* emit) {
emit->byte_code_offset = (emit->byte_code_offset + sizeof(machine_uint_t) - 1) & (~(sizeof(machine_uint_t) - 1));
STATIC void emit_align_bytecode_to_machine_word(emit_t* emit) {
emit->bytecode_offset = (emit->bytecode_offset + sizeof(machine_uint_t) - 1) & (~(sizeof(machine_uint_t) - 1));
}
STATIC void emit_write_byte_code_byte(emit_t* emit, byte b1) {
byte* c = emit_get_cur_to_write_byte_code(emit, 1);
STATIC void emit_write_bytecode_byte(emit_t* emit, byte b1) {
byte* c = emit_get_cur_to_write_bytecode(emit, 1);
c[0] = b1;
}
STATIC void emit_write_byte_code_byte_byte(emit_t* emit, byte b1, uint b2) {
STATIC void emit_write_bytecode_byte_byte(emit_t* emit, byte b1, uint b2) {
assert((b2 & (~0xff)) == 0);
byte* c = emit_get_cur_to_write_byte_code(emit, 2);
byte* c = emit_get_cur_to_write_bytecode(emit, 2);
c[0] = b1;
c[1] = b2;
}
STATIC void emit_write_byte_code_uint(emit_t* emit, uint num) {
STATIC void emit_write_bytecode_uint(emit_t* emit, uint num) {
// We store each 7 bits in a separate byte, and that's how many bytes needed
byte buf[(BYTES_PER_WORD * 8 + 6) / 7];
byte *p = buf + sizeof(buf);
......@@ -159,16 +159,16 @@ STATIC void emit_write_byte_code_uint(emit_t* emit, uint num) {
*--p = num & 0x7f;
num >>= 7;
} while (num != 0);
byte* c = emit_get_cur_to_write_byte_code(emit, buf + sizeof(buf) - p);
byte* c = emit_get_cur_to_write_bytecode(emit, buf + sizeof(buf) - p);
while (p != buf + sizeof(buf) - 1) {
*c++ = *p++ | 0x80;
}
*c = *p;
}
// Similar to emit_write_byte_code_uint(), just some extra handling to encode sign
STATIC void emit_write_byte_code_byte_int(emit_t* emit, byte b1, machine_int_t num) {
emit_write_byte_code_byte(emit, b1);
// Similar to emit_write_bytecode_uint(), just some extra handling to encode sign
STATIC void emit_write_bytecode_byte_int(emit_t* emit, byte b1, machine_int_t num) {
emit_write_bytecode_byte(emit, b1);
// We store each 7 bits in a separate byte, and that's how many bytes needed
byte buf[(BYTES_PER_WORD * 8 + 6) / 7];
......@@ -186,64 +186,64 @@ STATIC void emit_write_byte_code_byte_int(emit_t* emit, byte b1, machine_int_t n
*--p = 0;
}
byte* c = emit_get_cur_to_write_byte_code(emit, buf + sizeof(buf) - p);
byte* c = emit_get_cur_to_write_bytecode(emit, buf + sizeof(buf) - p);
while (p != buf + sizeof(buf) - 1) {
*c++ = *p++ | 0x80;
}
*c = *p;
}
STATIC void emit_write_byte_code_byte_uint(emit_t* emit, byte b, uint num) {
emit_write_byte_code_byte(emit, b);
emit_write_byte_code_uint(emit, num);
STATIC void emit_write_bytecode_byte_uint(emit_t* emit, byte b, uint num) {
emit_write_bytecode_byte(emit, b);
emit_write_bytecode_uint(emit, num);
}
// aligns the pointer so it is friendly to GC
STATIC void emit_write_byte_code_byte_ptr(emit_t* emit, byte b, void *ptr) {
emit_write_byte_code_byte(emit, b);
emit_align_byte_code_to_machine_word(emit);
machine_uint_t *c = (machine_uint_t*)emit_get_cur_to_write_byte_code(emit, sizeof(machine_uint_t));
STATIC void emit_write_bytecode_byte_ptr(emit_t* emit, byte b, void *ptr) {
emit_write_bytecode_byte(emit, b);
emit_align_bytecode_to_machine_word(emit);
machine_uint_t *c = (machine_uint_t*)emit_get_cur_to_write_bytecode(emit, sizeof(machine_uint_t));
*c = (machine_uint_t)ptr;
}
/* currently unused
STATIC void emit_write_byte_code_byte_uint_uint(emit_t* emit, byte b, uint num1, uint num2) {
emit_write_byte_code_byte(emit, b);
emit_write_byte_code_byte_uint(emit, num1);
emit_write_byte_code_byte_uint(emit, num2);
STATIC void emit_write_bytecode_byte_uint_uint(emit_t* emit, byte b, uint num1, uint 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_byte_code_byte_qstr(emit_t* emit, byte b, qstr qstr) {
emit_write_byte_code_byte_uint(emit, b, qstr);
STATIC void emit_write_bytecode_byte_qstr(emit_t* emit, byte b, qstr qstr) {
emit_write_bytecode_byte_uint(emit, b, qstr);
}
// unsigned labels are relative to ip following this instruction, stored as 16 bits
STATIC void emit_write_byte_code_byte_unsigned_label(emit_t* emit, byte b1, uint label) {
uint byte_code_offset;
STATIC void emit_write_bytecode_byte_unsigned_label(emit_t* emit, byte b1, uint label) {
uint bytecode_offset;
if (emit->pass < MP_PASS_EMIT) {
byte_code_offset = 0;
bytecode_offset = 0;
} else {
byte_code_offset = emit->label_offsets[label] - emit->byte_code_offset - 3;
bytecode_offset = emit->label_offsets[label] - emit->bytecode_offset - 3;
}
byte *c = emit_get_cur_to_write_byte_code(emit, 3);
byte *c = emit_get_cur_to_write_bytecode(emit, 3);
c[0] = b1;
c[1] = byte_code_offset;
c[2] = byte_code_offset >> 8;
c[1] = bytecode_offset;
c[2] = bytecode_offset >> 8;
}
// signed labels are relative to ip following this instruction, stored as 16 bits, in excess
STATIC void emit_write_byte_code_byte_signed_label(emit_t* emit, byte b1, uint label) {
int byte_code_offset;
STATIC void emit_write_bytecode_byte_signed_label(emit_t* emit, byte b1, uint label) {
int bytecode_offset;
if (emit->pass < MP_PASS_EMIT) {
byte_code_offset = 0;
bytecode_offset = 0;
} else {
byte_code_offset = emit->label_offsets[label] - emit->byte_code_offset - 3 + 0x8000;
bytecode_offset = emit->label_offsets[label] - emit->bytecode_offset - 3 + 0x8000;
}
byte* c = emit_get_cur_to_write_byte_code(emit, 3);
byte* c = emit_get_cur_to_write_bytecode(emit, 3);
c[0] = b1;
c[1] = byte_code_offset;
c[2] = byte_code_offset >> 8;
c[1] = bytecode_offset;
c[2] = bytecode_offset >> 8;
}
STATIC void emit_bc_set_native_types(emit_t *emit, bool do_native_types) {
......@@ -259,7 +259,7 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
if (pass < MP_PASS_EMIT) {
memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(uint));
}
emit->byte_code_offset = 0;
emit->bytecode_offset = 0;
emit->code_info_offset = 0;
// write code info size; use maximum space (4 bytes) to write it; TODO possible optimise this
......@@ -278,7 +278,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
{
byte* c = emit_get_cur_to_write_byte_code(emit, 4);
byte* c = emit_get_cur_to_write_bytecode(emit, 4);
uint 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
......@@ -301,11 +301,11 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
}
}
assert(num_cell <= 255);
emit_write_byte_code_byte(emit, num_cell); // write number of locals that are cells
emit_write_bytecode_byte(emit, num_cell); // write number of locals that are cells
for (int i = 0; i < scope->id_info_len; i++) {
id_info_t *id = &scope->id_info[i];
if (id->kind == ID_INFO_KIND_CELL) {
emit_write_byte_code_byte(emit, id->local_num); // write the local which should be converted to a cell
emit_write_bytecode_byte(emit, id->local_num); // write the local which should be converted to a cell
}
}
}
......@@ -317,21 +317,21 @@ STATIC void emit_bc_end_pass(emit_t *emit) {
}
*emit_get_cur_to_write_code_info(emit, 1) = 0; // end of line number info
emit_align_code_info_to_machine_word(emit); // align so that following byte_code is aligned
emit_align_code_info_to_machine_word(emit); // align so that following bytecode is aligned
if (emit->pass == MP_PASS_CODE_SIZE) {
// calculate size of code in bytes
emit->code_info_size = emit->code_info_offset;
emit->byte_code_size = emit->byte_code_offset;
emit->code_base = m_new0(byte, emit->code_info_size + emit->byte_code_size);
emit->bytecode_size = emit->bytecode_offset;
emit->code_base = m_new0(byte, emit->code_info_size + emit->bytecode_size);
} 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;
}
mp_emit_glue_assign_byte_code(emit->scope->raw_code, emit->code_base,
emit->code_info_size + emit->byte_code_size,
mp_emit_glue_assign_bytecode(emit->scope->raw_code, emit->code_base,
emit->code_info_size + emit->bytecode_size,
emit->scope->num_pos_args, emit->scope->num_kwonly_args, arg_names,
emit->scope->scope_flags);
}
......@@ -346,14 +346,14 @@ STATIC void emit_bc_adjust_stack_size(emit_t *emit, int delta) {
}
STATIC void emit_bc_set_source_line(emit_t *emit, int source_line) {
//printf("source: line %d -> %d offset %d -> %d\n", emit->last_source_line, source_line, emit->last_source_line_offset, emit->byte_code_offset);
//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 (source_line > emit->last_source_line) {
uint bytes_to_skip = emit->byte_code_offset - emit->last_source_line_offset;
uint bytes_to_skip = emit->bytecode_offset - emit->last_source_line_offset;
uint lines_to_skip = source_line - emit->last_source_line;
emit_write_code_info_bytes_lines(emit, bytes_to_skip, lines_to_skip);
//printf(" %d %d\n", bytes_to_skip, lines_to_skip);
emit->last_source_line_offset = emit->byte_code_offset;
emit->last_source_line_offset = emit->bytecode_offset;
emit->last_source_line = source_line;
}
#endif
......@@ -386,167 +386,167 @@ STATIC void emit_bc_label_assign(emit_t *emit, uint l) {
if (emit->pass < MP_PASS_EMIT) {
// assign label offset
assert(emit->label_offsets[l] == -1);
emit->label_offsets[l] = emit->byte_code_offset;
emit->label_offsets[l] = emit->bytecode_offset;
} else {
// ensure label offset has not changed from MP_PASS_CODE_SIZE to MP_PASS_EMIT
//printf("l%d: (at %d vs %d)\n", l, emit->byte_code_offset, emit->label_offsets[l]);
assert(emit->label_offsets[l] == emit->byte_code_offset);
//printf("l%d: (at %d vs %d)\n", l, emit->bytecode_offset, emit->label_offsets[l]);
assert(emit->label_offsets[l] == emit->bytecode_offset);
}
}
STATIC void emit_bc_import_name(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_qstr(emit, MP_BC_IMPORT_NAME, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_NAME, qstr);
}
STATIC void emit_bc_import_from(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_qstr(emit, MP_BC_IMPORT_FROM, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_FROM, qstr);
}
STATIC void emit_bc_import_star(emit_t *emit) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte(emit, MP_BC_IMPORT_STAR);
emit_write_bytecode_byte(emit, MP_BC_IMPORT_STAR);
}
STATIC void emit_bc_load_const_tok(emit_t *emit, mp_token_kind_t tok) {
emit_bc_pre(emit, 1);
switch (tok) {
case MP_TOKEN_KW_FALSE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_FALSE); break;
case MP_TOKEN_KW_NONE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_NONE); break;
case MP_TOKEN_KW_TRUE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_TRUE); break;
case MP_TOKEN_ELLIPSIS: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_ELLIPSIS); break;
case MP_TOKEN_KW_FALSE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_FALSE); break;
case MP_TOKEN_KW_NONE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_NONE); break;
case MP_TOKEN_KW_TRUE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_TRUE); break;
case MP_TOKEN_ELLIPSIS: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_ELLIPSIS); break;
default: assert(0);
}
}
STATIC void emit_bc_load_const_small_int(emit_t *emit, machine_int_t arg) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_int(emit, MP_BC_LOAD_CONST_SMALL_INT, 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) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qstr);
}
STATIC void emit_bc_load_const_dec(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr);
}
STATIC void emit_bc_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
emit_bc_pre(emit, 1);
if (bytes) {
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr);
} else {
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr);
}
}
STATIC void emit_bc_load_null(emit_t *emit) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte(emit, MP_BC_LOAD_NULL);
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) {
assert(local_num >= 0);
emit_bc_pre(emit, 1);
switch (local_num) {
case 0: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_0); break;
case 1: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_1); break;
case 2: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_2); break;
default: emit_write_byte_code_byte_uint(emit, MP_BC_LOAD_FAST_N, local_num); break;
case 0: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_0); break;
case 1: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_1); break;
case 2: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_2); break;
default: emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_FAST_N, local_num); break;
}
}
STATIC void emit_bc_load_deref(emit_t *emit, qstr qstr, int local_num) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_uint(emit, MP_BC_LOAD_DEREF, local_num);
emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_DEREF, local_num);
}
STATIC void emit_bc_load_name(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_NAME, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_NAME, qstr);
}
STATIC void emit_bc_load_global(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qstr);
}
STATIC void emit_bc_load_attr(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_ATTR, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_ATTR, qstr);
}
STATIC void emit_bc_load_method(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_METHOD, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_METHOD, qstr);
}
STATIC void emit_bc_load_build_class(emit_t *emit) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte(emit, MP_BC_LOAD_BUILD_CLASS);
emit_write_bytecode_byte(emit, MP_BC_LOAD_BUILD_CLASS);
}
STATIC void emit_bc_load_subscr(emit_t *emit) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte(emit, MP_BC_LOAD_SUBSCR);
emit_write_bytecode_byte(emit, MP_BC_LOAD_SUBSCR);
}
STATIC void emit_bc_store_fast(emit_t *emit, qstr qstr, int local_num) {
assert(local_num >= 0);
emit_bc_pre(emit, -1);
switch (local_num) {
case 0: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_0); break;
case 1: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_1); break;
case 2: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_2); break;
default: emit_write_byte_code_byte_uint(emit, MP_BC_STORE_FAST_N, local_num); break;
case 0: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_0); break;
case 1: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_1); break;
case 2: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_2); break;
default: emit_write_bytecode_byte_uint(emit, MP_BC_STORE_FAST_N, local_num); break;
}
}
STATIC void emit_bc_store_deref(emit_t *emit, qstr qstr, int local_num) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_uint(emit, MP_BC_STORE_DEREF, local_num);
emit_write_bytecode_byte_uint(emit, MP_BC_STORE_DEREF, local_num);
}
STATIC void emit_bc_store_name(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_NAME, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_NAME, qstr);
}
STATIC void emit_bc_store_global(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_GLOBAL, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_GLOBAL, qstr);
}
STATIC void emit_bc_store_attr(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, -2);
emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_ATTR, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_ATTR, qstr);
}
STATIC void emit_bc_store_subscr(emit_t *emit) {
emit_bc_pre(emit, -3);
emit_write_byte_code_byte(emit, MP_BC_STORE_SUBSCR);
emit_write_bytecode_byte(emit, MP_BC_STORE_SUBSCR);
}
STATIC void emit_bc_delete_fast(emit_t *emit, qstr qstr, int local_num) {
emit_write_byte_code_byte_uint(emit, MP_BC_DELETE_FAST, 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) {
emit_write_byte_code_byte_uint(emit, MP_BC_DELETE_DEREF, 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) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte_qstr(emit, MP_BC_DELETE_NAME, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_NAME, qstr);
}
STATIC void emit_bc_delete_global(emit_t *emit, qstr qstr) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qstr);
emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qstr);
}
STATIC void emit_bc_delete_attr(emit_t *emit, qstr qstr) {
......@@ -563,52 +563,52 @@ STATIC void emit_bc_delete_subscr(emit_t *emit) {
STATIC void emit_bc_dup_top(emit_t *emit) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte(emit, MP_BC_DUP_TOP);
emit_write_bytecode_byte(emit, MP_BC_DUP_TOP);
}
STATIC void emit_bc_dup_top_two(emit_t *emit) {
emit_bc_pre(emit, 2);
emit_write_byte_code_byte(emit, MP_BC_DUP_TOP_TWO);
emit_write_bytecode_byte(emit, MP_BC_DUP_TOP_TWO);
}
STATIC void emit_bc_pop_top(emit_t *emit) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte(emit, MP_BC_POP_TOP);
emit_write_bytecode_byte(emit, MP_BC_POP_TOP);
}
STATIC void emit_bc_rot_two(emit_t *emit) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte(emit, MP_BC_ROT_TWO);
emit_write_bytecode_byte(emit, MP_BC_ROT_TWO);
}
STATIC void emit_bc_rot_three(emit_t *emit) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte(emit, MP_BC_ROT_THREE);
emit_write_bytecode_byte(emit, MP_BC_ROT_THREE);
}
STATIC void emit_bc_jump(emit_t *emit, uint label) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP, label);
emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP, label);
}
STATIC void emit_bc_pop_jump_if_true(emit_t *emit, uint label) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label);
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) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label);
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) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label);
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) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label);
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) {
......@@ -616,44 +616,44 @@ STATIC void emit_bc_unwind_jump(emit_t *emit, uint label, int except_depth) {
emit_bc_jump(emit, label);
} else {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte_signed_label(emit, MP_BC_UNWIND_JUMP, label);
emit_write_byte_code_byte(emit, except_depth);
emit_write_bytecode_byte_signed_label(emit, MP_BC_UNWIND_JUMP, label);
emit_write_bytecode_byte(emit, except_depth);
}
}
STATIC void emit_bc_setup_with(emit_t *emit, uint label) {
emit_bc_pre(emit, 7);
emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_WITH, label);
emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_WITH, label);
}
STATIC void emit_bc_with_cleanup(emit_t *emit) {
emit_bc_pre(emit, -7);
emit_write_byte_code_byte(emit, MP_BC_WITH_CLEANUP);
emit_write_bytecode_byte(emit, MP_BC_WITH_CLEANUP);
}
STATIC void emit_bc_setup_except(emit_t *emit, uint label) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label);
emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label);
}
STATIC void emit_bc_setup_finally(emit_t *emit, uint label) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_FINALLY, label);
emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_FINALLY, label);
}
STATIC void emit_bc_end_finally(emit_t *emit) {
emit_bc_pre(emit, -1);
emit_write_byte_code_byte(emit, MP_BC_END_FINALLY);
emit_write_bytecode_byte(emit, MP_BC_END_FINALLY);
}
STATIC void emit_bc_get_iter(emit_t *emit) {
emit_bc_pre(emit, 0);
emit_write_byte_code_byte(emit, MP_BC_GET_ITER);
emit_write_bytecode_byte(emit, MP_BC_GET_ITER);
}
STATIC void emit_bc_for_iter(emit_t *emit, uint label) {
emit_bc_pre(emit, 1);
emit_write_byte_code_byte_unsigned_label(emit, MP_BC_FOR_ITER, label);
emit_write_bytecode_byte_unsigned_label(emit, MP_BC_FOR_ITER, label);
}
STATIC void emit_bc_for_iter_end(emit_t *emit) {
......@@ -662,23 +662,23 @@ STATIC void emit_bc_for_iter_end(emit_t *emit) {
STATIC void emit_bc_pop_block(emit_t *emit) {
emit_bc_pre(emit, 0);