From 55a5d2c3c61d430b65da027f65699dbaff918f92 Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Thu, 29 Sep 2016 13:20:09 +0000 Subject: [PATCH] did something on temporary variable and argument handling --- lib/comp.c | 206 ++++++++++++++++++++++++++++++++++++++++++++++---- lib/decode.c | 49 ++++++------ lib/hcl-prv.h | 64 ++++++++++------ lib/hcl.h | 5 +- lib/main.c | 4 +- lib/read.c | 22 ++++++ 6 files changed, 284 insertions(+), 66 deletions(-) diff --git a/lib/comp.c b/lib/comp.c index 90da1bd..3c2c3c0 100644 --- a/lib/comp.c +++ b/lib/comp.c @@ -32,6 +32,9 @@ enum VAR_ARGUMENT }; +#define TV_BUFFER_ALIGN 256 +#define BLK_TMPRCNT_BUFFER_ALIGN 128 + #define EMIT_BYTE_INSTRUCTION(hcl,code) \ do { if (emit_byte_instruction(hcl,code) <= -1) return -1; } while(0) @@ -72,6 +75,82 @@ static int add_literal (hcl_t* hcl, hcl_oop_t obj, hcl_oow_t* index) return 0; } +static int add_temporary_variable (hcl_t* hcl, hcl_oop_t name, hcl_oow_t dup_check_start) +{ + hcl_oow_t i; + + HCL_ASSERT (HCL_IS_SYMBOL (hcl, name)); + + for (i = dup_check_start; i < hcl->c->tv.size; i++) + { + HCL_ASSERT (HCL_IS_SYMBOL (hcl, hcl->c->tv.ptr[i])); + if (hcl->c->tv.ptr[i] == name) + { + hcl->errnum = HCL_EEXIST; + return -1; + } + } + + if (hcl->c->tv.size >= hcl->c->tv.capa) + { + hcl_oop_t* tmp; + hcl_oow_t newcapa; + + newcapa = HCL_ALIGN (hcl->c->tv.capa + 1, TV_BUFFER_ALIGN); /* TODO: set a better resizing policy */ + tmp = hcl_reallocmem (hcl, hcl->c->tv.ptr, newcapa); + if (!tmp) return -1; + + hcl->c->tv.capa = newcapa; + hcl->c->tv.ptr = tmp; + } + + hcl->c->tv.ptr[hcl->c->tv.size++] = name; + return 0; +} + +static int find_temporary_variable_backward (hcl_t* hcl, hcl_oop_t name, hcl_oow_t* index) +{ + hcl_oow_t i; + + HCL_ASSERT (HCL_IS_SYMBOL (hcl, name)); + for (i = hcl->c->tv.size; i > 0; ) + { + --i; + HCL_ASSERT (HCL_IS_SYMBOL (hcl, hcl->c->tv.ptr[i])); + if (hcl->c->tv.ptr[i] == name) + { + *index = i; + return 0; + } + } + + hcl->errnum = HCL_ENOENT; + return -1; +} + +static int store_temporary_variable_count_for_block (hcl_t* hcl, hcl_oow_t tmpr_count) +{ + HCL_ASSERT (hcl->c->blk.depth >= 0); + + if (hcl->c->blk.depth >= hcl->c->blk.tmprcnt_capa) + { + hcl_oow_t* tmp; + hcl_oow_t newcapa; + + newcapa = HCL_ALIGN (hcl->c->blk.depth + 1, BLK_TMPRCNT_BUFFER_ALIGN); + tmp = (hcl_oow_t*)hcl_reallocmem (hcl, hcl->c->blk.tmprcnt, newcapa * HCL_SIZEOF(*tmp)); + if (!tmp) return -1; + + hcl->c->blk.tmprcnt_capa = newcapa; + hcl->c->blk.tmprcnt = tmp; + } + + hcl->c->blk.tmprcnt[hcl->c->blk.depth] = tmpr_count; + return 0; +} + +/* ========================================================================= */ + static HCL_INLINE void patch_instruction (hcl_t* hcl, hcl_oow_t index, hcl_oob_t bc) { HCL_ASSERT (index < hcl->code.bc.len); @@ -150,7 +229,7 @@ static int emit_single_param_instruction (hcl_t* hcl, int cmd, hcl_oow_t param_1 case HCL_CODE_PUSH_OBJECT_0: case HCL_CODE_STORE_INTO_OBJECT_0: - case HCL_CODE_POP_INTO_OBJECT_0: + case BCODE_POP_INTO_OBJECT_0: case HCL_CODE_JUMP_FORWARD_0: case HCL_CODE_JUMP_BACKWARD_0: #if 0 @@ -229,15 +308,17 @@ static int emit_double_param_instruction (hcl_t* hcl, int cmd, hcl_oow_t param_1 switch (cmd) { -#if 0 + case HCL_CODE_STORE_INTO_CTXTEMPVAR_0: - case HCL_CODE_POP_INTO_CTXTEMPVAR_0: + /*case BCODE_POP_INTO_CTXTEMPVAR_0:*/ case HCL_CODE_PUSH_CTXTEMPVAR_0: +#if 0 case HCL_CODE_PUSH_OBJVAR_0: case HCL_CODE_STORE_INTO_OBJVAR_0: - case HCL_CODE_POP_INTO_OBJVAR_0: + case BCODE_POP_INTO_OBJVAR_0: case HCL_CODE_SEND_MESSAGE_0: case HCL_CODE_SEND_MESSAGE_TO_SUPER_0: +#endif if (param_1 < 4 && param_2 < 0xFF) { /* low 2 bits of the instruction code is the first parameter */ @@ -247,10 +328,10 @@ static int emit_double_param_instruction (hcl_t* hcl, int cmd, hcl_oow_t param_1 else { /* convert the code to a long version */ - bc = cmd | 0x80; + bc = cmd | 0x80; goto write_long; } -#endif + case HCL_CODE_MAKE_BLOCK: bc = cmd; @@ -469,10 +550,12 @@ static int compile_lambda (hcl_t* hcl, hcl_oop_t src) hcl_oop_t obj, args, arg, ptr; hcl_oow_t nargs, ntmprs; hcl_oow_t jump_inst_pos; + hcl_oow_t saved_tv_count; HCL_ASSERT (HCL_BRANDOF(hcl,src) == HCL_BRAND_CONS); HCL_ASSERT (HCL_CONS_CAR(src) == hcl->_lambda); + saved_tv_count = hcl->c->tv.size; obj = HCL_CONS_CDR(src); if (HCL_IS_NIL(hcl, obj)) @@ -496,6 +579,7 @@ static int compile_lambda (hcl_t* hcl, hcl_oop_t src) } else { + hcl_oow_t tv_dup_start; if (HCL_BRANDOF(hcl, args) != HCL_BRAND_CONS) { HCL_DEBUG1 (hcl, "Syntax error - not a lambda argument list - %O\n", args); @@ -503,6 +587,7 @@ static int compile_lambda (hcl_t* hcl, hcl_oop_t src) return -1; } + tv_dup_start = hcl->c->tv.size; nargs = 0; ptr = args; do @@ -510,12 +595,23 @@ static int compile_lambda (hcl_t* hcl, hcl_oop_t src) arg = HCL_CONS_CAR(ptr); if (HCL_BRANDOF(hcl, arg) != HCL_BRAND_SYMBOL) { - HCL_DEBUG1 (hcl, "Syntax error - ldamba argument not a symbol - %O\n", arg); + HCL_DEBUG1 (hcl, "Syntax error - lambda argument not a symbol - %O\n", arg); hcl_setsynerr (hcl, HCL_SYNERR_ARGNAME, HCL_NULL, HCL_NULL); /* TODO: error location */ return -1; } /* TODO: check duplicates within only the argument list. duplicates against outer-scope are ok. * is this check necessary? */ + + if (add_temporary_variable (hcl, arg, tv_dup_start) <= -1) + { + if (hcl->errnum == HCL_EEXIST) + { + HCL_DEBUG1 (hcl, "Syntax error - lambda argument duplicate - %O\n", arg); + hcl_setsynerr (hcl, HCL_SYNERR_ARGNAME, HCL_NULL, HCL_NULL); /* TODO: error location */ + return -1; + } + return -1; + } nargs++; ptr = HCL_CONS_CDR(ptr); @@ -533,9 +629,42 @@ static int compile_lambda (hcl_t* hcl, hcl_oop_t src) while (1); } - ntmprs = nargs; + ntmprs = nargs; /* TODO: handle local temporary variables */ + HCL_ASSERT (nargs == hcl->c->tv.size - saved_tv_count); + if (nargs > MAX_CODE_NBLKARGS) /*TODO: change this limit to max call argument count */ + { + /* while an integer object is pused to indicate the number of + * block arguments, evaluation which is done by message passing + * limits the number of arguments that can be passed. so the + * check is implemented */ + HCL_DEBUG1 (hcl, "Syntax error - too many arguments - %O\n", args); + hcl_setsynerr (hcl, HCL_SYNERR_ARGFLOOD, HCL_NULL, HCL_NULL); + return -1; + } + +#if 0 +/* TODO: block local temporary variables... */ + /* ntmprs: number of temporary variables including arguments */ + HCL_ASSERT (ntmprs == hcl->c->tv.size - saved_tv_count); + if (ntmprs > MAX_CODE_NBLKTMPRS) + { + HCL_DEBUG1 (hcl, "Syntax error - too many local temporary variables - %O\n", args); + hcl_setsynerr (hcl, HCL_SYNERR_BLKTMPRFLOOD, HCL_NULL, HCL_NULL); + return -1; + } +#endif + + if (hcl->c->blk.depth == HCL_TYPE_MAX(hcl_ooi_t)) + { + HCL_DEBUG1 (hcl, "Syntax error - lambda block depth too deep - %O\n", src); + hcl_setsynerr (hcl, HCL_SYNERR_BLKDEPTH, HCL_NULL, HCL_NULL); + return -1; + } + hcl->c->blk.depth++; + if (store_temporary_variable_count_for_block (hcl, hcl->c->tv.size) <= -1) return -1; + if (emit_double_param_instruction (hcl, HCL_CODE_MAKE_BLOCK, nargs, ntmprs) <= -1) return -1; /* specifying MAX_CODE_JUMP causes emit_single_param_instruction() to @@ -544,8 +673,9 @@ static int compile_lambda (hcl_t* hcl, hcl_oop_t src) if (emit_single_param_instruction (hcl, HCL_CODE_JUMP_FORWARD_0, MAX_CODE_JUMP) <= -1) return -1; SWITCH_TOP_CFRAME (hcl, COP_COMPILE_OBJECT_LIST, HCL_CONS_CDR(obj)); + PUSH_SUBCFRAME (hcl, COP_EMIT_LAMBDA, hcl->_nil); /* operand field is not used for COP_EMIT_LAMBDA */ - cf = GET_SUBCFRAME (hcl); + cf = GET_SUBCFRAME (hcl); /* modify the EMIT_LAMBDA frame */ cf->u.lambda.jip = jump_inst_pos; cf->u.lambda.nargs = nargs; cf->u.lambda.ntmprs = ntmprs; @@ -610,7 +740,7 @@ static int compile_set (hcl_t* hcl, hcl_oop_t src) } SWITCH_TOP_CFRAME (hcl, COP_COMPILE_OBJECT, val); - PUSH_SUBCFRAME (hcl, COP_EMIT_SET, var); + PUSH_SUBCFRAME (hcl, COP_EMIT_SET, var); /* set doesn't evaluate the variable name */ cf = GET_SUBCFRAME (hcl); cf->u.set.var_type = VAR_NAMED; @@ -719,11 +849,44 @@ static HCL_INLINE int compile_symbol (hcl_t* hcl, hcl_oop_t obj) HCL_ASSERT (HCL_BRANDOF(hcl,obj) == HCL_BRAND_SYMBOL); /* check if a symbol is a local variable */ - /*if (emit_single_param_instruction (hcl, HCL_CODE_PUSH_TEMPVAR_0, xxx) <= -1) return -1;*/ + if (find_temporary_variable_backward (hcl, obj, &index) <= -1) + { + /* global variable */ + if (add_literal(hcl, obj, &index) <= -1 || + emit_single_param_instruction (hcl, HCL_CODE_PUSH_OBJECT_0, index) <= -1) return -1; + } + else + { + #if defined(HCL_USE_CTXTEMPVAR) + if (hcl->c->blk.depth >= 0) + { + hcl_oow_t i; - /* global variable */ - if (add_literal(hcl, obj,&index) <= -1 || - emit_single_param_instruction (hcl, HCL_CODE_PUSH_OBJECT_0, index) <= -1) return -1; + /* if a temporary variable is accessed inside a block, + * use a special instruction to indicate it */ + HCL_ASSERT (index < hcl->c->blk.tmprcnt[hcl->c->blk.depth]); + for (i = hcl->c->blk.depth; i > 0; i--) /* excluded the top level -- TODO: change this code depending on global variable handling */ + { + if (index >= hcl->c->blk.tmprcnt[i - 1]) + { + hcl_oow_t ctx_offset, index_in_ctx; + ctx_offset = hcl->c->blk.depth - i; + index_in_ctx = index - hcl->c->blk.tmprcnt[i - 1]; + /* ctx_offset 0 means the current context. + * 1 means current->home. + * 2 means current->home->home. + * index_in_ctx is a relative index within the context found. + */ + if (emit_double_param_instruction(hcl, HCL_CODE_PUSH_CTXTEMPVAR_0, ctx_offset, index_in_ctx) <= -1) return -1; + return 0; + } + } + } + #endif + + /* TODO: top-level... verify this. this will vary depending on how i implement the top-level and global variables... */ + if (emit_single_param_instruction (hcl, HCL_CODE_PUSH_TEMPVAR_0, index) <= -1) return -1; + } return 0; } @@ -832,6 +995,9 @@ static HCL_INLINE int emit_lambda (hcl_t* hcl) HCL_ASSERT (cf->opcode == COP_EMIT_LAMBDA); HCL_ASSERT (HCL_IS_NIL(hcl, cf->operand)); + hcl->c->blk.depth--; + hcl->c->tv.size = hcl->c->blk.tmprcnt[hcl->c->blk.depth]; + /* HCL_CODE_LONG_PARAM_SIZE + 1 => size of the long JUMP_FORWARD instruction */ block_code_size = hcl->code.bc.len - cf->u.lambda.jip - (HCL_BCODE_LONG_PARAM_SIZE + 1); @@ -944,6 +1110,13 @@ int hcl_compile (hcl_t* hcl, hcl_oop_t obj) saved_bc_len = hcl->code.bc.len; saved_lit_len = hcl->code.lit.len; + HCL_ASSERT (hcl->c->tv.size == 0); + HCL_ASSERT (hcl->c->blk.depth == -1); + +/* TODO: in case i implement all global variables as block arguments at the top level... */ + hcl->c->blk.depth++; + if (store_temporary_variable_count_for_block(hcl, hcl->c->tv.size) <= -1) return -1; + PUSH_CFRAME (hcl, COP_COMPILE_OBJECT, obj); while (GET_TOP_CFRAME_INDEX(hcl) >= 0) @@ -990,6 +1163,9 @@ int hcl_compile (hcl_t* hcl, hcl_oop_t obj) done: HCL_ASSERT (GET_TOP_CFRAME_INDEX(hcl) < 0); + HCL_ASSERT (hcl->c->tv.size == 0); + HCL_ASSERT (hcl->c->blk.depth == 0); + hcl->c->blk.depth--; return 0; oops: @@ -999,5 +1175,7 @@ oops: hcl->code.bc.len = saved_bc_len; hcl->code.lit.len = saved_lit_len; + hcl->c->tv.size = 0; + hcl->c->blk.depth = 0; return -1; } diff --git a/lib/decode.c b/lib/decode.c index d673980..46ab1bb 100644 --- a/lib/decode.c +++ b/lib/decode.c @@ -1,4 +1,3 @@ -/* /* * $Id$ * @@ -120,7 +119,7 @@ int hcl_decode (hcl_t* hcl, hcl_oow_t start, hcl_oow_t end) /* ------------------------------------------------- */ case HCL_CODE_PUSH_TEMPVAR_X: - case BCODE_STORE_INTO_TEMPVAR_X: + case HCL_CODE_STORE_INTO_TEMPVAR_X: case BCODE_POP_INTO_TEMPVAR_X: FETCH_PARAM_CODE_TO (hcl, b1); goto handle_tempvar; @@ -133,14 +132,14 @@ int hcl_decode (hcl_t* hcl, hcl_oow_t start, hcl_oow_t end) case HCL_CODE_PUSH_TEMPVAR_5: case HCL_CODE_PUSH_TEMPVAR_6: case HCL_CODE_PUSH_TEMPVAR_7: - case BCODE_STORE_INTO_TEMPVAR_0: - case BCODE_STORE_INTO_TEMPVAR_1: - case BCODE_STORE_INTO_TEMPVAR_2: - case BCODE_STORE_INTO_TEMPVAR_3: - case BCODE_STORE_INTO_TEMPVAR_4: - case BCODE_STORE_INTO_TEMPVAR_5: - case BCODE_STORE_INTO_TEMPVAR_6: - case BCODE_STORE_INTO_TEMPVAR_7: + case HCL_CODE_STORE_INTO_TEMPVAR_0: + case HCL_CODE_STORE_INTO_TEMPVAR_1: + case HCL_CODE_STORE_INTO_TEMPVAR_2: + case HCL_CODE_STORE_INTO_TEMPVAR_3: + case HCL_CODE_STORE_INTO_TEMPVAR_4: + case HCL_CODE_STORE_INTO_TEMPVAR_5: + case HCL_CODE_STORE_INTO_TEMPVAR_6: + case HCL_CODE_STORE_INTO_TEMPVAR_7: case BCODE_POP_INTO_TEMPVAR_0: case BCODE_POP_INTO_TEMPVAR_1: case BCODE_POP_INTO_TEMPVAR_2: @@ -203,7 +202,7 @@ int hcl_decode (hcl_t* hcl, hcl_oow_t start, hcl_oow_t end) /* ------------------------------------------------- */ case HCL_CODE_PUSH_OBJECT_X: case HCL_CODE_STORE_INTO_OBJECT_X: - case HCL_CODE_POP_INTO_OBJECT_X: + case BCODE_POP_INTO_OBJECT_X: FETCH_PARAM_CODE_TO (hcl, b1); goto handle_object; @@ -215,10 +214,10 @@ int hcl_decode (hcl_t* hcl, hcl_oow_t start, hcl_oow_t end) case HCL_CODE_STORE_INTO_OBJECT_1: case HCL_CODE_STORE_INTO_OBJECT_2: case HCL_CODE_STORE_INTO_OBJECT_3: - case HCL_CODE_POP_INTO_OBJECT_0: - case HCL_CODE_POP_INTO_OBJECT_1: - case HCL_CODE_POP_INTO_OBJECT_2: - case HCL_CODE_POP_INTO_OBJECT_3: + case BCODE_POP_INTO_OBJECT_0: + case BCODE_POP_INTO_OBJECT_1: + case BCODE_POP_INTO_OBJECT_2: + case BCODE_POP_INTO_OBJECT_3: b1 = bcode & 0x3; /* low 2 bits */ handle_object: if ((bcode >> 3) & 1) @@ -306,20 +305,20 @@ return -1; /* -------------------------------------------------------- */ - case BCODE_PUSH_CTXTEMPVAR_X: - case BCODE_STORE_INTO_CTXTEMPVAR_X: + case HCL_CODE_PUSH_CTXTEMPVAR_X: + case HCL_CODE_STORE_INTO_CTXTEMPVAR_X: case BCODE_POP_INTO_CTXTEMPVAR_X: FETCH_PARAM_CODE_TO (hcl, b1); FETCH_PARAM_CODE_TO (hcl, b2); goto handle_ctxtempvar; - case BCODE_PUSH_CTXTEMPVAR_0: - case BCODE_PUSH_CTXTEMPVAR_1: - case BCODE_PUSH_CTXTEMPVAR_2: - case BCODE_PUSH_CTXTEMPVAR_3: - case BCODE_STORE_INTO_CTXTEMPVAR_0: - case BCODE_STORE_INTO_CTXTEMPVAR_1: - case BCODE_STORE_INTO_CTXTEMPVAR_2: - case BCODE_STORE_INTO_CTXTEMPVAR_3: + case HCL_CODE_PUSH_CTXTEMPVAR_0: + case HCL_CODE_PUSH_CTXTEMPVAR_1: + case HCL_CODE_PUSH_CTXTEMPVAR_2: + case HCL_CODE_PUSH_CTXTEMPVAR_3: + case HCL_CODE_STORE_INTO_CTXTEMPVAR_0: + case HCL_CODE_STORE_INTO_CTXTEMPVAR_1: + case HCL_CODE_STORE_INTO_CTXTEMPVAR_2: + case HCL_CODE_STORE_INTO_CTXTEMPVAR_3: case BCODE_POP_INTO_CTXTEMPVAR_0: case BCODE_POP_INTO_CTXTEMPVAR_1: case BCODE_POP_INTO_CTXTEMPVAR_2: diff --git a/lib/hcl-prv.h b/lib/hcl-prv.h index e9795a2..e9b4b94 100644 --- a/lib/hcl-prv.h +++ b/lib/hcl-prv.h @@ -351,6 +351,20 @@ struct hcl_compiler_t hcl_oow_t capa; } cfs; /* == END COMPILER STACK == */ + + struct + { + hcl_oop_t* ptr; + hcl_oow_t size; + hcl_oow_t capa; + } tv; /* temporary variables including arguments */ + + struct + { + hcl_ooi_t depth; + hcl_oow_t* tmprcnt; + hcl_oow_t tmprcnt_capa; + } blk; /* lambda block */ }; #endif @@ -489,15 +503,15 @@ enum hcl_bcode_t HCL_CODE_PUSH_TEMPVAR_6 = 0x1E, HCL_CODE_PUSH_TEMPVAR_7 = 0x1F, - BCODE_STORE_INTO_TEMPVAR_0 = 0x20, - BCODE_STORE_INTO_TEMPVAR_1 = 0x21, - BCODE_STORE_INTO_TEMPVAR_2 = 0x22, - BCODE_STORE_INTO_TEMPVAR_3 = 0x23, + HCL_CODE_STORE_INTO_TEMPVAR_0 = 0x20, + HCL_CODE_STORE_INTO_TEMPVAR_1 = 0x21, + HCL_CODE_STORE_INTO_TEMPVAR_2 = 0x22, + HCL_CODE_STORE_INTO_TEMPVAR_3 = 0x23, - BCODE_STORE_INTO_TEMPVAR_4 = 0x24, - BCODE_STORE_INTO_TEMPVAR_5 = 0x25, - BCODE_STORE_INTO_TEMPVAR_6 = 0x26, - BCODE_STORE_INTO_TEMPVAR_7 = 0x27, + HCL_CODE_STORE_INTO_TEMPVAR_4 = 0x24, + HCL_CODE_STORE_INTO_TEMPVAR_5 = 0x25, + HCL_CODE_STORE_INTO_TEMPVAR_6 = 0x26, + HCL_CODE_STORE_INTO_TEMPVAR_7 = 0x27, BCODE_POP_INTO_TEMPVAR_0 = 0x28, BCODE_POP_INTO_TEMPVAR_1 = 0x29, @@ -526,10 +540,10 @@ enum hcl_bcode_t HCL_CODE_STORE_INTO_OBJECT_2 = 0x3A, HCL_CODE_STORE_INTO_OBJECT_3 = 0x3B, - HCL_CODE_POP_INTO_OBJECT_0 = 0x3C, - HCL_CODE_POP_INTO_OBJECT_1 = 0x3D, - HCL_CODE_POP_INTO_OBJECT_2 = 0x3E, - HCL_CODE_POP_INTO_OBJECT_3 = 0x3F, + BCODE_POP_INTO_OBJECT_0 = 0x3C, + BCODE_POP_INTO_OBJECT_1 = 0x3D, + BCODE_POP_INTO_OBJECT_2 = 0x3E, + BCODE_POP_INTO_OBJECT_3 = 0x3F, HCL_CODE_PUSH_OBJECT_0 = 0x40, HCL_CODE_PUSH_OBJECT_1 = 0x41, @@ -561,20 +575,20 @@ enum hcl_bcode_t HCL_CODE_CALL_2 = 0x56, /* 86 */ HCL_CODE_CALL_3 = 0x57, /* 87 */ - BCODE_STORE_INTO_CTXTEMPVAR_0 = 0x58, /* 88 */ - BCODE_STORE_INTO_CTXTEMPVAR_1 = 0x59, /* 89 */ - BCODE_STORE_INTO_CTXTEMPVAR_2 = 0x5A, /* 90 */ - BCODE_STORE_INTO_CTXTEMPVAR_3 = 0x5B, /* 91 */ + HCL_CODE_STORE_INTO_CTXTEMPVAR_0 = 0x58, /* 88 */ + HCL_CODE_STORE_INTO_CTXTEMPVAR_1 = 0x59, /* 89 */ + HCL_CODE_STORE_INTO_CTXTEMPVAR_2 = 0x5A, /* 90 */ + HCL_CODE_STORE_INTO_CTXTEMPVAR_3 = 0x5B, /* 91 */ BCODE_POP_INTO_CTXTEMPVAR_0 = 0x5C, /* 92 */ BCODE_POP_INTO_CTXTEMPVAR_1 = 0x5D, /* 93 */ BCODE_POP_INTO_CTXTEMPVAR_2 = 0x5E, /* 94 */ BCODE_POP_INTO_CTXTEMPVAR_3 = 0x5F, /* 95 */ - BCODE_PUSH_CTXTEMPVAR_0 = 0x60, /* 96 */ - BCODE_PUSH_CTXTEMPVAR_1 = 0x61, /* 97 */ - BCODE_PUSH_CTXTEMPVAR_2 = 0x62, /* 98 */ - BCODE_PUSH_CTXTEMPVAR_3 = 0x63, /* 99 */ + HCL_CODE_PUSH_CTXTEMPVAR_0 = 0x60, /* 96 */ + HCL_CODE_PUSH_CTXTEMPVAR_1 = 0x61, /* 97 */ + HCL_CODE_PUSH_CTXTEMPVAR_2 = 0x62, /* 98 */ + HCL_CODE_PUSH_CTXTEMPVAR_3 = 0x63, /* 99 */ BCODE_PUSH_OBJVAR_0 = 0x64, BCODE_PUSH_OBJVAR_1 = 0x65, @@ -608,7 +622,7 @@ enum hcl_bcode_t BCODE_PUSH_INSTVAR_X = 0x90, /* 144 */ HCL_CODE_PUSH_TEMPVAR_X = 0x98, /* 152 */ - BCODE_STORE_INTO_TEMPVAR_X = 0xA0, /* 160 */ + HCL_CODE_STORE_INTO_TEMPVAR_X = 0xA0, /* 160 */ BCODE_POP_INTO_TEMPVAR_X = 0xA8, /* 168 */ HCL_CODE_PUSH_LITERAL_X = 0xB0, /* 176 */ @@ -616,8 +630,8 @@ enum hcl_bcode_t /* SEE FURTHER DOWN FOR SPECIAL CODES - 0xB2 - 0xB7 */ - HCL_CODE_STORE_INTO_OBJECT_X = 0xB8, /* 184 */ - HCL_CODE_POP_INTO_OBJECT_X = 0xBC, /* 188 */ + HCL_CODE_STORE_INTO_OBJECT_X = 0xB8, /* 184 */ + BCODE_POP_INTO_OBJECT_X = 0xBC, /* 188 */ HCL_CODE_PUSH_OBJECT_X = 0xC0, /* 192 */ HCL_CODE_JUMP_FORWARD_X = 0xC4, /* 196 */ @@ -627,9 +641,9 @@ enum hcl_bcode_t HCL_CODE_CALL_X = 0xD4, /* 212 */ - BCODE_STORE_INTO_CTXTEMPVAR_X = 0xD8, /* 216 */ + HCL_CODE_STORE_INTO_CTXTEMPVAR_X = 0xD8, /* 216 */ BCODE_POP_INTO_CTXTEMPVAR_X = 0xDC, /* 220 */ - BCODE_PUSH_CTXTEMPVAR_X = 0xE0, /* 224 */ + HCL_CODE_PUSH_CTXTEMPVAR_X = 0xE0, /* 224 */ BCODE_PUSH_OBJVAR_X = 0xE4, /* 228 */ BCODE_STORE_INTO_OBJVAR_X = 0xE8, /* 232 */ diff --git a/lib/hcl.h b/lib/hcl.h index 325b1a3..b00beca 100644 --- a/lib/hcl.h +++ b/lib/hcl.h @@ -52,6 +52,7 @@ enum hcl_errnum_t HCL_EPERM, /**< operation not permitted */ HCL_ERANGE, /**< range error. overflow and underflow */ HCL_ENOENT, /**< no matching entry */ + HCL_EEXIST, /**< duplicate entry */ HCL_EDFULL, /**< dictionary full */ HCL_EPFULL, /**< processor full */ HCL_ESHFULL, /**< semaphore heap full */ @@ -90,8 +91,10 @@ enum hcl_synerrnum_t HCL_SYNERR_ARGNAMELIST, /* argument name list expected */ HCL_SYNERR_ARGNAME, /* argument name expected */ HCL_SYNERR_BLKFLOOD, /* lambda block too big */ + HCL_SYNERR_BLKDEPTH, /* lambda block too deep */ HCL_SYNERR_VARNAME, /* variable name expected */ - HCL_SYNERR_ARGCOUNT /* wrong number of arguments */ + HCL_SYNERR_ARGCOUNT, /* wrong number of arguments */ + HCL_SYNERR_ARGFLOOD /* too many arguments defined */ }; typedef enum hcl_synerrnum_t hcl_synerrnum_t; diff --git a/lib/main.c b/lib/main.c index 79b7dbd..4c95e46 100644 --- a/lib/main.c +++ b/lib/main.c @@ -447,8 +447,10 @@ static char* syntax_error_msg[] = "argument name list expected", "argument name expected", "lambda block too big", + "lambda block too deep", "variable name expected", - "wrong number of arguments" + "wrong number of arguments", + "too many arguments defined" }; static void print_synerr (hcl_t* hcl) diff --git a/lib/read.c b/lib/read.c index 4e080fd..1fd50ec 100644 --- a/lib/read.c +++ b/lib/read.c @@ -1687,6 +1687,11 @@ static void gc_compiler (hcl_t* hcl) { hcl->c->cfs.ptr[i].operand = hcl_moveoop(hcl, hcl->c->cfs.ptr[i].operand); } + + for (i = 0; i < hcl->c->tv.size; i++) + { + hcl->c->tv.ptr[i] = hcl_moveoop (hcl, hcl->c->tv.ptr[i]); + } } static void fini_compiler (hcl_t* hcl) @@ -1710,6 +1715,22 @@ static void fini_compiler (hcl_t* hcl) hcl->c->cfs.capa = 0; } + if (hcl->c->tv.ptr) + { + hcl_freemem (hcl, hcl->c->tv.ptr); + hcl->c->tv.ptr = HCL_NULL; + hcl->c->tv.size = 0; + hcl->c->tv.capa = 0; + } + + if (hcl->c->blk.tmprcnt) + { + hcl_freemem (hcl, hcl->c->blk.tmprcnt); + hcl->c->blk.tmprcnt = HCL_NULL; + hcl->c->blk.tmprcnt_capa = 0; + hcl->c->blk.depth = -1; + } + clear_io_names (hcl); if (hcl->c->tok.name.ptr) hcl_freemem (hcl, hcl->c->tok.name.ptr); @@ -1755,6 +1776,7 @@ int hcl_attachio (hcl_t* hcl, hcl_ioimpl_t reader, hcl_ioimpl_t printer) hcl->c->r.e = hcl->_nil; hcl->c->cfs.top = -1; + hcl->c->blk.depth = -1; } else if (hcl->c->reader || hcl->c->printer) {