hyung-hwan/moo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added primitive code to compile the 'if' expression

Browse Source
This commit is contained in:
hyunghwan.chung 2017-01-18 17:17:05 +00:00
parent 4a4d40dea1
commit 40ba50fc53
7 changed files with 386 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
moo/kernel/Apex.moo
View File

@ -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)

2
moo/kernel/Collect.moo
View File

@ -514,4 +514,4 @@ extend Apex
{
^Association new key: self value: object
}
}
}

50
moo/kernel/Mill.moo
View File

@ -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...'.
}
}

206
moo/lib/comp.c
View File

@ -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;

46
moo/lib/decode.c
View File

@ -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:

60
moo/lib/exec.c
View File

@ -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:

99
moo/lib/moo-prv.h
View File

@ -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,