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

enhanced the compiler to compile byte array expression.

Browse Source 
added MAKE_BYTEARRAY and POP_INTO_BYTEARRAY byte codes
This commit is contained in:
hyunghwan.chung
2018-04-19 09:48:45 +00:00
parent a5328db569
commit df5b9301dc
6 changed files with 140 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
moo/lib/comp.c
View File

@ -1681,13 +1681,18 @@ retry:
ADD_TOKEN_CHAR(moo, c);
GET_CHAR_TO (moo, c);
/* TODO: byte array expression token -> %[ */
if (c == '(')
{
/* %( - array expression */
ADD_TOKEN_CHAR(moo, c);
SET_TOKEN_TYPE (moo, MOO_IOTOK_PERCPAREN);
}
else if (c == '[')
{
/* %[ - byte-array expression */
ADD_TOKEN_CHAR(moo, c);
SET_TOKEN_TYPE (moo, MOO_IOTOK_PERCBRACK);
}
else if (c == '{')
{
/* %{ - dictionary expression */
@ -1725,6 +1730,12 @@ retry:
SET_TOKEN_TYPE (moo, MOO_IOTOK_HASHBRACK);
break;
case '{':
/* #[ - dictionary literal */
ADD_TOKEN_CHAR(moo, c);
SET_TOKEN_TYPE (moo, MOO_IOTOK_HASHBRACE);
break;
case '\'':
/* quoted symbol literal */
if (get_strlit(moo) <= -1) return -1; /* reuse the string literal tokenizer */
@ -2192,6 +2203,8 @@ static int emit_single_param_instruction (moo_t* moo, int cmd, moo_oow_t param_1
case BCODE_MAKE_DICTIONARY:
case BCODE_MAKE_ARRAY:
case BCODE_POP_INTO_ARRAY:
case BCODE_MAKE_BYTEARRAY:
case BCODE_POP_INTO_BYTEARRAY:
bc = cmd;
goto write_long;
}
@ -4713,15 +4726,15 @@ static int compile_array_literal (moo_t* moo)
return 0;
}
static int compile_array_expression (moo_t* moo)
static int _compile_array_expression (moo_t* moo, int closer_token, int bcode_make, int bcode_pop_into)
{
moo_oow_t maip;
moo_ioloc_t aeloc;
MOO_ASSERT (moo, TOKEN_TYPE(moo) == MOO_IOTOK_PERCPAREN);
MOO_ASSERT (moo, TOKEN_TYPE(moo) == MOO_IOTOK_PERCPAREN || TOKEN_TYPE(moo) == MOO_IOTOK_PERCBRACK);
maip = moo->c->mth.code.len;
if (emit_single_param_instruction(moo, BCODE_MAKE_ARRAY, 0) <= -1) return -1;
if (emit_single_param_instruction(moo, bcode_make, 0) <= -1) return -1;
aeloc = *TOKEN_LOC(moo);
GET_TOKEN (moo); /* read a token after #{ */
@ -4732,8 +4745,8 @@ static int compile_array_expression (moo_t* moo)
index = 0;
do
{
if (compile_method_expression (moo, 0) <= -1) return -1;
if (emit_single_param_instruction (moo, BCODE_POP_INTO_ARRAY, index) <= -1) return -1;
if (compile_method_expression(moo, 0) <= -1) return -1;
if (emit_single_param_instruction(moo, bcode_pop_into, index) <= -1) return -1;
index++;
if (index > MAX_CODE_PARAM)
@ -4742,7 +4755,7 @@ static int compile_array_expression (moo_t* moo)
return -1;
}
if (TOKEN_TYPE(moo) == MOO_IOTOK_RPAREN) break;
if (TOKEN_TYPE(moo) == closer_token) break;
if (TOKEN_TYPE(moo) != MOO_IOTOK_COMMA)
{
@ -4768,6 +4781,16 @@ static int compile_array_expression (moo_t* moo)
return 0;
}
static int compile_array_expression (moo_t* moo)
{
return _compile_array_expression (moo, MOO_IOTOK_RPAREN, BCODE_MAKE_ARRAY, BCODE_POP_INTO_ARRAY);
}
static int compile_bytearray_expression (moo_t* moo)
{
return _compile_array_expression (moo, MOO_IOTOK_RBRACK, BCODE_MAKE_BYTEARRAY, BCODE_POP_INTO_BYTEARRAY);
}
static int compile_dictionary_expression (moo_t* moo)
{
moo_oow_t mdip;
@ -5008,20 +5031,32 @@ static int compile_expression_primary (moo_t* moo, const moo_oocs_t* ident, cons
GET_TOKEN (moo);
break;
case MOO_IOTOK_HASHBRACK: /* #[ */
/*GET_TOKEN (moo);*/
if (compile_byte_array_literal(moo) <= -1) return -1;
break;
case MOO_IOTOK_HASHPAREN: /* #( */
/*GET_TOKEN (moo);*/
if (compile_array_literal(moo) <= -1) return -1;
break;
case MOO_IOTOK_HASHBRACK: /* #[ */
/*GET_TOKEN (moo);*/
if (compile_byte_array_literal(moo) <= -1) return -1;
break;
#if 0
/* TODO: */
case MOO_IOTOK_HASHBRACE: /* #{ */
if (compile_dictionary_literal(moo) <= -1) return -1;
break;
#endif
case MOO_IOTOK_PERCPAREN: /* %( */
if (compile_array_expression(moo) <= -1) return -1;
break;
case MOO_IOTOK_PERCBRACK: /* %[ */
if (compile_bytearray_expression(moo) <= -1) return -1;
break;
case MOO_IOTOK_PERCBRACE: /* %{ */
if (compile_dictionary_expression(moo) <= -1) return -1;
break;

10
moo/lib/decode.c
View File

@ -500,6 +500,16 @@ int moo_decode (moo_t* moo, moo_oop_method_t mth, const moo_oocs_t* classfqn)
break;
/* -------------------------------------------------------- */
case BCODE_MAKE_BYTEARRAY:
FETCH_PARAM_CODE_TO (moo, b1);
LOG_INST_1 (moo, "make_bytearray %zu", b1);
break;
case BCODE_POP_INTO_BYTEARRAY:
FETCH_PARAM_CODE_TO (moo, b1);
LOG_INST_1 (moo, "pop_into_bytearray %zu", b1);
break;
case BCODE_MAKE_DICTIONARY:
FETCH_PARAM_CODE_TO (moo, b1);
LOG_INST_1 (moo, "make_dictionary %zu", b1);

33
moo/lib/exec.c
View File

@ -5283,6 +5283,39 @@ static int __execute (moo_t* moo)
NEXT_INST();
}
ON_INST(BCODE_MAKE_BYTEARRAY)
{
moo_oop_t t;
FETCH_PARAM_CODE_TO (moo, b1);
LOG_INST1 (moo, "make_bytearray %zu", b1);
/* create an empty array */
t = moo_instantiate (moo, moo->_byte_array, MOO_NULL, b1);
if (!t) return -1;
MOO_STACK_PUSH (moo, t); /* push the array created */
NEXT_INST();
}
ON_INST(BCODE_POP_INTO_BYTEARRAY)
{
moo_oop_t t1, t2;
moo_uint8_t bv;
FETCH_PARAM_CODE_TO (moo, b1);
LOG_INST1 (moo, "pop_into_bytearray %zu", b1);
t1 = MOO_STACK_GETTOP(moo);
MOO_STACK_POP (moo);
t2 = MOO_STACK_GETTOP(moo);
if (MOO_OOP_IS_SMOOI(t1)) bv = MOO_OOP_TO_SMOOI(t1);
else if (MOO_OOP_IS_CHAR(t1)) bv = MOO_OOP_TO_CHAR(t1);
else if (MOO_OOP_IS_ERROR(t1)) bv = MOO_OOP_TO_ERROR(t1);
else if (MOO_OOP_IS_SMPTR(t1)) bv = ((moo_oow_t)MOO_OOP_TO_SMPTR(t1) & 0xFF);
else bv = 0;
((moo_oop_byte_t)t2)->slot[b1] = bv;
NEXT_INST();
}
ON_INST(BCODE_DUP_STACKTOP)
{
moo_oop_t t;

4
moo/lib/moo-bct.h
View File

@ -238,8 +238,8 @@
/* 235 */ &&case_DEFAULT,
/* 236 */ &&case_BCODE_POP_INTO_OBJVAR_X,
/* 237 */ &&case_DEFAULT,
/* 238 */ &&case_DEFAULT,
/* 239 */ &&case_DEFAULT,
/* 238 */ &&case_BCODE_MAKE_BYTEARRAY,
/* 239 */ &&case_BCODE_POP_INTO_BYTEARRAY,
/* 240 */ &&case_BCODE_SEND_MESSAGE_X,
/* 241 */ &&case_DEFAULT,
/* 242 */ &&case_BCODE_MAKE_DICTIONARY,

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

@ -369,7 +369,9 @@ enum moo_iotok_type_t
MOO_IOTOK_RPAREN,
MOO_IOTOK_HASHPAREN, /* #( - array literal */
MOO_IOTOK_HASHBRACK, /* #[ - byte array literal */
MOO_IOTOK_HASHBRACE, /* #{ - dictionary literal */
MOO_IOTOK_PERCPAREN, /* %( - array expression */
MOO_IOTOK_PERCBRACK, /* %[ - byte array expression */
MOO_IOTOK_PERCBRACE, /* %{ - dictionary expression */
MOO_IOTOK_PERIOD,
MOO_IOTOK_COMMA,
@ -954,8 +956,8 @@ enum moo_bcode_t
BCODE_POP_INTO_OBJVAR_X = 0xEC, /* 236 ## */
/* UNUSED 237 */
/* UNUSED 238 */
/* UNUSED 239 */
BCODE_MAKE_BYTEARRAY = 0xEE, /* 238 */
BCODE_POP_INTO_BYTEARRAY = 0xEF, /* 239 */
BCODE_SEND_MESSAGE_X = 0xF0, /* 240 ## */
/* UNUSED 241 */