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

more true multidimensional map work

Browse Source
This commit is contained in:
hyung-hwan 2020-04-03 17:56:04 +00:00
parent 9d40f45092
commit 82eac76de4
1 changed files with 138 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

500
hawk/lib/run.c
View File

@ -2885,88 +2885,110 @@ static hawk_val_t* assign_newmapval_in_map (hawk_rtx_t* rtx, hawk_map_t* contain
return tmp;
}
static hawk_val_t* assign_newmapval_in_htb (hawk_rtx_t* rtx, hawk_htb_t* container, hawk_ooch_t* idxptr, hawk_oow_t idxlen)
static hawk_val_t* fetch_topval_from_var (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
hawk_val_t* tmp;
hawk_htb_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);
pair = hawk_htb_upsert(container, idxptr, idxlen, tmp, 0);
if (HAWK_UNLIKELY(!pair))
{
hawk_rtx_refdownval (rtx, tmp); /* decrement upon upsert() failure */
return HAWK_NULL;
}
HAWK_ASSERT (tmp == HAWK_HTB_VPTR(pair));
return tmp;
}
static hawk_val_t* assign_newmapval_in_varidx (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
hawk_val_t* tmp;
HAWK_ASSERT (var->type >= HAWK_NDE_NAMEDIDX && var->type <= HAWK_NDE_ARGIDX);
tmp = hawk_rtx_makemapval(rtx);
if (HAWK_UNLIKELY(!tmp)) return HAWK_NULL;
hawk_val_t* val;
switch (var->type)
{
case HAWK_NDE_NAMED:
case HAWK_NDE_NAMEDIDX:
{
hawk_htb_pair_t* pair;
pair = hawk_htb_search(rtx->named, var->id.name.ptr, var->id.name.len);
val = pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil;
break;
}
case HAWK_NDE_GBL:
case HAWK_NDE_GBLIDX:
val = HAWK_RTX_STACK_GBL(rtx,var->id.idxa);
break;
case HAWK_NDE_LCL:
case HAWK_NDE_LCLIDX:
val = HAWK_RTX_STACK_LCL(rtx,var->id.idxa);
break;
default:
HAWK_ASSERT (var->type == HAWK_NDE_ARG || var->type == HAWK_NDE_ARGIDX);
val = HAWK_RTX_STACK_ARG(rtx,var->id.idxa);
break;
}
return val;
}
static hawk_val_t* assign_topval_to_var (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk_val_t* val)
{
switch (var->type)
{
case HAWK_NDE_NAMED:
case HAWK_NDE_NAMEDIDX:
{
/* doesn't have to decrease the reference count
* of the previous value here as it is done by
* hawk_htb_upsert */
hawk_rtx_refupval (rtx, tmp);
if (HAWK_UNLIKELY(hawk_htb_upsert(rtx->named, var->id.name.ptr, var->id.name.len, tmp, 0) == HAWK_NULL))
hawk_rtx_refupval (rtx, val);
if (HAWK_UNLIKELY(hawk_htb_upsert(rtx->named, var->id.name.ptr, var->id.name.len, val, 0) == HAWK_NULL))
{
hawk_rtx_refdownval (rtx, tmp);
hawk_rtx_refdownval (rtx, val);
return HAWK_NULL;
}
break;
}
case HAWK_NDE_GBL:
case HAWK_NDE_GBLIDX:
{
int x;
hawk_rtx_refupval (rtx, tmp);
x = hawk_rtx_setgbl(rtx, (int)var->id.idxa, tmp);
hawk_rtx_refdownval (rtx, tmp);
hawk_rtx_refupval (rtx, val);
x = hawk_rtx_setgbl(rtx, (int)var->id.idxa, val);
hawk_rtx_refdownval (rtx, val);
if (HAWK_UNLIKELY(x <= -1)) return HAWK_NULL;
break;
}
case HAWK_NDE_LCL:
case HAWK_NDE_LCLIDX:
{
hawk_val_t* old;
old = HAWK_RTX_STACK_LCL(rtx,var->id.idxa);
hawk_rtx_refdownval (rtx, old);
HAWK_RTX_STACK_LCL(rtx,var->id.idxa) = tmp;
hawk_rtx_refupval (rtx, tmp);
HAWK_RTX_STACK_LCL(rtx,var->id.idxa) = val;
hawk_rtx_refupval (rtx, val);
break;
}
default: /* HAWK_NDE_ARGIDX */
default: /* HAWK_NDE_ARG, HAWK_NDE_ARGIDX */
{
hawk_val_t* old;
old = HAWK_RTX_STACK_ARG(rtx,var->id.idxa);
hawk_rtx_refdownval (rtx, old);
HAWK_RTX_STACK_ARG(rtx,var->id.idxa) = tmp;
hawk_rtx_refupval (rtx, tmp);
HAWK_RTX_STACK_ARG(rtx,var->id.idxa) = val;
hawk_rtx_refupval (rtx, val);
break;
}
}
return tmp;
return val;
}
static hawk_val_t* assign_newmapval_to_var (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
hawk_val_t* tmp;
HAWK_ASSERT (var->type >= HAWK_NDE_NAMED && var->type <= HAWK_NDE_ARGIDX);
tmp = hawk_rtx_makemapval(rtx);
if (HAWK_UNLIKELY(!tmp)) return HAWK_NULL;
return assign_topval_to_var (rtx, var, tmp);
}
static int delete_indexed (hawk_rtx_t* rtx, hawk_val_t* vv, hawk_nde_var_t* var)
{
hawk_map_t* map;
@ -3003,7 +3025,6 @@ static int delete_indexed (hawk_rtx_t* rtx, hawk_val_t* vv, hawk_nde_var_t* var)
remidx_nil_to_map:
vv = assign_newmapval_in_map(rtx, map, str, len);
if (HAWK_UNLIKELY(!vv)) goto oops;
map = ((hawk_val_map_t*)vv)->map;
break;
@ -3043,186 +3064,49 @@ oops:
return -1;
}
#if 0
static int delete_indexed_xxx (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
if (var->type == HAWK_NDE_NAMEDIDX)
{
/* indexed delete.. */
}
else
{
hawk_htb_pair_t* pair;
/* clear the entire variable */
pair = hawk_htb_search(rtx->named, var->id.name.ptr, var->id.name.len);
if (pair == HAWK_NULL)
{
if (assign_newmapval_in_htb(rtx, rtx->named, var->id.name.ptr, var->id.name.len) == HAWK_NULL) goto oops;
}
else
{
hawk_val_t* val;
val = (hawk_val_t*)HAWK_HTB_VPTR(pair);
if (HAWK_RTX_GETVALTYPE(rtx, val) == HAWK_VAL_MAP)
{
hawk_map_clear (((hawk_val_map_t*)val)->map);
}
else
{
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_ENOTDEL, HAWK_T("'%.*js' not deletable"), var->id.name.len, var->id.name.ptr);
goto oops;
}
}
}
return 0;
oops:
ADJERR_LOC (rtx, &var->loc);
return -1;
}
#endif
static int run_delete_named (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
hawk_htb_pair_t* pair;
/* if a named variable has an index part and a named indexed variable
* doesn't have an index part, the program is definitely wrong */
HAWK_ASSERT (
(var->type == HAWK_NDE_NAMED && var->idx == HAWK_NULL) ||
(var->type == HAWK_NDE_NAMEDIDX && var->idx != HAWK_NULL));
pair = hawk_htb_search(rtx->named, var->id.name.ptr, var->id.name.len);
if (pair == HAWK_NULL)
{
if (assign_newmapval_in_htb(rtx, rtx->named, var->id.name.ptr, var->id.name.len) == HAWK_NULL) goto oops;
}
else
{
hawk_val_t* val;
val = (hawk_val_t*)HAWK_HTB_VPTR(pair);
HAWK_ASSERT (val != HAWK_NULL);
if (HAWK_RTX_GETVALTYPE(rtx, val) != HAWK_VAL_MAP)
{
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_ENOTDEL, HAWK_T("'%.*js' not deletable"), var->id.name.len, var->id.name.ptr);
goto oops;
}
if (var->type == HAWK_NDE_NAMEDIDX)
{
if (delete_indexed(rtx, val, var) <= -1) goto oops;
}
else
{
hawk_map_clear (((hawk_val_map_t*)val)->map);
}
}
return 0;
oops:
ADJERR_LOC (rtx, &var->loc);
return -1;
}
static int run_delete_unnamed (hawk_rtx_t* rtx, hawk_nde_var_t* var)
static int run_delete (hawk_rtx_t* rtx, hawk_nde_delete_t* nde)
{
hawk_nde_var_t* var;
hawk_val_t* val;
hawk_val_type_t vtype;
switch (var->type)
{
case HAWK_NDE_GBL:
case HAWK_NDE_GBLIDX:
val = HAWK_RTX_STACK_GBL(rtx,var->id.idxa);
break;
case HAWK_NDE_LCL:
case HAWK_NDE_LCLIDX:
val = HAWK_RTX_STACK_LCL(rtx,var->id.idxa);
break;
default:
val = HAWK_RTX_STACK_ARG(rtx,var->id.idxa);
break;
}
var = (hawk_nde_var_t*)nde->var;
val = fetch_topval_from_var(rtx, var);
HAWK_ASSERT (val != HAWK_NULL);
vtype = HAWK_RTX_GETVALTYPE(rtx, val);
if (vtype == HAWK_VAL_NIL)
switch (vtype)
{
case HAWK_VAL_NIL:
/* value not set. create a map and assign it to the variable */
if (HAWK_UNLIKELY(assign_newmapval_to_var(rtx, var) == HAWK_NULL)) goto oops;
break;
hawk_val_t* tmp;
/* value not set.
* create a map and assign it to the variable */
tmp = hawk_rtx_makemapval(rtx);
if (HAWK_UNLIKELY(!tmp)) goto oops;
/* no need to reduce the reference count of
* the previous value because it was nil. */
switch (var->type)
{
case HAWK_NDE_GBL:
case HAWK_NDE_GBLIDX:
case HAWK_VAL_MAP:
if (var->type == HAWK_NDE_NAMEDIDX || var->type == HAWK_NDE_GBLIDX ||
var->type == HAWK_NDE_LCLIDX || var->type == HAWK_NDE_ARGIDX)
{
int x;
hawk_rtx_refupval (rtx, tmp);
x = hawk_rtx_setgbl(rtx, (int)var->id.idxa, tmp);
hawk_rtx_refdownval (rtx, tmp);
if (HAWK_UNLIKELY(x <= -1)) goto oops;
break;
if (delete_indexed(rtx, val, var) <= -1) goto oops;
}
else
{
/*
BEGIN {
@local a;
a[1] = 20; a[2] = "hello"; a[3][4][5]="ttt";
print typename(a), length(a);
delete a;
print typename(a), length(a);
}
*/
hawk_map_clear (((hawk_val_map_t*)val)->map);
}
break;
case HAWK_NDE_LCL:
case HAWK_NDE_LCLIDX:
HAWK_RTX_STACK_LCL(rtx,var->id.idxa) = tmp;
hawk_rtx_refupval (rtx, tmp);
break;
default:
HAWK_RTX_STACK_ARG(rtx,var->id.idxa) = tmp;
hawk_rtx_refupval (rtx, tmp);
break;
}
}
else
{
if (vtype != HAWK_VAL_MAP)
{
default:
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_ENOTDEL, HAWK_T("'%.*js' not deletable"), var->id.name.len, var->id.name.ptr);
goto oops;
}
if (var->type == HAWK_NDE_GBLIDX ||
var->type == HAWK_NDE_LCLIDX ||
var->type == HAWK_NDE_ARGIDX)
{
if (delete_indexed(rtx, val, var) <= -1) goto oops;
}
else
{
/*
BEGIN {
@local a;
a[1] = 20; a[2] = "hello"; a[3][4][5]="ttt";
print typename(a), length(a);
delete a;
print typename(a), length(a);
}
*/
hawk_map_clear (((hawk_val_map_t*)val)->map);
}
}
return 0;
@ -3230,48 +3114,24 @@ static int run_delete_unnamed (hawk_rtx_t* rtx, hawk_nde_var_t* var)
oops:
ADJERR_LOC (rtx, &var->loc);
return -1;
}
static int run_delete (hawk_rtx_t* rtx, hawk_nde_delete_t* nde)
static int run_reset (hawk_rtx_t* rtx, hawk_nde_reset_t* nde)
{
hawk_nde_var_t* var;
var = (hawk_nde_var_t*)nde->var;
switch (var->type)
{
case HAWK_NDE_NAMED:
case HAWK_NDE_NAMEDIDX:
return run_delete_named(rtx, var);
HAWK_ASSERT (var->type >= HAWK_NDE_NAMED && var->type <= HAWK_NDE_ARG);
case HAWK_NDE_GBL:
case HAWK_NDE_LCL:
case HAWK_NDE_ARG:
case HAWK_NDE_GBLIDX:
case HAWK_NDE_LCLIDX:
case HAWK_NDE_ARGIDX:
return run_delete_unnamed(rtx, var);
default:
/* the delete statement cannot be called with other nodes than
* the variables such as a named variable, a named indexed variable, etc */
HAWK_ASSERT (!"should never happen - wrong target for delete");
hawk_rtx_seterrnum (rtx, &var->loc, HAWK_EBADARG);
return -1;
}
}
static int reset_variable (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
switch (var->type)
{
case HAWK_NDE_NAMED:
/* if a named variable has an index part, something is definitely wrong */
HAWK_ASSERT (var->type == HAWK_NDE_NAMED && var->idx == HAWK_NULL);
HAWK_ASSERT (var->idx == HAWK_NULL);
/* a named variable can be reset if removed from a internal map
to manage it */
/* a named variable can be reset if removed from the internal map to manage it */
hawk_htb_delete (rtx->named, var->id.name.ptr, var->id.name.len);
return 0;
@ -3281,58 +3141,26 @@ static int reset_variable (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
hawk_val_t* val;
switch (var->type)
{
case HAWK_NDE_GBL:
val = HAWK_RTX_STACK_GBL(rtx,var->id.idxa);
break;
case HAWK_NDE_LCL:
val = HAWK_RTX_STACK_LCL(rtx,var->id.idxa);
break;
case HAWK_NDE_ARG:
val = HAWK_RTX_STACK_ARG(rtx,var->id.idxa);
break;
}
HAWK_ASSERT (var->idx == HAWK_NULL);
val = fetch_topval_from_var(rtx, var);
HAWK_ASSERT (val != HAWK_NULL);
if (HAWK_RTX_GETVALTYPE (rtx, val) != HAWK_VAL_NIL)
if (HAWK_RTX_GETVALTYPE(rtx, val) != HAWK_VAL_NIL)
{
hawk_rtx_refdownval (rtx, val);
switch (var->type)
{
case HAWK_NDE_GBL:
HAWK_RTX_STACK_GBL(rtx,var->id.idxa) = hawk_val_nil;
break;
case HAWK_NDE_LCL:
HAWK_RTX_STACK_LCL(rtx,var->id.idxa) = hawk_val_nil;
break;
case HAWK_NDE_ARG:
HAWK_RTX_STACK_ARG(rtx,var->id.idxa) = hawk_val_nil;
break;
}
assign_topval_to_var(rtx, var, hawk_val_nil); /* this must not fail */
}
return 0;
}
default:
/* the reset statement can only be called with plain variables */
HAWK_ASSERT (!"should never happen - wrong target for reset");
HAWK_ASSERT (!"should never happen - wrong target for @reset");
hawk_rtx_seterrnum (rtx, &var->loc, HAWK_EBADARG);
return -1;
}
}
static int run_reset (hawk_rtx_t* rtx, hawk_nde_reset_t* nde)
{
return reset_variable (rtx, (hawk_nde_var_t*)nde->var);
}
static hawk_val_t* io_nde_to_str(hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_oocs_t* dst, int seterr)
{
@ -4105,36 +3933,14 @@ static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk
HAWK_ASSERT (HAWK_RTX_GETVALTYPE(rtx, val) != HAWK_VAL_MAP);
#endif
retry:
switch (var->type)
{
case HAWK_NDE_NAMEDIDX:
{
hawk_htb_pair_t* pair;
pair = hawk_htb_search(rtx->named, var->id.name.ptr, var->id.name.len);
vv = (pair == HAWK_NULL)? hawk_val_nil: HAWK_HTB_VPTR(pair);
break;
}
case HAWK_NDE_GBLIDX:
vv = HAWK_RTX_STACK_GBL(rtx,var->id.idxa);
break;
case HAWK_NDE_LCLIDX:
vv = HAWK_RTX_STACK_LCL(rtx,var->id.idxa);
break;
default: /* HAWK_NDE_ARGIDX */
vv = HAWK_RTX_STACK_ARG(rtx,var->id.idxa);
break;
}
/* check the value that the assigned variable points to */
vv = fetch_topval_from_var(rtx, var);
vtype = HAWK_RTX_GETVALTYPE(rtx, vv);
switch (vtype)
{
case HAWK_VAL_NIL:
vv = assign_newmapval_in_varidx(rtx, var);
nil_to_map:
vv = assign_newmapval_to_var(rtx, var);
if (HAWK_UNLIKELY(!vv)) goto oops;
break;
@ -4146,18 +3952,7 @@ retry:
if (rtx->hawk->opt.trait & HAWK_FLEXMAP)
{
/* if FLEXMAP is on, you can switch a scalar value to a map */
hawk_nde_var_t fake;
/* create a fake non-indexed variable node */
fake = *var;
/* NOTE: type conversion by decrementing by 4 is
* dependent on the hawk_nde_type_t
* enumerators defined in <hawk.h> */
fake.type = var->type - 4;
fake.idx = HAWK_NULL;
reset_variable (rtx, &fake);
goto retry;
goto nil_to_map; /* switch a scalar value to a map */
}
else
{
@ -6710,7 +6505,7 @@ static hawk_oow_t push_arg_from_nde (hawk_rtx_t* rtx, hawk_nde_fncall_t* call, v
v = eval_expression(rtx, p);
}
if (!v)
if (HAWK_UNLIKELY(!v))
{
UNWIND_HAWK_RTX_STACK_ARG (rtx, nargs);
return (hawk_oow_t)-1;
@ -6860,7 +6655,7 @@ 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* nde, hawk_val_t** val)
{
hawk_map_pair_t* pair;
hawk_ooch_t* str;
hawk_ooch_t* str = HAWK_NULL;
hawk_oow_t len;
hawk_ooch_t idxbuf[IDXBUFSIZE];
hawk_val_type_t vtype;
@ -6874,11 +6669,7 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde,
hawk_val_t* tmp;
tmp = hawk_rtx_makemapval(rtx);
if (HAWK_UNLIKELY(!tmp))
{
ADJERR_LOC (rtx, &nde->loc);
return HAWK_NULL;
}
if (HAWK_UNLIKELY(!tmp)) goto oops;
hawk_rtx_refdownval (rtx, *val);
*val = tmp;
@ -6887,31 +6678,34 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde,
else if (vtype != HAWK_VAL_MAP)
{
hawk_rtx_seterrnum (rtx, &nde->loc, HAWK_ENOTMAP);
return HAWK_NULL;
goto oops;
}
HAWK_ASSERT (nde->idx != HAWK_NULL);
len = HAWK_COUNTOF(idxbuf);
str = idxnde_to_str(rtx, nde->idx, idxbuf, &len, &remidx);
if (HAWK_UNLIKELY(!str)) return HAWK_NULL;
if (HAWK_UNLIKELY(!str)) goto oops;
#if defined(HAWK_ENABLE_GC)
/* TODO: true-multidimensional map support */
#endif
pair = hawk_map_search((*(hawk_val_map_t**)val)->map, str, len);
if (!pair)
{
pair = hawk_map_upsert((*(hawk_val_map_t**)val)->map, str, len, hawk_val_nil, 0);
if (HAWK_UNLIKELY(!pair))
{
if (str != idxbuf) hawk_rtx_freemem (rtx, str);
ADJERR_LOC (rtx, &nde->loc);
return HAWK_NULL;
}
if (HAWK_UNLIKELY(!pair)) goto oops;
hawk_rtx_refupval (rtx, HAWK_HTB_VPTR(pair));
}
if (str != idxbuf) hawk_rtx_freemem (rtx, str);
return (hawk_val_t**)&HAWK_HTB_VPTR(pair);
oops:
if (str && str != idxbuf) hawk_rtx_freemem (rtx, str);
ADJERR_LOC (rtx, &nde->loc);
return HAWK_NULL;
}
static hawk_val_t* eval_int (hawk_rtx_t* rtx, hawk_nde_t* nde)
@ -6997,20 +6791,20 @@ static hawk_val_t* eval_named (hawk_rtx_t* rtx, hawk_nde_t* nde)
static hawk_val_t* eval_gbl (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
return HAWK_RTX_STACK_GBL(rtx,((hawk_nde_var_t*)nde)->id.idxa);
return HAWK_RTX_STACK_GBL(rtx, ((hawk_nde_var_t*)nde)->id.idxa);
}
static hawk_val_t* eval_lcl (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
return HAWK_RTX_STACK_LCL(rtx,((hawk_nde_var_t*)nde)->id.idxa);
return HAWK_RTX_STACK_LCL(rtx, ((hawk_nde_var_t*)nde)->id.idxa);
}
static hawk_val_t* eval_arg (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
return HAWK_RTX_STACK_ARG(rtx,((hawk_nde_var_t*)nde)->id.idxa);
return HAWK_RTX_STACK_ARG(rtx, ((hawk_nde_var_t*)nde)->id.idxa);
}
static hawk_val_t* eval_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde, hawk_val_t** val)
static hawk_val_t* eval_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* var)
{
hawk_map_t* map; /* containing map */
hawk_map_pair_t* pair;
@ -7021,33 +6815,29 @@ static hawk_val_t* eval_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde, hawk_val_
hawk_val_type_t vtype;
hawk_nde_t* remidx;
HAWK_ASSERT (val != HAWK_NULL);
v = fetch_topval_from_var(rtx, var);
vtype = HAWK_RTX_GETVALTYPE(rtx, v);
vtype = HAWK_RTX_GETVALTYPE(rtx, *val);
switch (vtype)
{
case HAWK_VAL_NIL:
v = hawk_rtx_makemapval(rtx);
v = assign_newmapval_to_var(rtx, var);
if (HAWK_UNLIKELY(!v)) goto oops;
hawk_rtx_refdownval (rtx, *val);
*val = v;
hawk_rtx_refupval (rtx, (hawk_val_t*)*val);
break;
case HAWK_VAL_MAP:
v = *val;
/* nothing to do */
break;
default:
hawk_rtx_seterrnum (rtx, &nde->loc, HAWK_ENOTMAP);
hawk_rtx_seterrnum (rtx, &var->loc, HAWK_ENOTMAP);
goto oops;
}
HAWK_ASSERT (nde->idx != HAWK_NULL);
HAWK_ASSERT (var->idx != HAWK_NULL);
len = HAWK_COUNTOF(idxbuf);
str = idxnde_to_str(rtx, nde->idx, idxbuf, &len, &remidx);
str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx);
if (HAWK_UNLIKELY(!str)) goto oops;
map = ((hawk_val_map_t*)v)->map;
@ -7072,7 +6862,7 @@ static hawk_val_t* eval_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde, hawk_val_
break;
default:
hawk_rtx_seterrnum (rtx, &nde->loc, HAWK_ENOTMAP);
hawk_rtx_seterrnum (rtx, &var->loc, HAWK_ENOTMAP);
goto oops;
}
@ -7090,44 +6880,28 @@ static hawk_val_t* eval_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde, hawk_val_
oops:
if (str && str != idxbuf) hawk_rtx_freemem (rtx, str);
ADJERR_LOC (rtx, &nde->loc);
ADJERR_LOC (rtx, &var->loc);
return HAWK_NULL;
}
static hawk_val_t* eval_namedidx (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
hawk_nde_var_t* tgt = (hawk_nde_var_t*)nde;
hawk_htb_pair_t* pair;
pair = hawk_htb_search(rtx->named, tgt->id.name.ptr, tgt->id.name.len);
if (pair == HAWK_NULL)
{
pair = hawk_htb_upsert(rtx->named, tgt->id.name.ptr, tgt->id.name.len, hawk_val_nil, 0);
if (HAWK_UNLIKELY(!pair))
{
ADJERR_LOC (rtx, &nde->loc);
return HAWK_NULL;
}
hawk_rtx_refupval (rtx, HAWK_HTB_VPTR(pair));
}
return eval_indexed (rtx, tgt, (hawk_val_t**)&HAWK_HTB_VPTR(pair));
return eval_indexed(rtx, (hawk_nde_var_t*)nde);
}
static hawk_val_t* eval_gblidx (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
return eval_indexed(rtx, (hawk_nde_var_t*)nde, (hawk_val_t**)&HAWK_RTX_STACK_GBL(rtx,((hawk_nde_var_t*)nde)->id.idxa));
return eval_indexed(rtx, (hawk_nde_var_t*)nde);
}
static hawk_val_t* eval_lclidx (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
return eval_indexed(rtx, (hawk_nde_var_t*)nde, (hawk_val_t**)&HAWK_RTX_STACK_LCL(rtx,((hawk_nde_var_t*)nde)->id.idxa));
return eval_indexed(rtx, (hawk_nde_var_t*)nde);
}
static hawk_val_t* eval_argidx (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
return eval_indexed(rtx, (hawk_nde_var_t*)nde, (hawk_val_t**)&HAWK_RTX_STACK_ARG(rtx,((hawk_nde_var_t*)nde)->id.idxa));
return eval_indexed(rtx, (hawk_nde_var_t*)nde);
}
static hawk_val_t* eval_pos (hawk_rtx_t* rtx, hawk_nde_t* nde)