diff --git a/moo/kernel/Apex.moo b/moo/kernel/Apex.moo index 2b9d744..72ce83a 100644 --- a/moo/kernel/Apex.moo +++ b/moo/kernel/Apex.moo @@ -406,9 +406,16 @@ class UndefinedObject(Apex) pooldic ErrorCode { (* migrate it into Error class *) - #NONE := error(0). - #GENERIC := error(1). - #NOENT := error(2). + #NONE := error(0). + #GENERIC := error(1). + #NOIMPL := error(2). + #SYSERR := error(3). + #INTERN := error(4). + #SYSMEM := error(5). + #OOMEM := error(6). + #INVAL := error(7). + #NOENT := error(8). +(* add more items... *) } class Error(Apex) diff --git a/moo/kernel/Collect.moo b/moo/kernel/Collect.moo index 7bd4286..a8d5f28 100644 --- a/moo/kernel/Collect.moo +++ b/moo/kernel/Collect.moo @@ -514,4 +514,4 @@ extend Apex { ^Association new key: self value: object } -} \ No newline at end of file +} diff --git a/moo/kernel/Mill.moo b/moo/kernel/Mill.moo index a085bf2..ab5e7d8 100644 --- a/moo/kernel/Mill.moo +++ b/moo/kernel/Mill.moo @@ -39,7 +39,7 @@ dcl obj. class MyObject(Object) { - method(#class) main + method(#class) mainxx { | d a ffi | @@ -85,6 +85,7 @@ class MyObject(Object) ] on: Exception do: [:ex | ('Exception caught - ' & ex asString) dump ].*) ffi := FFI new: '/lib64/libc.so.6'. + (* (ffi isError) ifTrue: [System logNl: 'cannot open libc.so' ] ifFalse: [ @@ -92,6 +93,51 @@ class MyObject(Object) (ffi call: #printf signature: 's|iis)i' arguments: #(S'A=>%d B=>%d Hello, world %s\n' 1 2 'fly away')) dump. (ffi call: #printf signature: 's|iis)i' arguments: #(S'A=>%d B=>%d Hello, world %s\n' 1 2 'jump down')) dump. ffi close. - ] + ]. + *) + if (ffi isError) + { + System logNl: 'cannot open libc.so' + } + else + { + (ffi call: #getpid signature: ')i' arguments: nil) dump. + (ffi call: #printf signature: 's|iis)i' arguments: #(S'A=>%d B=>%d Hello, world %s\n' 1 2 'fly away')) dump. + (ffi call: #printf signature: 's|iis)i' arguments: #(S'A=>%d B=>%d Hello, world %s\n' 1 2 'jump down')) dump. + ffi close. + }. + (('abcd' == 'abcd') ifTrue: [1] ifFalse: [2]) dump. + + } + + method(#class) main + { + |a k| + a := + if ([System logNl: 'xxxx'. 'abcd' == 'bcde'. false] value) + { + System logNl: 'XXXXXXXXX'. + 1111 + } + elsif ('abcd' ~= 'abcd') + { + System logNl: 'second if'. + } + elsif ([k := 20. System logNl: 'k => ' & (k asString). k + 20. true] value) + { + System logNl: 'THIRID forever.............' & (k asString) + } + elsif (true = true) + { + System logNl: 'forever.............' + } + else + { + System logNl: 'NO MATCH'. + [true] value. + }. + + a dump. + System logNl: 'DONE DONE DONE...'. } } diff --git a/moo/lib/comp.c b/moo/lib/comp.c index 2569b3e..e4f6481 100644 --- a/moo/lib/comp.c +++ b/moo/lib/comp.c @@ -81,6 +81,8 @@ static struct voca_t { 10, { '#','c','l','a','s','s','i','n','s','t' } }, { 3, { 'd','c','l' } }, { 7, { 'd','e','c','l','a','r','e' } }, + { 4, { 'e','l','s','e' } }, + { 5, { 'e','l','s','i','f' } }, { 6, { 'e','n','s','u','r','e', } }, { 5, { 'e','r','r','o','r' } }, { 9, { 'e','x','c','e','p','t','i','o','n' } }, @@ -120,6 +122,8 @@ enum voca_id_t VOCA_CLASSINST_S, VOCA_DCL, VOCA_DECLARE, + VOCA_ELSE, + VOCA_ELSIF, VOCA_ENSURE, VOCA_ERROR, VOCA_EXCEPTION, @@ -986,6 +990,14 @@ static int get_ident (moo_t* moo, moo_ooci_t char_read_ahead) { SET_TOKEN_TYPE (moo, MOO_IOTOK_IF); } + else if (is_token_word(moo, VOCA_ELSE)) + { + SET_TOKEN_TYPE (moo, MOO_IOTOK_ELSE); + } + else if (is_token_word(moo, VOCA_ELSIF)) + { + SET_TOKEN_TYPE (moo, MOO_IOTOK_ELSIF); + } } return 0; @@ -1867,8 +1879,8 @@ static int emit_single_param_instruction (moo_t* moo, int cmd, moo_oow_t param_1 case BCODE_POP_INTO_OBJECT_0: case BCODE_JUMP_FORWARD_0: case BCODE_JUMP_BACKWARD_0: - case BCODE_JUMP_IF_TRUE_0: - case BCODE_JUMP_IF_FALSE_0: + case BCODE_JUMP_FORWARD_IF_FALSE_0: + case BCODE_JUMP_BACKWARD_IF_FALSE_0: if (param_1 < 4) { /* low 2 bits to hold the parameter */ @@ -3257,12 +3269,49 @@ static int store_tmpr_count_for_block (moo_t* moo, moo_oow_t tmpr_count) return 0; } + +static int patch_jump_instruction (moo_t* moo, moo_oow_t jip, moo_oob_t jump2_inst, moo_ioloc_t* errloc) +{ + moo_oow_t code_size; + moo_oow_t jump_offset; + + /* MOO_BCODE_LONG_PARAM_SIZE + 1 => size of the long JUMP_FORWARD instruction */ + code_size = moo->c->mth.code.len - jip - (MOO_BCODE_LONG_PARAM_SIZE + 1); + if (code_size > MAX_CODE_JUMP * 2) + { + /* TODO: accept the location and pass it to set_syntax_error. + * change error code or get it as a parameter */ + set_syntax_error (moo, MOO_SYNERR_BLKFLOOD, errloc, MOO_NULL); + return -1; + } + + if (code_size > MAX_CODE_JUMP) + { + /* switch to JUMP2 instruction to allow a bigger jump offset. + * up to twice MAX_CODE_JUMP only */ + moo->c->mth.code.ptr[jip] = jump2_inst; + jump_offset = code_size - MAX_CODE_JUMP; + } + else + { + jump_offset = code_size; + } + +#if (MOO_BCODE_LONG_PARAM_SIZE == 2) + moo->c->mth.code.ptr[jip + 1] = jump_offset >> 8; + moo->c->mth.code.ptr[jip + 2] = jump_offset & 0xFF; +#else + moo->c->mth.code.ptr[jip + 1] = jump_offset; +#endif + + return 0; +} + static int compile_block_expression (moo_t* moo) { moo_oow_t jump_inst_pos; moo_oow_t saved_tmpr_count, saved_tmprs_len; moo_oow_t block_arg_count, block_tmpr_count; - moo_oow_t block_code_size; moo_ioloc_t block_loc, colon_loc, tmpr_loc; /* @@ -3273,7 +3322,7 @@ static int compile_block_expression (moo_t* moo) /* this function expects [ not to be consumed away */ MOO_ASSERT (moo, TOKEN_TYPE(moo) == MOO_IOTOK_LBRACK); - block_loc = moo->c->tok.loc; + block_loc = *TOKEN_LOC(moo); GET_TOKEN (moo); saved_tmprs_len = moo->c->mth.tmprs.len; @@ -3397,6 +3446,8 @@ static int compile_block_expression (moo_t* moo) if (emit_byte_instruction(moo, BCODE_RETURN_FROM_BLOCK) <= -1) return -1; + if (patch_jump_instruction (moo, jump_inst_pos, BCODE_JUMP2_FORWARD, &block_loc) <= -1) return -1; +#if 0 /* MOO_BCODE_LONG_PARAM_SIZE + 1 => size of the long JUMP_FORWARD instruction */ block_code_size = moo->c->mth.code.len - jump_inst_pos - (MOO_BCODE_LONG_PARAM_SIZE + 1); if (block_code_size > MAX_CODE_JUMP * 2) @@ -3427,6 +3478,7 @@ static int compile_block_expression (moo_t* moo) moo->c->mth.code.ptr[jump_inst_pos + 1] = jump_offset; #endif } +#endif /* restore the temporary count */ moo->c->mth.tmprs.len = saved_tmprs_len; @@ -4224,12 +4276,147 @@ static int compile_basic_expression (moo_t* moo, const moo_oocs_t* ident, const return 0; } +static int compile_braced_block (moo_t* moo) +{ + if (TOKEN_TYPE(moo) != MOO_IOTOK_LBRACE) + { + set_syntax_error (moo, MOO_SYNERR_LBRACE, TOKEN_LOC(moo), TOKEN_NAME(moo)); + return -1; + } + + GET_TOKEN (moo); + + while (TOKEN_TYPE(moo) != MOO_IOTOK_EOF) + { + if (compile_block_statement(moo) <= -1) return -1; + + if (TOKEN_TYPE(moo) == MOO_IOTOK_RBRACE) break; + else if (TOKEN_TYPE(moo) == MOO_IOTOK_PERIOD) + { + GET_TOKEN (moo); + if (TOKEN_TYPE(moo) == MOO_IOTOK_RBRACE) break; + if (emit_byte_instruction(moo, BCODE_POP_STACKTOP) <= -1) return -1; + } + else + { + set_syntax_error (moo, MOO_SYNERR_RBRACE, TOKEN_LOC(moo), TOKEN_NAME(moo)); + return -1; + } + } + + if (TOKEN_TYPE(moo) != MOO_IOTOK_RBRACE) + { + set_syntax_error (moo, MOO_SYNERR_RBRACE, TOKEN_LOC(moo), TOKEN_NAME(moo)); + return -1; + } + + return 0; +} + +static int compile_conditional (moo_t* moo) +{ + if (TOKEN_TYPE(moo) != MOO_IOTOK_LPAREN) + { + set_syntax_error (moo, MOO_SYNERR_LPAREN, TOKEN_LOC(moo), TOKEN_NAME(moo)); + return -1; + } + + GET_TOKEN (moo); + if (compile_method_expression(moo, 0) <= -1) return -1; + if (TOKEN_TYPE(moo) != MOO_IOTOK_RPAREN) + { + set_syntax_error (moo, MOO_SYNERR_LPAREN, TOKEN_LOC(moo), TOKEN_NAME(moo)); + return -1; + } + + return 0; +} + +static int compile_if_expression (moo_t* moo) +{ +moo_oow_t jumptoend[100]; +moo_oow_t jumptoend_count = 0; + + moo_oow_t i; + moo_oow_t jumptonext; + moo_ioloc_t if_loc, brace_loc; + + MOO_ASSERT (moo, TOKEN_TYPE(moo) == MOO_IOTOK_IF); + if_loc = *TOKEN_LOC(moo); + +/* TODO: simple optimization to check if the conditional is true or false */ + GET_TOKEN (moo); /* get ( */ + if (compile_conditional (moo) <= -1) return -1; + + /* insert dummy instructions before replacing them with a jump instruction */ + jumptonext = moo->c->mth.code.len; + /* specifying MAX_CODE_JUMP causes emit_single_param_instruction() to + * produce the long jump instruction (BCODE_JUMP_FORWARD_X) */ + if (emit_single_param_instruction (moo, BCODE_JUMP_FORWARD_IF_FALSE_0, MAX_CODE_JUMP) <= -1) return -1; + + GET_TOKEN (moo); /* get { */ + brace_loc = *TOKEN_LOC(moo); + if (compile_braced_block (moo) <= -1) return -1; + + /* emit code to jump to the end */ + jumptoend[jumptoend_count++] = moo->c->mth.code.len; + if (emit_single_param_instruction (moo, BCODE_JUMP_FORWARD_0, MAX_CODE_JUMP) <= -1) return -1; + + GET_TOKEN (moo); + while (TOKEN_TYPE(moo) == MOO_IOTOK_ELSIF) + { + if (patch_jump_instruction (moo, jumptonext, BCODE_JUMP2_FORWARD_IF_FALSE, &brace_loc) <= -1) return -1; + + GET_TOKEN (moo); + if (compile_conditional(moo) <= -1) return -1; + + /* emit code to jump to the next elsif or else */ + jumptonext = moo->c->mth.code.len; + if (emit_single_param_instruction (moo, BCODE_JUMP_FORWARD_IF_FALSE_0, MAX_CODE_JUMP) <= -1) return -1; + + GET_TOKEN (moo); /* get { */ + brace_loc = *TOKEN_LOC(moo); + if (compile_braced_block(moo) <= -1) return -1; + + /* emit code to jump to the end */ + jumptoend[jumptoend_count++] = moo->c->mth.code.len; + if (emit_single_param_instruction (moo, BCODE_JUMP_FORWARD_0, MAX_CODE_JUMP) <= -1) return -1; + + GET_TOKEN (moo); + } + + if (patch_jump_instruction (moo, jumptonext, BCODE_JUMP2_FORWARD_IF_FALSE, &brace_loc) <= -1) return -1; + + if (TOKEN_TYPE(moo) == MOO_IOTOK_ELSE) + { + GET_TOKEN (moo); + if (compile_braced_block (moo) <= -1) return -1; + GET_TOKEN (moo); + } + else + { + /* emit code to push nil if no 'else' part exists */ + if (emit_byte_instruction (moo, BCODE_PUSH_NIL) <= -1) return -1; + } + + /* patch instructions that jumps to the end of if expression */ + for (i = 0; i < jumptoend_count; i++) + { + /* pass if_loc to every call to patch_jump_instruction(). + * it's harmless because if the first call doesn't flood, the subseqent + * call will never flood either. */ + if (patch_jump_instruction (moo, jumptoend[i], BCODE_JUMP2_FORWARD_IF_FALSE, &if_loc) <= -1) return -1; + } + + return 0; +} + static int compile_method_expression (moo_t* moo, int pop) { /* * method-expression := method-assignment-expression | basic-expression | if-expression * method-assignment-expression := identifier ":=" method-expression - * if-expression := if ( ) { } else { }. + * if-expression := if ( ) { } elsif { } else { } */ moo_oocs_t assignee; @@ -4241,10 +4428,10 @@ static int compile_method_expression (moo_t* moo, int pop) if (TOKEN_TYPE(moo) == MOO_IOTOK_IF) { -/* TODO: ... */ + if (compile_if_expression (moo) <= -1) return -1; } else if (TOKEN_TYPE(moo) == MOO_IOTOK_IDENT || - TOKEN_TYPE(moo) == MOO_IOTOK_IDENT_DOTTED) + TOKEN_TYPE(moo) == MOO_IOTOK_IDENT_DOTTED) { moo_ioloc_t assignee_loc; moo_oow_t assignee_offset; @@ -4396,7 +4583,10 @@ static int compile_method_statement (moo_t* moo) * that the stack top will eventually be popped off. the compiler * can optimize some instruction sequencese. for example, two * consecutive store and pop intructions can be transformed to - * a more specialized single pop-and-store instruction. */ + * a more specialized single pop-and-store instruction. + * the compile_method_expression() function emits POP_INTO_XXX + * instructions if the second parameter is 1 whenever possible and + * STORE_INTO_XXX if it's 0.*/ n = compile_method_expression(moo, 1); if (n <= -1) return -1; diff --git a/moo/lib/decode.c b/moo/lib/decode.c index 4404437..cc8c50f 100644 --- a/moo/lib/decode.c +++ b/moo/lib/decode.c @@ -247,7 +247,6 @@ int moo_decode (moo_t* moo, moo_oop_method_t mth, const moo_oocs_t* classfqn) case BCODE_JUMP_BACKWARD_X: FETCH_PARAM_CODE_TO (moo, b1); LOG_INST_1 (moo, "jump_backward %zu", b1); - moo->ip += b1; break; case BCODE_JUMP_BACKWARD_0: @@ -257,19 +256,29 @@ int moo_decode (moo_t* moo, moo_oop_method_t mth, const moo_oocs_t* classfqn) LOG_INST_1 (moo, "jump_backward %zu", (moo_oow_t)(bcode & 0x3)); /* low 2 bits */ break; - case BCODE_JUMP_IF_TRUE_X: - case BCODE_JUMP_IF_FALSE_X: - case BCODE_JUMP_IF_TRUE_0: - case BCODE_JUMP_IF_TRUE_1: - case BCODE_JUMP_IF_TRUE_2: - case BCODE_JUMP_IF_TRUE_3: - case BCODE_JUMP_IF_FALSE_0: - case BCODE_JUMP_IF_FALSE_1: - case BCODE_JUMP_IF_FALSE_2: - case BCODE_JUMP_IF_FALSE_3: -LOG_INST_0 (moo, "<<<<<<<<<<<<<< JUMP NOT IMPLEMENTED YET >>>>>>>>>>>>"); -moo->errnum = MOO_ENOIMPL; -return -1; + case BCODE_JUMP_FORWARD_IF_FALSE_X: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump_forward_if_false %zu", b1); + break; + + case BCODE_JUMP_FORWARD_IF_FALSE_0: + case BCODE_JUMP_FORWARD_IF_FALSE_1: + case BCODE_JUMP_FORWARD_IF_FALSE_2: + case BCODE_JUMP_FORWARD_IF_FALSE_3: + LOG_INST_1 (moo, "jump_forward_if_false %zu", (moo_oow_t)(bcode & 0x3)); /* low 2 bits */ + break; + + case BCODE_JUMP_BACKWARD_IF_FALSE_X: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump_backward_if_false %zu", b1); + break; + + case BCODE_JUMP_BACKWARD_IF_FALSE_0: + case BCODE_JUMP_BACKWARD_IF_FALSE_1: + case BCODE_JUMP_BACKWARD_IF_FALSE_2: + case BCODE_JUMP_BACKWARD_IF_FALSE_3: + LOG_INST_1 (moo, "jump_backward_if_false %zu", (moo_oow_t)(bcode & 0x3)); /* low 2 bits */ + break; case BCODE_JUMP2_FORWARD: FETCH_PARAM_CODE_TO (moo, b1); @@ -281,6 +290,15 @@ return -1; LOG_INST_1 (moo, "jump2_backward %zu", b1); break; + case BCODE_JUMP2_FORWARD_IF_FALSE: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump2_forward_if_false %zu", b1); + break; + + case BCODE_JUMP2_BACKWARD_IF_FALSE: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump2_backward_if_false %zu", b1); + break; /* -------------------------------------------------------- */ case BCODE_PUSH_CTXTEMPVAR_X: diff --git a/moo/lib/exec.c b/moo/lib/exec.c index 08160a0..10147d6 100644 --- a/moo/lib/exec.c +++ b/moo/lib/exec.c @@ -3460,7 +3460,7 @@ int moo_execute (moo_t* moo) case BCODE_JUMP_BACKWARD_X: FETCH_PARAM_CODE_TO (moo, b1); LOG_INST_1 (moo, "jump_backward %zu", b1); - moo->ip += b1; + moo->ip -= b1; break; case BCODE_JUMP_BACKWARD_0: @@ -3471,19 +3471,37 @@ int moo_execute (moo_t* moo) moo->ip -= (bcode & 0x3); /* low 2 bits */ break; - case BCODE_JUMP_IF_TRUE_X: - case BCODE_JUMP_IF_FALSE_X: - case BCODE_JUMP_IF_TRUE_0: - case BCODE_JUMP_IF_TRUE_1: - case BCODE_JUMP_IF_TRUE_2: - case BCODE_JUMP_IF_TRUE_3: - case BCODE_JUMP_IF_FALSE_0: - case BCODE_JUMP_IF_FALSE_1: - case BCODE_JUMP_IF_FALSE_2: - case BCODE_JUMP_IF_FALSE_3: -MOO_LOG0 (moo, MOO_LOG_IC | MOO_LOG_FATAL, "<<<<<<<<<<<<<< JUMP NOT IMPLEMENTED YET >>>>>>>>>>>>\n"); -moo->errnum = MOO_ENOIMPL; -return -1; + case BCODE_JUMP_FORWARD_IF_FALSE_X: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump_forward_if_false %zu", b1); + if (MOO_STACK_GETTOP(moo) == moo->_false) moo->ip += b1; + MOO_STACK_POP (moo); + break; + + case BCODE_JUMP_FORWARD_IF_FALSE_0: + case BCODE_JUMP_FORWARD_IF_FALSE_1: + case BCODE_JUMP_FORWARD_IF_FALSE_2: + case BCODE_JUMP_FORWARD_IF_FALSE_3: + LOG_INST_1 (moo, "jump_forward_if_false %zu", (moo_oow_t)(bcode & 0x3)); + if (MOO_STACK_GETTOP(moo) == moo->_false) moo->ip += (bcode & 0x3); /* low 2 bits */ + MOO_STACK_POP (moo); + break; + + case BCODE_JUMP_BACKWARD_IF_FALSE_X: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump_backward_if_false %zu", b1); + if (MOO_STACK_GETTOP(moo) == moo->_false) moo->ip -= b1; + MOO_STACK_POP (moo); + break; + + case BCODE_JUMP_BACKWARD_IF_FALSE_0: + case BCODE_JUMP_BACKWARD_IF_FALSE_1: + case BCODE_JUMP_BACKWARD_IF_FALSE_2: + case BCODE_JUMP_BACKWARD_IF_FALSE_3: + LOG_INST_1 (moo, "jump_backward_if_false %zu", (moo_oow_t)(bcode & 0x3)); + if (MOO_STACK_GETTOP(moo) == moo->_false) moo->ip -= (bcode & 0x3); /* low 2 bits */ + MOO_STACK_POP (moo); + break; case BCODE_JUMP2_FORWARD: FETCH_PARAM_CODE_TO (moo, b1); @@ -3497,6 +3515,20 @@ return -1; moo->ip -= MAX_CODE_JUMP + b1; break; + case BCODE_JUMP2_FORWARD_IF_FALSE: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump2_forward_if_false %zu", b1); + if (MOO_STACK_GETTOP(moo) == moo->_false) moo->ip += MAX_CODE_JUMP + b1; + MOO_STACK_POP (moo); + break; + + case BCODE_JUMP2_BACKWARD_IF_FALSE: + FETCH_PARAM_CODE_TO (moo, b1); + LOG_INST_1 (moo, "jump2_backward_if_false %zu", b1); + if (MOO_STACK_GETTOP(moo) == moo->_false) moo->ip -= MAX_CODE_JUMP + b1; + MOO_STACK_POP (moo); + break; + /* -------------------------------------------------------- */ case BCODE_PUSH_CTXTEMPVAR_X: diff --git a/moo/lib/moo-prv.h b/moo/lib/moo-prv.h index 310ade2..2dc9c05 100644 --- a/moo/lib/moo-prv.h +++ b/moo/lib/moo-prv.h @@ -309,7 +309,6 @@ struct moo_iotok_t MOO_IOTOK_FALSE, MOO_IOTOK_THIS_CONTEXT, MOO_IOTOK_THIS_PROCESS, - MOO_IOTOK_IF, MOO_IOTOK_IDENT, MOO_IOTOK_IDENT_DOTTED, MOO_IOTOK_BINSEL, @@ -327,7 +326,11 @@ struct moo_iotok_t MOO_IOTOK_BAPAREN, /* #[ */ MOO_IOTOK_PERIOD, MOO_IOTOK_COMMA, - MOO_IOTOK_SEMICOLON + MOO_IOTOK_SEMICOLON, + + MOO_IOTOK_IF, + MOO_IOTOK_ELSE, + MOO_IOTOK_ELSIF } type; moo_oocs_t name; @@ -575,8 +578,8 @@ SHORT INSTRUCTION CODE LONG INSTRUCTION C 68-71 0100 01XX JUMP_FORWARD 196 1100 0100 XXXXXXXX JUMP_FORWARD_X 72-75 0100 10XX JUMP_BACKWARD 200 1100 1000 XXXXXXXX JUMP_BACKWARD_X -76-79 0100 11XX JUMP_IF_TRUE 204 1100 1100 XXXXXXXX JUMP_IF_TRUE_X -80-83 0101 00XX JUMP_IF_FALSE 208 1101 0000 XXXXXXXX JUMP_IF_FALSE_X +76-79 0100 11XX JUMP_BACKWARD_IF_FALSE 204 1100 1100 XXXXXXXX JUMP_BACKWARD_IF_FALSE_X +80-83 0101 00XX JUMP_FORWARD_IF_FALSE 208 1101 0000 XXXXXXXX JUMP_FORWARD_IF_FALSE_X 84-87 0101 01XX UNUSED @@ -704,15 +707,15 @@ enum moo_bcode_t BCODE_JUMP_BACKWARD_2 = 0x4A, BCODE_JUMP_BACKWARD_3 = 0x4B, - BCODE_JUMP_IF_TRUE_0 = 0x4C, - BCODE_JUMP_IF_TRUE_1 = 0x4D, - BCODE_JUMP_IF_TRUE_2 = 0x4E, - BCODE_JUMP_IF_TRUE_3 = 0x4F, + BCODE_JUMP_FORWARD_IF_FALSE_0 = 0x4C, /* 76 */ + BCODE_JUMP_FORWARD_IF_FALSE_1 = 0x4D, /* 77 */ + BCODE_JUMP_FORWARD_IF_FALSE_2 = 0x4E, /* 78 */ + BCODE_JUMP_FORWARD_IF_FALSE_3 = 0x4F, /* 79 */ - BCODE_JUMP_IF_FALSE_0 = 0x50, /* 80 */ - BCODE_JUMP_IF_FALSE_1 = 0x51, /* 81 */ - BCODE_JUMP_IF_FALSE_2 = 0x52, /* 82 */ - BCODE_JUMP_IF_FALSE_3 = 0x53, /* 83 */ + BCODE_JUMP_BACKWARD_IF_FALSE_0 = 0x50, /* 80 */ + BCODE_JUMP_BACKWARD_IF_FALSE_1 = 0x51, /* 81 */ + BCODE_JUMP_BACKWARD_IF_FALSE_2 = 0x52, /* 82 */ + BCODE_JUMP_BACKWARD_IF_FALSE_3 = 0x53, /* 83 */ BCODE_STORE_INTO_CTXTEMPVAR_0 = 0x58, /* 88 */ BCODE_STORE_INTO_CTXTEMPVAR_1 = 0x59, /* 89 */ @@ -756,41 +759,7 @@ enum moo_bcode_t /* UNUSED 0x78 - 0x7F */ - BCODE_STORE_INTO_INSTVAR_X = 0x80, /* 128 */ - BCODE_POP_INTO_INSTVAR_X = 0x88, /* 136 */ - BCODE_PUSH_INSTVAR_X = 0x90, /* 144 */ - - BCODE_PUSH_TEMPVAR_X = 0x98, /* 152 */ - BCODE_STORE_INTO_TEMPVAR_X = 0xA0, /* 160 */ - BCODE_POP_INTO_TEMPVAR_X = 0xA8, /* 168 */ - - BCODE_PUSH_LITERAL_X = 0xB0, /* 176 */ - - BCODE_STORE_INTO_OBJECT_X = 0xB8, /* 184 */ - BCODE_POP_INTO_OBJECT_X = 0xBC, /* 188 */ - BCODE_PUSH_OBJECT_X = 0xC0, /* 192 */ - - BCODE_JUMP_FORWARD_X = 0xC4, /* 196 */ - BCODE_JUMP_BACKWARD_X = 0xC8, /* 200 */ - BCODE_JUMP_IF_TRUE_X = 0xCC, /* 204 */ - BCODE_JUMP_IF_FALSE_X = 0xD0, /* 208 */ - - - BCODE_STORE_INTO_CTXTEMPVAR_X = 0xD8, /* 216 */ - BCODE_POP_INTO_CTXTEMPVAR_X = 0xDC, /* 220 */ - BCODE_PUSH_CTXTEMPVAR_X = 0xE0, /* 224 */ - - BCODE_PUSH_OBJVAR_X = 0xE4, /* 228 */ - BCODE_STORE_INTO_OBJVAR_X = 0xE8, /* 232 */ - BCODE_POP_INTO_OBJVAR_X = 0xEC, /* 236 */ - - BCODE_SEND_MESSAGE_X = 0xF0, /* 240 */ - BCODE_SEND_MESSAGE_TO_SUPER_X = 0xF4, /* 244 */ - - /* -------------------------------------- */ - - BCODE_JUMP2_FORWARD = 0xC5, /* 197 */ - BCODE_JUMP2_BACKWARD = 0xC9, /* 201 */ + BCODE_STORE_INTO_INSTVAR_X = 0x80, /* 128 ## */ BCODE_PUSH_RECEIVER = 0x81, /* 129 */ BCODE_PUSH_NIL = 0x82, /* 130 */ @@ -799,16 +768,50 @@ enum moo_bcode_t BCODE_PUSH_CONTEXT = 0x85, /* 133 */ BCODE_PUSH_PROCESS = 0x86, /* 134 */ BCODE_PUSH_NEGONE = 0x87, /* 135 */ + + BCODE_POP_INTO_INSTVAR_X = 0x88, /* 136 ## */ + BCODE_PUSH_ZERO = 0x89, /* 137 */ BCODE_PUSH_ONE = 0x8A, /* 138 */ BCODE_PUSH_TWO = 0x8B, /* 139 */ + BCODE_PUSH_INSTVAR_X = 0x90, /* 144 ## */ + BCODE_PUSH_TEMPVAR_X = 0x98, /* 152 ## */ + BCODE_STORE_INTO_TEMPVAR_X = 0xA0, /* 160 ## */ + BCODE_POP_INTO_TEMPVAR_X = 0xA8, /* 168 ## */ + BCODE_PUSH_LITERAL_X = 0xB0, /* 176 ## */ + /* UNUSED - 0xB1 */ BCODE_PUSH_INTLIT = 0xB2, /* 178 */ BCODE_PUSH_NEGINTLIT = 0xB3, /* 179 */ BCODE_PUSH_CHARLIT = 0xB4, /* 180 */ - /* UNUSED 0xE8 - 0xF7 */ + BCODE_STORE_INTO_OBJECT_X = 0xB8, /* 184 ## */ + BCODE_POP_INTO_OBJECT_X = 0xBC, /* 188 ## */ + BCODE_PUSH_OBJECT_X = 0xC0, /* 192 ## */ + + BCODE_JUMP_FORWARD_X = 0xC4, /* 196 ## */ + BCODE_JUMP2_FORWARD = 0xC5, /* 197 */ + BCODE_JUMP_BACKWARD_X = 0xC8, /* 200 ## */ + BCODE_JUMP2_BACKWARD = 0xC9, /* 201 */ + + BCODE_JUMP_FORWARD_IF_FALSE_X = 0xCC, /* 204 ## */ + BCODE_JUMP2_FORWARD_IF_FALSE = 0xCD, /* 205 */ + BCODE_JUMP_BACKWARD_IF_FALSE_X = 0xD0, /* 208 ## */ + BCODE_JUMP2_BACKWARD_IF_FALSE = 0xD1, /* 209 */ + + BCODE_STORE_INTO_CTXTEMPVAR_X = 0xD8, /* 216 ## */ + BCODE_POP_INTO_CTXTEMPVAR_X = 0xDC, /* 220 ## */ + BCODE_PUSH_CTXTEMPVAR_X = 0xE0, /* 224 ## */ + + BCODE_PUSH_OBJVAR_X = 0xE4, /* 228 ## */ + BCODE_STORE_INTO_OBJVAR_X = 0xE8, /* 232 ## */ + BCODE_POP_INTO_OBJVAR_X = 0xEC, /* 236 ## */ + + BCODE_SEND_MESSAGE_X = 0xF0, /* 240 ## */ + BCODE_SEND_MESSAGE_TO_SUPER_X = 0xF4, /* 244 ## */ + + /* -------------------------------------- */ BCODE_DUP_STACKTOP = 0xF8, BCODE_POP_STACKTOP = 0xF9,