From d497e51b620f33c0fb9d1cbe8ce461c06fdf0974 Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Sat, 25 Apr 2020 18:35:04 +0000 Subject: [PATCH] code for array support in assignment, evaluation, getting reference, deletion --- hawk/lib/run.c | 444 ++++++++++++++++++++++++++++++++-------------- hawk/t/h-001.hawk | 20 ++- 2 files changed, 325 insertions(+), 139 deletions(-) diff --git a/hawk/lib/run.c b/hawk/lib/run.c index a7caf3f7..7e0ddf27 100644 --- a/hawk/lib/run.c +++ b/hawk/lib/run.c @@ -194,7 +194,7 @@ static hawk_val_t* eval_printf (hawk_rtx_t* rtx, hawk_nde_t* nde); static int read_record (hawk_rtx_t* rtx); static hawk_ooch_t* idxnde_to_str (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_ooch_t* buf, hawk_oow_t* len, hawk_nde_t** remidx); -static hawk_ooi_t idxnde_to_int (hawk_rtx_t* rtx, hawk_nde_t* nde); +static hawk_ooi_t idxnde_to_int (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_nde_t** remidx); typedef hawk_val_t* (*binop_func_t) (hawk_rtx_t* rtx, hawk_val_t* left, hawk_val_t* right); typedef hawk_val_t* (*eval_expr_t) (hawk_rtx_t* rtx, hawk_nde_t* nde); @@ -2859,7 +2859,27 @@ static hawk_val_t* assign_newmapval_in_map (hawk_rtx_t* rtx, hawk_map_t* contain return HAWK_NULL; } - HAWK_ASSERT (tmp == HAWK_HTB_VPTR(pair)); + HAWK_ASSERT (tmp == HAWK_MAP_VPTR(pair)); + return tmp; +} + +static hawk_val_t* assign_newmapval_in_arr (hawk_rtx_t* rtx, hawk_arr_t* container, hawk_ooi_t idx) +{ + hawk_val_t* tmp; + hawk_map_pair_t* pair; + + tmp = hawk_rtx_makemapval(rtx); + if (HAWK_UNLIKELY(!tmp)) return HAWK_NULL; + + /* as this is the assignment, it needs to update + * the reference count of the target value. */ + hawk_rtx_refupval (rtx, tmp); + if (HAWK_UNLIKELY(hawk_arr_upsert(container, idx, tmp, 0) == HAWK_VAL_NIL)) + { + hawk_rtx_refdownval (rtx, tmp); /* decrement upon upsert() failure */ + return HAWK_NULL; + } + return tmp; } @@ -2976,42 +2996,64 @@ static hawk_val_t* assign_newmapval_to_var (hawk_rtx_t* rtx, hawk_nde_var_t* var } -static int delete_indexed_in_map (hawk_rtx_t* rtx, hawk_val_t* vv, hawk_nde_var_t* var) +static HAWK_INLINE int delete_indexed (hawk_rtx_t* rtx, hawk_val_t* vv, hawk_nde_var_t* var) { hawk_map_t* map; hawk_ooch_t* str = HAWK_NULL; hawk_oow_t len; hawk_ooch_t idxbuf[IDXBUFSIZE]; + hawk_arr_t* arr; + hawk_ooi_t idx; + hawk_nde_t* remidx; hawk_val_type_t vtype; HAWK_ASSERT (var->idx != HAWK_NULL); - HAWK_ASSERT (HAWK_RTX_GETVALTYPE(rtx, vv) == HAWK_VAL_MAP); /* delete x["abc"]; * delete x[20,"abc"]; */ - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops; - map = ((hawk_val_map_t*)vv)->map; + vtype = HAWK_RTX_GETVALTYPE(rtx, vv); + if (vtype == HAWK_VAL_MAP) + { + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops; + map = ((hawk_val_map_t*)vv)->map; + } + else + { + HAWK_ASSERT (vtype == HAWK_VAL_ARR); + idx = idxnde_to_int(rtx, var->idx, &remidx); + if (HAWK_UNLIKELY(idx <= -1)) goto oops; + arr = ((hawk_val_arr_t*)vv)->arr; + } #if defined(HAWK_ENABLE_GC) while (remidx) { - hawk_map_pair_t* pair; + hawk_val_type_t container_vtype; - pair = hawk_map_search(map, str, len); - - vv = pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil; + if (vtype == HAWK_VAL_MAP) + { + hawk_map_pair_t* pair; + pair = hawk_map_search(map, str, len); + vv = pair? (hawk_val_t*)HAWK_MAP_VPTR(pair): hawk_val_nil; + } + else + { + vv = (idx < HAWK_ARR_SIZE(arr) && HAWK_ARR_SLOT(arr, idx))? ((hawk_val_t*)HAWK_ARR_DPTR(arr, idx)): hawk_val_nil; + } + container_vtype = vtype; vtype = HAWK_RTX_GETVALTYPE(rtx, vv); switch (vtype) { case HAWK_VAL_NIL: remidx_nil_to_map: - vv = assign_newmapval_in_map(rtx, map, str, len); - if (HAWK_UNLIKELY(!vv)) goto oops; + vv = container_vtype == HAWK_VAL_MAP? assign_newmapval_in_map(rtx, map, str, len): assign_newmapval_in_arr(rtx, arr, idx); + if (HAWK_UNLIKELY(!vv)) { ADJERR_LOC(rtx, &var->loc); goto oops; } + vtype = HAWK_RTX_GETVALTYPE(rtx, vv); map = ((hawk_val_map_t*)vv)->map; break; @@ -3019,6 +3061,10 @@ static int delete_indexed_in_map (hawk_rtx_t* rtx, hawk_val_t* vv, hawk_nde_var_ map = ((hawk_val_map_t*)vv)->map; break; + case HAWK_VAL_ARR: + arr = ((hawk_val_arr_t*)vv)->arr; + break; + default: if (rtx->hawk->opt.trait & HAWK_FLEXMAP) { @@ -3031,44 +3077,35 @@ static int delete_indexed_in_map (hawk_rtx_t* rtx, hawk_val_t* vv, hawk_nde_var_ } } - if (str != idxbuf) hawk_rtx_freemem (rtx, str); - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops; - - pair = hawk_map_search(map, str, len); + if (str && str != idxbuf) { hawk_rtx_freemem (rtx, str); str = HAWK_NULL; } + if (vtype == HAWK_VAL_MAP) + { + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops; + } + else + { + idx = idxnde_to_int(rtx, remidx, &remidx); + if (HAWK_UNLIKELY(idx <= -1)) goto oops; + arr = ((hawk_val_arr_t*)vv)->arr; + } } #endif - hawk_map_delete (map, str, len); + if (vtype == HAWK_VAL_MAP) + hawk_map_delete (map, str, len); + else + hawk_arr_delete (arr, idx, 1); - if (str != idxbuf) hawk_rtx_freemem (rtx, str); + if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); return 0; oops: if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); - ADJERR_LOC (rtx, &var->loc); return -1; } -static int delete_indexed_in_arr (hawk_rtx_t* rtx, hawk_val_t* vv, hawk_nde_var_t* var) -{ - hawk_arr_t* arr; - hawk_ooi_t idx; - - HAWK_ASSERT (var->idx != HAWK_NULL); - HAWK_ASSERT (HAWK_RTX_GETVALTYPE(rtx, vv) == HAWK_VAL_ARR); - - idx = idxnde_to_int(rtx, var->idx); - if (HAWK_UNLIKELY(idx <= -1)) return -1; - - arr = ((hawk_val_arr_t*)vv)->arr; - - /* no bound check because hawk_arr_delete() performs sanity check */ - hawk_arr_delete (arr, idx, 1); - return 0; -} - static int run_delete (hawk_rtx_t* rtx, hawk_nde_delete_t* nde) { hawk_nde_var_t* var; @@ -3092,7 +3129,7 @@ static int run_delete (hawk_rtx_t* rtx, hawk_nde_delete_t* nde) if (var->type == HAWK_NDE_NAMEDIDX || var->type == HAWK_NDE_GBLIDX || var->type == HAWK_NDE_LCLIDX || var->type == HAWK_NDE_ARGIDX) { - if (delete_indexed_in_map(rtx, val, var) <= -1) goto oops; + if (delete_indexed(rtx, val, var) <= -1) goto oops; } else { @@ -3113,7 +3150,7 @@ static int run_delete (hawk_rtx_t* rtx, hawk_nde_delete_t* nde) if (var->type == HAWK_NDE_NAMEDIDX || var->type == HAWK_NDE_GBLIDX || var->type == HAWK_NDE_LCLIDX || var->type == HAWK_NDE_ARGIDX) { - if (delete_indexed_in_arr(rtx, val, var) <= -1) goto oops; + if (delete_indexed(rtx, val, var) <= -1) goto oops; } else { @@ -3943,7 +3980,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* rtx, hawk_nde_var_t* var, h static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk_val_t* val) { - hawk_map_t* map; + hawk_val_t* vv; /* existing value pointed to by var */ hawk_val_type_t vtype; @@ -3966,38 +4003,62 @@ static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk nil_to_map: vv = assign_newmapval_to_var(rtx, var); if (HAWK_UNLIKELY(!vv)) return HAWK_NULL; + vtype = HAWK_RTX_GETVALTYPE(rtx, vv); /* it must be HAWK_VAL_MAP */ /* fall thru */ case HAWK_VAL_MAP: + case HAWK_VAL_ARR: { + hawk_map_t* map; hawk_ooch_t* str = HAWK_NULL; hawk_oow_t len; hawk_ooch_t idxbuf[IDXBUFSIZE]; + + hawk_ooi_t idx; + hawk_arr_t* arr; + hawk_nde_t* remidx; - /* nothing to do */ - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops_map; - - map = ((hawk_val_map_t*)vv)->map; + if (vtype == HAWK_VAL_MAP) + { + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops_map; + map = ((hawk_val_map_t*)vv)->map; + } + else + { + idx = idxnde_to_int(rtx, var->idx, &remidx); + if (idx <= -1) return HAWK_NULL; + arr = ((hawk_val_arr_t*)vv)->arr; + } #if defined(HAWK_ENABLE_GC) while (remidx) { - hawk_map_pair_t* pair; + hawk_val_type_t container_vtype; - pair = hawk_map_search(map, str, len); + if (vtype == HAWK_VAL_MAP) + { + hawk_map_pair_t* pair; + pair = hawk_map_search(map, str, len); + vv = pair? (hawk_val_t*)HAWK_MAP_VPTR(pair): hawk_val_nil; + } + else + { + vv = (idx < HAWK_ARR_SIZE(arr) && HAWK_ARR_SLOT(arr, idx))? ((hawk_val_t*)HAWK_ARR_DPTR(arr, idx)): hawk_val_nil; + } - vv = pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil; + container_vtype = vtype; vtype = HAWK_RTX_GETVALTYPE(rtx, vv); switch (vtype) { case HAWK_VAL_NIL: remidx_nil_to_map: - vv = assign_newmapval_in_map(rtx, map, str, len); + vv = container_vtype == HAWK_VAL_MAP? assign_newmapval_in_map(rtx, map, str, len): assign_newmapval_in_arr(rtx, arr, idx); if (HAWK_UNLIKELY(!vv)) goto oops_map; + vtype = HAWK_RTX_GETVALTYPE(rtx, vv); /* it must be HAWK_VAL_MAP */ map = ((hawk_val_map_t*)vv)->map; break; @@ -4005,6 +4066,10 @@ static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk map = ((hawk_val_map_t*)vv)->map; break; + case HAWK_VAL_ARR: + arr = ((hawk_val_arr_t*)vv)->arr; + break; + default: if (rtx->hawk->opt.trait & HAWK_FLEXMAP) { @@ -4024,10 +4089,19 @@ static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk } } - if (str != idxbuf) hawk_rtx_freemem (rtx, str); - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops_map; + if (vtype == HAWK_VAL_MAP) + { + if (str != idxbuf) hawk_rtx_freemem (rtx, str); + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops_map; + } + else + { + idx = idxnde_to_int(rtx, remidx, &remidx); + if (idx <= -1) return HAWK_NULL; + arr = ((hawk_val_arr_t*)vv)->arr; + } } #endif @@ -4035,9 +4109,16 @@ static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk hawk_logfmt (hawk_rtx_gethawk(rtx), HAWK_T("**** index str=>%s, map->ref=%d, map->type=%d\n"), str, (int)v->ref, (int)v->type); #endif - if (HAWK_UNLIKELY(hawk_map_upsert(map, str, len, val, 0) == HAWK_NULL)) goto oops_map; + if (vtype == HAWK_VAL_MAP) + { + if (HAWK_UNLIKELY(hawk_map_upsert(map, str, len, val, 0) == HAWK_NULL)) goto oops_map; + } + else + { + if (HAWK_UNLIKELY(hawk_arr_upsert(arr, idx, val, 0) == HAWK_ARR_NIL)) goto oops_map; + } - if (str != idxbuf) hawk_rtx_freemem (rtx, str); + if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); hawk_rtx_refupval (rtx, val); return val; @@ -4047,25 +4128,6 @@ static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk return HAWK_NULL; } - case HAWK_VAL_ARR: - { - /* multiple indeics in a single bracket is not allowed. e.g. x[1,2] not allowed */ - hawk_ooi_t idx; - hawk_arr_t* arr; - - idx = idxnde_to_int(rtx, var->idx); - if (idx <= -1) return HAWK_NULL; - - arr = ((hawk_val_arr_t*)vv)->arr; - if (HAWK_UNLIKELY(hawk_arr_upsert(arr, idx, val, 0) == HAWK_ARR_NIL)) - { - ADJERR_LOC (rtx, &var->loc); - return HAWK_NULL; - } - hawk_rtx_refupval (rtx, val); - return val; - } - default: if (rtx->hawk->opt.trait & HAWK_FLEXMAP) { @@ -6666,10 +6728,13 @@ static int get_reference (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_val_t*** ref) static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* var) { hawk_map_t* map; - hawk_map_pair_t* pair; hawk_ooch_t* str = HAWK_NULL; hawk_oow_t len; hawk_ooch_t idxbuf[IDXBUFSIZE]; + + hawk_arr_t* arr; + hawk_ooi_t idx; + hawk_val_t* v; hawk_val_type_t vtype; hawk_nde_t* remidx; @@ -6684,9 +6749,11 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* var) case HAWK_VAL_NIL: v = assign_newmapval_to_var(rtx, var); if (HAWK_UNLIKELY(!v)) goto oops; + vtype = HAWK_RTX_GETVALTYPE(rtx, v); break; - + case HAWK_VAL_MAP: + case HAWK_VAL_ARR: /* do nothing */ break; @@ -6695,24 +6762,44 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* var) goto oops; } - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops; - - map = ((hawk_val_map_t*)v)->map; + if (vtype == HAWK_VAL_MAP) + { + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops; + map = ((hawk_val_map_t*)v)->map; + } + else + { + idx = idxnde_to_int(rtx, var->idx, &remidx); + if (HAWK_UNLIKELY(idx <= -1)) goto oops; + arr = ((hawk_val_arr_t*)v)->arr; + } #if defined(HAWK_ENABLE_GC) while (remidx) { - pair = hawk_map_search(map, str, len); - v = pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil; + hawk_val_type_t container_vtype; + + if (vtype == HAWK_VAL_MAP) + { + hawk_map_pair_t* pair; + pair = hawk_map_search(map, str, len); + v = pair? (hawk_val_t*)HAWK_MAP_VPTR(pair): hawk_val_nil; + } + else + { + v = (idx < HAWK_ARR_SIZE(arr) && HAWK_ARR_SLOT(arr, idx))? ((hawk_val_t*)HAWK_ARR_DPTR(arr, idx)): hawk_val_nil; + } + container_vtype = vtype; vtype = HAWK_RTX_GETVALTYPE(rtx, v); switch (vtype) { case HAWK_VAL_NIL: - v = assign_newmapval_in_map(rtx, map, str, len); + v = container_vtype == HAWK_VAL_MAP? assign_newmapval_in_map(rtx, map, str, len): assign_newmapval_in_arr(rtx, arr, idx); if (HAWK_UNLIKELY(!v)) goto oops; + vtype = HAWK_RTX_GETVALTYPE(rtx, v); map = ((hawk_val_map_t*)v)->map; break; @@ -6720,30 +6807,58 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* var) map = ((hawk_val_map_t*)v)->map; break; + case HAWK_VAL_ARR: + arr = ((hawk_val_arr_t*)v)->arr; + break; + default: hawk_rtx_seterrnum (rtx, &var->loc, HAWK_ENOTMAP); goto oops; } - if (str != idxbuf) hawk_rtx_freemem (rtx, str); - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops; + if (str && str != idxbuf) { hawk_rtx_freemem (rtx, str); str = HAWK_NULL; } + + if (vtype == HAWK_VAL_MAP) + { + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops; + } + else + { + idx = idxnde_to_int(rtx, remidx, &remidx); + if (HAWK_UNLIKELY(idx <= -1)) goto oops; + } } #endif - pair = hawk_map_search(map, str, len); - if (!pair) + if (vtype == HAWK_VAL_MAP) { - pair = hawk_map_upsert(map, str, len, hawk_val_nil, 0); - if (HAWK_UNLIKELY(!pair)) goto oops; - HAWK_ASSERT (HAWK_HTB_VPTR(pair) == hawk_val_nil); - /* no reference count increment as hawk_val_nil is upserted - hawk_rtx_refupval (rtx, HAWK_HTB_VPTR(pair)); */ - } + hawk_map_pair_t* pair; + pair = hawk_map_search(map, str, len); + if (!pair) + { + /* if the value doesn't exist for the given key, insert a nil for it to create a placeholder for the reference */ + pair = hawk_map_upsert(map, str, len, hawk_val_nil, 0); + if (HAWK_UNLIKELY(!pair)) goto oops; + HAWK_ASSERT (HAWK_MAP_VPTR(pair) == hawk_val_nil); + /* no reference count increment as hawk_val_nil is upserted + hawk_rtx_refupval (rtx, HAWK_MAP_VPTR(pair)); */ + } - if (str != idxbuf) hawk_rtx_freemem (rtx, str); - return (hawk_val_t**)&HAWK_HTB_VPTR(pair); + if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); + return (hawk_val_t**)&HAWK_MAP_VPTR(pair); + } + else + { + if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); + if (idx >= HAWK_ARR_SIZE(arr) || !HAWK_ARR_SLOT(arr, idx)) + { + /* if the value doesn't exist for the given index, insert a nil at that position to create a placeholder for the reference */ + if (HAWK_UNLIKELY(hawk_arr_upsert (arr, idx, hawk_val_nil, 0) == HAWK_ARR_NIL)) goto oops; + } + return (hawk_val_t**)&HAWK_ARR_DPTR(arr, idx); + } oops: if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); @@ -6860,37 +6975,81 @@ static hawk_val_t* eval_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* var) case HAWK_VAL_NIL: v = assign_newmapval_to_var(rtx, var); if (HAWK_UNLIKELY(!v)) return HAWK_NULL; + vtype = HAWK_RTX_GETVALTYPE(rtx, v); /* fall thru */ case HAWK_VAL_MAP: + case HAWK_VAL_ARR: { hawk_map_t* map; /* containing map */ hawk_map_pair_t* pair; + hawk_ooch_t* str = HAWK_NULL; hawk_oow_t len; hawk_ooch_t idxbuf[IDXBUFSIZE]; + + hawk_arr_t* arr; /* containing array */ + hawk_ooi_t idx; + hawk_nde_t* remidx; HAWK_ASSERT (var->idx != HAWK_NULL); - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops_map; - - map = ((hawk_val_map_t*)v)->map; - pair = hawk_map_search(map, str, len); + if (vtype == HAWK_VAL_MAP) + { + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops; + map = ((hawk_val_map_t*)v)->map; + pair = hawk_map_search(map, str, len); + } + else + { + idx = idxnde_to_int(rtx, var->idx, &remidx); + if (idx <= -1) goto oops; + arr = ((hawk_val_arr_t*)v)->arr; + } #if defined(HAWK_ENABLE_GC) while (remidx) { - v = pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil; + hawk_val_type_t container_vtype; + + if (vtype == HAWK_VAL_MAP) + { + v = pair? (hawk_val_t*)HAWK_MAP_VPTR(pair): hawk_val_nil; + } + else + { + v = (idx < HAWK_ARR_SIZE(arr) && HAWK_ARR_SLOT(arr, idx))? ((hawk_val_t*)HAWK_ARR_DPTR(arr, idx)): hawk_val_nil; + } + container_vtype = vtype; vtype = HAWK_RTX_GETVALTYPE(rtx, v); + +/* +a[10] = hawk::array(); + +print typename(a[10][40][50]); +print typename(a[10][40]); +* +* +a[10] = hawk::array(); +a[10][40] = hawk::array(); +a[10][40][5] = hawk::array(); +* +* +a = hawk::array( + hawk::array(10, 20, 30), + hawk::array(99, 99, 99, 88, 77) +); +*/ switch (vtype) { case HAWK_VAL_NIL: - v = assign_newmapval_in_map(rtx, map, str, len); - if (HAWK_UNLIKELY(!v)) goto oops_map; + v = container_vtype == HAWK_VAL_MAP? assign_newmapval_in_map(rtx, map, str, len): assign_newmapval_in_arr(rtx, arr, idx); /* TODO: should i do assign_newarrval_in_arr(rtx, arr, idx)? instead??? */ + if (HAWK_UNLIKELY(!v)) goto oops; + vtype = HAWK_RTX_GETVALTYPE(rtx, v); /* it must be HAWK_VAL_MAP */ map = ((hawk_val_map_t*)v)->map; break; @@ -6898,45 +7057,53 @@ static hawk_val_t* eval_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* var) map = ((hawk_val_map_t*)v)->map; break; + case HAWK_VAL_ARR: + arr = ((hawk_val_arr_t*)v)->arr; + break; + default: hawk_rtx_seterrnum (rtx, &var->loc, HAWK_ENOTMAP); - goto oops_map; + goto oops; } - if (str != idxbuf) hawk_rtx_freemem (rtx, str); - len = HAWK_COUNTOF(idxbuf); - str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); - if (HAWK_UNLIKELY(!str)) goto oops_map; + if (str && str != idxbuf) { hawk_rtx_freemem (rtx, str); str = HAWK_NULL; } - pair = hawk_map_search(map, str, len); + if (vtype == HAWK_VAL_MAP) + { + len = HAWK_COUNTOF(idxbuf); + str = idxnde_to_str(rtx, remidx, idxbuf, &len, &remidx); + if (HAWK_UNLIKELY(!str)) goto oops; + pair = hawk_map_search(map, str, len); + } + else + { + idx = idxnde_to_int(rtx, remidx, &remidx); + if (idx <= -1) goto oops; + arr = ((hawk_val_arr_t*)v)->arr; + } } #endif - if (str != idxbuf) hawk_rtx_freemem (rtx, str); - return pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil; + if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); + if (vtype == HAWK_VAL_MAP) + { + return pair? (hawk_val_t*)HAWK_MAP_VPTR(pair): hawk_val_nil; + } + else + { + /* return nil if the index is out of range or the element at the index is not set. + * no check for a negative index as it's guaranteed to be positive by idxnde_to_int() */ + return (idx < HAWK_ARR_SIZE(arr) && HAWK_ARR_SLOT(arr, idx))? ((hawk_val_t*)HAWK_ARR_DPTR(arr, idx)): hawk_val_nil; + } - oops_map: + oops: if (str && str != idxbuf) hawk_rtx_freemem (rtx, str); ADJERR_LOC (rtx, &var->loc); return HAWK_NULL; } - case HAWK_VAL_ARR: - { - hawk_arr_t* arr; /* containing array */ - hawk_ooi_t idx; - - idx = idxnde_to_int(rtx, var->idx); - if (idx <= -1) return HAWK_NULL; - - arr = ((hawk_val_arr_t*)v)->arr; - /* return nil if the index is out of range or the element at the index is not set. - * no check for a negative index as it's guaranteed to be positive by idxnde_to_int() */ - return (idx < HAWK_ARR_SIZE(arr) && HAWK_ARR_SLOT(arr, idx))? ((hawk_val_t*)HAWK_ARR_DPTR(arr, idx)): hawk_val_nil; - } - default: - hawk_rtx_seterrnum (rtx, &var->loc, HAWK_ENOTMAP); + hawk_rtx_seterrnum (rtx, &var->loc, HAWK_ENOTMAP); /* TODO: change error code... ENOTINDEXABLE, not map or not array */ return HAWK_NULL; } } @@ -7394,13 +7561,13 @@ static hawk_ooch_t* idxnde_to_str (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_ooch_t return str; } -static hawk_ooi_t idxnde_to_int (hawk_rtx_t* rtx, hawk_nde_t* nde) +static hawk_ooi_t idxnde_to_int (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_nde_t** remidx) { hawk_int_t v; hawk_val_t* tmp; int n; - if (nde->next) + if (nde->next && nde->next->type != HAWK_NDE_NULL) { /* multidimensional indices inside a single brakcet is not allowed for an array */ hawk_rtx_seterrnum (rtx, &nde->loc, HAWK_EARRIDXMULTI); @@ -7426,6 +7593,7 @@ static hawk_ooi_t idxnde_to_int (hawk_rtx_t* rtx, hawk_nde_t* nde) return -1; } + *remidx = nde->next? nde->next->next: HAWK_NULL; return (hawk_ooi_t)v; } diff --git a/hawk/t/h-001.hawk b/hawk/t/h-001.hawk index 8c635621..cb08323e 100644 --- a/hawk/t/h-001.hawk +++ b/hawk/t/h-001.hawk @@ -23,9 +23,13 @@ function call_by_ref_2(a, &b) return a; } +function call_by_ref_3(&x) +{ + x = "hello world"; +} + function main() { - x = 20; y = 90; r = call_by_ref_1(x, y, z); @@ -73,5 +77,19 @@ function main() ensure (a[1][2], 20, SCRIPTNAME); } + { + @local a; + a = hawk::array(); + a[10] = "good"; + call_by_ref_3(a[9]); + ensure (a[10], "good", SCRIPTNAME); + ensure (a[9], "hello world", SCRIPTNAME); + call_by_ref_3(a[10]); + ensure (a[10], "hello world", SCRIPTNAME); + ensure (a[9], "hello world", SCRIPTNAME); + } + + + print "SUCCESS" }