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

writing code for supporting true multi-dimensional indices in map

Browse Source
This commit is contained in:
hyung-hwan 2020-03-30 08:54:37 +00:00
parent abcc217dd0
commit 76d295365a
4 changed files with 174 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
hawk/lib/parse.c
View File

@ -1827,12 +1827,12 @@ static hawk_nde_t* parse_block (hawk_t* awk, const hawk_loc_t* xloc, int istop)
nde = parse_statement (awk, &sloc); nde = parse_statement (awk, &sloc);
} }
if (nde == HAWK_NULL) if (HAWK_UNLIKELY(!nde))
{ {
hawk_arr_delete ( hawk_arr_delete (
awk->parse.lcls, nlcls, awk->parse.lcls, nlcls,
HAWK_ARR_SIZE(awk->parse.lcls)-nlcls); HAWK_ARR_SIZE(awk->parse.lcls)-nlcls);
if (head != HAWK_NULL) hawk_clrpt (awk, head); if (head) hawk_clrpt (awk, head);
return HAWK_NULL; return HAWK_NULL;
} }
@ -1857,7 +1857,7 @@ static hawk_nde_t* parse_block (hawk_t* awk, const hawk_loc_t* xloc, int istop)
} }
block = (hawk_nde_blk_t*)hawk_callocmem(awk, HAWK_SIZEOF(*block)); block = (hawk_nde_blk_t*)hawk_callocmem(awk, HAWK_SIZEOF(*block));
if (block == HAWK_NULL) if (HAWK_UNLIKELY(!block))
{ {
hawk_arr_delete (awk->parse.lcls, nlcls, HAWK_ARR_SIZE(awk->parse.lcls) - nlcls); hawk_arr_delete (awk->parse.lcls, nlcls, HAWK_ARR_SIZE(awk->parse.lcls) - nlcls);
hawk_clrpt (awk, head); hawk_clrpt (awk, head);
@ -5687,33 +5687,38 @@ static hawk_nde_t* parse_hashidx (hawk_t* awk, const hawk_oocs_t* name, const ha
idx = HAWK_NULL; idx = HAWK_NULL;
last = HAWK_NULL; last = HAWK_NULL;
#if defined(HAWK_ENABLE_GC)
more_idx:
#endif
do do
{ {
if (get_token(awk) <= -1) if (get_token(awk) <= -1)
{ {
if (idx != HAWK_NULL) hawk_clrpt (awk, idx); if (idx) hawk_clrpt (awk, idx);
return HAWK_NULL; return HAWK_NULL;
} }
{ {
hawk_loc_t eloc; hawk_loc_t eloc;
eloc = awk->tok.loc; eloc = awk->tok.loc;
tmp = parse_expr_withdc(awk, &eloc); tmp = parse_expr_withdc(awk, &eloc);
} }
if (tmp == HAWK_NULL) if (HAWK_UNLIKELY(!tmp))
{ {
if (idx != HAWK_NULL) hawk_clrpt (awk, idx); if (idx) hawk_clrpt (awk, idx);
return HAWK_NULL; return HAWK_NULL;
} }
if (idx == HAWK_NULL) if (!idx)
{ {
/* this is the first item */
HAWK_ASSERT (last == HAWK_NULL); HAWK_ASSERT (last == HAWK_NULL);
idx = tmp; last = tmp; idx = tmp;
last = tmp;
} }
else else
{ {
/* not the first item. append it */
last->next = tmp; last->next = tmp;
last = tmp; last = tmp;
} }
@ -5735,8 +5740,31 @@ static hawk_nde_t* parse_hashidx (hawk_t* awk, const hawk_oocs_t* name, const ha
return HAWK_NULL; return HAWK_NULL;
} }
#if defined(HAWK_ENABLE_GC)
if (MATCH(awk,TOK_LBRACK))
{
/* additional index - a[10][20] ...
* use the NULL node as a splitter */
tmp = (hawk_nde_t*)hawk_callocmem(awk, HAWK_SIZEOF(*tmp));
if (HAWK_UNLIKELY(!tmp))
{
hawk_clrpt (awk, idx);
ADJERR_LOC (awk, xloc);
return HAWK_NULL;
}
tmp->type = HAWK_NDE_NULL;
HAWK_ASSERT (idx != HAWK_NULL);
HAWK_ASSERT (last != HAWK_NULL);
last->next = tmp;
last = tmp;
goto more_idx;
}
#endif
nde = (hawk_nde_var_t*)hawk_callocmem(awk, HAWK_SIZEOF(*nde)); nde = (hawk_nde_var_t*)hawk_callocmem(awk, HAWK_SIZEOF(*nde));
if (nde == HAWK_NULL) if (HAWK_UNLIKELY(!nde))
{ {
hawk_clrpt (awk, idx); hawk_clrpt (awk, idx);
ADJERR_LOC (awk, xloc); ADJERR_LOC (awk, xloc);

127
hawk/lib/run.c
View File

@ -208,7 +208,7 @@ static hawk_val_t* eval_printf (hawk_rtx_t* rtx, hawk_nde_t* nde);
static int read_record (hawk_rtx_t* rtx); 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); 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);
typedef hawk_val_t* (*binop_func_t) (hawk_rtx_t* rtx, hawk_val_t* left, hawk_val_t* right); 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); typedef hawk_val_t* (*eval_expr_t) (hawk_rtx_t* rtx, hawk_nde_t* nde);
@ -2867,13 +2867,14 @@ static int delete_indexed (hawk_rtx_t* rtx, hawk_map_t* map, hawk_nde_var_t* var
hawk_ooch_t* iptr; hawk_ooch_t* iptr;
hawk_oow_t ilen; hawk_oow_t ilen;
hawk_ooch_t idxbuf[IDXBUFSIZE]; hawk_ooch_t idxbuf[IDXBUFSIZE];
hawk_nde_t* remidx;
HAWK_ASSERT (var->idx != HAWK_NULL); HAWK_ASSERT (var->idx != HAWK_NULL);
/* delete x["abc"]; /* delete x["abc"];
* delete x[20,"abc"]; */ * delete x[20,"abc"]; */
ilen = HAWK_COUNTOF(idxbuf); ilen = HAWK_COUNTOF(idxbuf);
iptr = idxnde_to_str(rtx, var->idx, idxbuf, &ilen); iptr = idxnde_to_str(rtx, var->idx, idxbuf, &ilen, &remidx);
if (HAWK_UNLIKELY(!iptr)) return -1; if (HAWK_UNLIKELY(!iptr)) return -1;
hawk_map_delete (map, iptr, ilen); hawk_map_delete (map, iptr, ilen);
@ -2960,7 +2961,7 @@ static int run_delete_unnamed (hawk_rtx_t* rtx, hawk_nde_var_t* var)
case HAWK_NDE_GBLIDX: case HAWK_NDE_GBLIDX:
val = HAWK_RTX_STACK_GBL(rtx,var->id.idxa); val = HAWK_RTX_STACK_GBL(rtx,var->id.idxa);
break; break;
case HAWK_NDE_LCL: case HAWK_NDE_LCL:
case HAWK_NDE_LCLIDX: case HAWK_NDE_LCLIDX:
val = HAWK_RTX_STACK_LCL(rtx,var->id.idxa); val = HAWK_RTX_STACK_LCL(rtx,var->id.idxa);
@ -3001,7 +3002,7 @@ static int run_delete_unnamed (hawk_rtx_t* rtx, hawk_nde_var_t* var)
x = hawk_rtx_setgbl(rtx, (int)var->id.idxa, tmp); x = hawk_rtx_setgbl(rtx, (int)var->id.idxa, tmp);
hawk_rtx_refdownval (rtx, tmp); hawk_rtx_refdownval (rtx, tmp);
if (x <= -1) if (HAWK_UNLIKELY(x <= -1))
{ {
ADJERR_LOC (rtx, &var->loc); ADJERR_LOC (rtx, &var->loc);
return -1; return -1;
@ -3908,6 +3909,7 @@ static hawk_val_t* do_assignment_idx (hawk_rtx_t* rtx, hawk_nde_var_t* var, hawk
hawk_ooch_t* str; hawk_ooch_t* str;
hawk_oow_t len; hawk_oow_t len;
hawk_ooch_t idxbuf[IDXBUFSIZE]; hawk_ooch_t idxbuf[IDXBUFSIZE];
hawk_nde_t* remidx;
HAWK_ASSERT ( HAWK_ASSERT (
(var->type == HAWK_NDE_NAMEDIDX || (var->type == HAWK_NDE_NAMEDIDX ||
@ -3949,7 +3951,7 @@ retry:
/* the map is not initialized yet */ /* the map is not initialized yet */
tmp = hawk_rtx_makemapval(rtx); tmp = hawk_rtx_makemapval(rtx);
if (tmp == HAWK_NULL) if (HAWK_UNLIKELY(!tmp))
{ {
ADJERR_LOC (rtx, &var->loc); ADJERR_LOC (rtx, &var->loc);
return HAWK_NULL; return HAWK_NULL;
@ -4031,8 +4033,8 @@ retry:
} }
len = HAWK_COUNTOF(idxbuf); len = HAWK_COUNTOF(idxbuf);
str = idxnde_to_str(rtx, var->idx, idxbuf, &len); str = idxnde_to_str(rtx, var->idx, idxbuf, &len, &remidx);
if (str == HAWK_NULL) return HAWK_NULL; if (HAWK_UNLIKELY(!str)) return HAWK_NULL;
#if defined(DEBUG_RUN) #if defined(DEBUG_RUN)
@ -4321,6 +4323,7 @@ static hawk_val_t* eval_binop_in (hawk_rtx_t* rtx, hawk_nde_t* left, hawk_nde_t*
hawk_ooch_t* str; hawk_ooch_t* str;
hawk_oow_t len; hawk_oow_t len;
hawk_ooch_t idxbuf[IDXBUFSIZE]; hawk_ooch_t idxbuf[IDXBUFSIZE];
hawk_nde_t* remidx;
if (right->type != HAWK_NDE_GBL && if (right->type != HAWK_NDE_GBL &&
right->type != HAWK_NDE_LCL && right->type != HAWK_NDE_LCL &&
@ -4336,8 +4339,8 @@ static hawk_val_t* eval_binop_in (hawk_rtx_t* rtx, hawk_nde_t* left, hawk_nde_t*
/* evaluate the left-hand side of the operator */ /* evaluate the left-hand side of the operator */
len = HAWK_COUNTOF(idxbuf); len = HAWK_COUNTOF(idxbuf);
str = (left->type == HAWK_NDE_GRP)? str = (left->type == HAWK_NDE_GRP)?
idxnde_to_str(rtx, ((hawk_nde_grp_t*)left)->body, idxbuf, &len): idxnde_to_str(rtx, ((hawk_nde_grp_t*)left)->body, idxbuf, &len, &remidx):
idxnde_to_str(rtx, left, idxbuf, &len); idxnde_to_str(rtx, left, idxbuf, &len, &remidx);
if (HAWK_UNLIKELY(!str)) return HAWK_NULL; if (HAWK_UNLIKELY(!str)) return HAWK_NULL;
/* evaluate the right-hand side of the operator */ /* evaluate the right-hand side of the operator */
@ -6674,6 +6677,7 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde,
hawk_oow_t len; hawk_oow_t len;
hawk_ooch_t idxbuf[IDXBUFSIZE]; hawk_ooch_t idxbuf[IDXBUFSIZE];
hawk_val_type_t vtype; hawk_val_type_t vtype;
hawk_nde_t* remidx;
HAWK_ASSERT (val != HAWK_NULL); HAWK_ASSERT (val != HAWK_NULL);
@ -6702,7 +6706,7 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde,
HAWK_ASSERT (nde->idx != HAWK_NULL); HAWK_ASSERT (nde->idx != HAWK_NULL);
len = HAWK_COUNTOF(idxbuf); len = HAWK_COUNTOF(idxbuf);
str = idxnde_to_str(rtx, nde->idx, idxbuf, &len); str = idxnde_to_str(rtx, nde->idx, idxbuf, &len, &remidx);
if (HAWK_UNLIKELY(!str)) return HAWK_NULL; if (HAWK_UNLIKELY(!str)) return HAWK_NULL;
pair = hawk_map_search((*(hawk_val_map_t**)val)->map, str, len); pair = hawk_map_search((*(hawk_val_map_t**)val)->map, str, len);
@ -6821,46 +6825,95 @@ static hawk_val_t* eval_arg (hawk_rtx_t* rtx, hawk_nde_t* nde)
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* nde, hawk_val_t** val)
{ {
hawk_map_t* map; /* containing map */
hawk_map_pair_t* pair; hawk_map_pair_t* pair;
hawk_ooch_t* str; hawk_ooch_t* str = HAWK_NULL;
hawk_oow_t len; hawk_oow_t len;
hawk_ooch_t idxbuf[IDXBUFSIZE]; hawk_ooch_t idxbuf[IDXBUFSIZE];
hawk_val_t* v;
hawk_val_type_t vtype; hawk_val_type_t vtype;
hawk_nde_t* remidx;
HAWK_ASSERT (val != HAWK_NULL); HAWK_ASSERT (val != HAWK_NULL);
vtype = HAWK_RTX_GETVALTYPE(rtx, *val); vtype = HAWK_RTX_GETVALTYPE(rtx, *val);
if (vtype == HAWK_VAL_NIL) switch (vtype)
{ {
hawk_val_t* tmp; case HAWK_VAL_NIL:
v = hawk_rtx_makemapval(rtx);
if (HAWK_UNLIKELY(!v)) goto oops;
tmp = hawk_rtx_makemapval(rtx); hawk_rtx_refdownval (rtx, *val);
if (tmp == HAWK_NULL) *val = v;
{ hawk_rtx_refupval (rtx, (hawk_val_t*)*val);
ADJERR_LOC (rtx, &nde->loc); break;
return HAWK_NULL;
}
hawk_rtx_refdownval (rtx, *val); case HAWK_VAL_MAP:
*val = tmp; v = *val;
hawk_rtx_refupval (rtx, (hawk_val_t*)*val); break;
}
else if (vtype != HAWK_VAL_MAP) default:
{ hawk_rtx_seterrnum (rtx, &nde->loc, HAWK_ENOTMAP);
hawk_rtx_seterrnum (rtx, &nde->loc, HAWK_ENOTMAP); goto oops;
return HAWK_NULL;
} }
HAWK_ASSERT (nde->idx != HAWK_NULL); HAWK_ASSERT (nde->idx != HAWK_NULL);
len = HAWK_COUNTOF(idxbuf); len = HAWK_COUNTOF(idxbuf);
str = idxnde_to_str(rtx, nde->idx, idxbuf, &len); str = idxnde_to_str(rtx, nde->idx, idxbuf, &len, &remidx);
if (str == HAWK_NULL) return HAWK_NULL; if (HAWK_UNLIKELY(!str)) goto oops;
map = ((hawk_val_map_t*)v)->map;
pair = hawk_map_search(map, str, len);
#if defined(HAWK_ENABLE_GC)
while (remidx)
{
v = pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil;
vtype = HAWK_RTX_GETVALTYPE(rtx, v);
switch (vtype)
{
case HAWK_VAL_NIL:
v = hawk_rtx_makemapval(rtx);
if (HAWK_UNLIKELY(!v)) goto oops;
hawk_rtx_refupval (rtx, v);
pair = hawk_map_upsert(map, str, len, v, 0);
if (HAWK_UNLIKELY(!pair))
{
hawk_rtx_refdownval (rtx, v);
goto oops;
}
map = ((hawk_val_map_t*)v)->map;
break;
case HAWK_VAL_MAP:
map = ((hawk_val_map_t*)v)->map;
break;
default:
hawk_rtx_seterrnum (rtx, &nde->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;
pair = hawk_map_search(map, str, len);
}
#endif
pair = hawk_map_search((*(hawk_val_map_t**)val)->map, str, len);
if (str != idxbuf) hawk_rtx_freemem (rtx, str); if (str != idxbuf) hawk_rtx_freemem (rtx, str);
return pair? (hawk_val_t*)HAWK_HTB_VPTR(pair): hawk_val_nil;
return (pair == HAWK_NULL)? hawk_val_nil: (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_namedidx (hawk_rtx_t* rtx, hawk_nde_t* nde) static hawk_val_t* eval_namedidx (hawk_rtx_t* rtx, hawk_nde_t* nde)
@ -6872,7 +6925,7 @@ static hawk_val_t* eval_namedidx (hawk_rtx_t* rtx, hawk_nde_t* nde)
if (pair == HAWK_NULL) if (pair == HAWK_NULL)
{ {
pair = hawk_htb_upsert(rtx->named, tgt->id.name.ptr, tgt->id.name.len, hawk_val_nil, 0); pair = hawk_htb_upsert(rtx->named, tgt->id.name.ptr, tgt->id.name.len, hawk_val_nil, 0);
if (pair == HAWK_NULL) if (HAWK_UNLIKELY(!pair))
{ {
ADJERR_LOC (rtx, &nde->loc); ADJERR_LOC (rtx, &nde->loc);
return HAWK_NULL; return HAWK_NULL;
@ -7209,7 +7262,7 @@ read_again:
return 1; return 1;
} }
static hawk_ooch_t* idxnde_to_str (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_ooch_t* buf, hawk_oow_t* len) 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)
{ {
hawk_ooch_t* str; hawk_ooch_t* str;
hawk_val_t* idx; hawk_val_t* idx;
@ -7260,6 +7313,7 @@ static hawk_ooch_t* idxnde_to_str (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_ooch_t
} }
hawk_rtx_refdownval (rtx, idx); hawk_rtx_refdownval (rtx, idx);
*remidx = HAWK_NULL;
} }
else else
{ {
@ -7279,7 +7333,11 @@ static hawk_ooch_t* idxnde_to_str (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_ooch_t
} }
xnde = nde; xnde = nde;
#if defined(HAWK_ENABLE_GC)
while (nde && nde->type != HAWK_NDE_NULL)
#else
while (nde) while (nde)
#endif
{ {
idx = eval_expression(rtx, nde); idx = eval_expression(rtx, nde);
if (HAWK_UNLIKELY(!idx)) if (HAWK_UNLIKELY(!idx))
@ -7314,6 +7372,9 @@ static hawk_ooch_t* idxnde_to_str (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_ooch_t
*len = tmp.len; *len = tmp.len;
hawk_ooecs_fini (&idxstr); hawk_ooecs_fini (&idxstr);
/* if nde is not HAWK_NULL, it should be of the HAWK_NDE_NULL type */
*remidx = nde? nde->next: nde;
} }
return str; return str;

59
hawk/lib/tree.c
View File

@ -136,6 +136,10 @@ static const hawk_ooch_t* print_outop_str[] =
if (print_expr_list(awk,nde) == -1) return -1; \ if (print_expr_list(awk,nde) == -1) return -1; \
} while(0) } while(0)
#define PRINT_EXPR_LIST_FOR_IDX(awk,nde) do { \
if (print_expr_list_for_idx(awk,nde) == -1) return -1; \
} while(0)
#define PRINT_STMTS(awk,nde,depth) do { \ #define PRINT_STMTS(awk,nde,depth) do { \
if (print_stmts(awk,nde,depth) == -1) return -1; \ if (print_stmts(awk,nde,depth) == -1) return -1; \
} while(0) } while(0)
@ -143,6 +147,7 @@ static const hawk_ooch_t* print_outop_str[] =
static int print_tabs (hawk_t* awk, int depth); static int print_tabs (hawk_t* awk, int depth);
static int print_expr (hawk_t* awk, hawk_nde_t* nde); static int print_expr (hawk_t* awk, hawk_nde_t* nde);
static int print_expr_list (hawk_t* awk, hawk_nde_t* tree); static int print_expr_list (hawk_t* awk, hawk_nde_t* tree);
static int print_expr_list_for_idx (hawk_t* awk, hawk_nde_t* tree);
static int print_stmts (hawk_t* awk, hawk_nde_t* tree, int depth); static int print_stmts (hawk_t* awk, hawk_nde_t* tree, int depth);
static int print_tabs (hawk_t* awk, int depth) static int print_tabs (hawk_t* awk, int depth)
@ -527,9 +532,7 @@ static int print_expr (hawk_t* awk, hawk_nde_t* nde)
PUT_SRCSTR (awk, HAWK_T("__p")); PUT_SRCSTR (awk, HAWK_T("__p"));
n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, awk->tmp.fmt, HAWK_COUNTOF(awk->tmp.fmt)); n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, awk->tmp.fmt, HAWK_COUNTOF(awk->tmp.fmt));
PUT_SRCSTRN (awk, awk->tmp.fmt, n); PUT_SRCSTRN (awk, awk->tmp.fmt, n);
PUT_SRCSTR (awk, HAWK_T("[")); PRINT_EXPR_LIST_FOR_IDX (awk, px->idx);
PRINT_EXPR_LIST (awk, px->idx);
PUT_SRCSTR (awk, HAWK_T("]"));
break; break;
} }
@ -550,9 +553,7 @@ static int print_expr (hawk_t* awk, hawk_nde_t* nde)
HAWK_ASSERT (px->idx != HAWK_NULL); HAWK_ASSERT (px->idx != HAWK_NULL);
PUT_SRCSTRN (awk, px->id.name.ptr, px->id.name.len); PUT_SRCSTRN (awk, px->id.name.ptr, px->id.name.len);
PUT_SRCSTR (awk, HAWK_T("[")); PRINT_EXPR_LIST_FOR_IDX (awk, px->idx);
PRINT_EXPR_LIST (awk, px->idx);
PUT_SRCSTR (awk, HAWK_T("]"));
break; break;
} }
@ -621,16 +622,13 @@ static int print_expr (hawk_t* awk, hawk_nde_t* nde)
n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, tmp, HAWK_COUNTOF(tmp)); n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, tmp, HAWK_COUNTOF(tmp));
PUT_SRCSTRN (awk, tmp, n); PUT_SRCSTRN (awk, tmp, n);
} }
PUT_SRCSTR (awk, HAWK_T("["));
} }
else else
{ {
PUT_SRCSTRN (awk, px->id.name.ptr, px->id.name.len); PUT_SRCSTRN (awk, px->id.name.ptr, px->id.name.len);
PUT_SRCSTR (awk, HAWK_T("["));
} }
HAWK_ASSERT (px->idx != HAWK_NULL); HAWK_ASSERT (px->idx != HAWK_NULL);
PRINT_EXPR_LIST (awk, px->idx); PRINT_EXPR_LIST_FOR_IDX (awk, px->idx);
PUT_SRCSTR (awk, HAWK_T("]"));
break; break;
} }
@ -663,16 +661,13 @@ static int print_expr (hawk_t* awk, hawk_nde_t* nde)
PUT_SRCSTR (awk, HAWK_T("__l")); PUT_SRCSTR (awk, HAWK_T("__l"));
n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, awk->tmp.fmt, HAWK_COUNTOF(awk->tmp.fmt)); n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, awk->tmp.fmt, HAWK_COUNTOF(awk->tmp.fmt));
PUT_SRCSTRN (awk, awk->tmp.fmt, n); PUT_SRCSTRN (awk, awk->tmp.fmt, n);
PUT_SRCSTR (awk, HAWK_T("["));
} }
else else
{ {
PUT_SRCSTRN (awk, px->id.name.ptr, px->id.name.len); PUT_SRCSTRN (awk, px->id.name.ptr, px->id.name.len);
PUT_SRCSTR (awk, HAWK_T("["));
} }
HAWK_ASSERT (px->idx != HAWK_NULL); HAWK_ASSERT (px->idx != HAWK_NULL);
PRINT_EXPR_LIST (awk, px->idx); PRINT_EXPR_LIST_FOR_IDX (awk, px->idx);
PUT_SRCSTR (awk, HAWK_T("]"));
break; break;
} }
@ -774,16 +769,44 @@ static int print_expr_list (hawk_t* awk, hawk_nde_t* tree)
{ {
hawk_nde_t* p = tree; hawk_nde_t* p = tree;
while (p != HAWK_NULL) while (p)
{ {
PRINT_EXPR (awk, p); PRINT_EXPR (awk, p);
p = p->next; p = p->next;
if (p != HAWK_NULL) PUT_SRCSTR (awk, HAWK_T(",")); if (p) PUT_SRCSTR (awk, HAWK_T(","));
} }
return 0; return 0;
} }
static int print_expr_list_for_idx (hawk_t* awk, hawk_nde_t* tree)
{
hawk_nde_t* p = tree;
PUT_SRCSTR (awk, HAWK_T("["));
while (p)
{
PRINT_EXPR (awk, p);
p = p->next;
if (p)
{
if (p->type == HAWK_NDE_NULL)
{
/* the parser injects a HAWK_NDE_NULL node between the true multi-dimensional indices
* if the true multi-dimensional indices are enabled(i.e. HAWK_ENABLE_GC is defined)
* e.g. a[x][y][z]
* let me print this regardless of */
PUT_SRCSTR (awk, HAWK_T("]["));
p = p->next;
}
else PUT_SRCSTR (awk, HAWK_T(","));
}
}
PUT_SRCSTR (awk, HAWK_T("]"));
return 0;
}
static int print_stmt (hawk_t* awk, hawk_nde_t* p, int depth) static int print_stmt (hawk_t* awk, hawk_nde_t* p, int depth)
{ {
hawk_oow_t i; hawk_oow_t i;
@ -877,7 +900,7 @@ static int print_stmt (hawk_t* awk, hawk_nde_t* p, int depth)
PRINT_TABS (awk, depth); PRINT_TABS (awk, depth);
hawk_getkwname (awk, HAWK_KWID_WHILE, &kw); hawk_getkwname (awk, HAWK_KWID_WHILE, &kw);
PUT_SRCSTRN (awk, kw.ptr, kw.len); PUT_SRCSTRN (awk, kw.ptr, kw.len);
PUT_SRCSTR (awk, HAWK_T(" (")); PUT_SRCSTR (awk, HAWK_T(" ("));
PRINT_EXPR (awk, px->test); PRINT_EXPR (awk, px->test);
PUT_SRCSTR (awk, HAWK_T(")")); PUT_SRCSTR (awk, HAWK_T(")"));
PUT_NL (awk); PUT_NL (awk);
@ -912,7 +935,7 @@ static int print_stmt (hawk_t* awk, hawk_nde_t* p, int depth)
PRINT_TABS (awk, depth); PRINT_TABS (awk, depth);
hawk_getkwname (awk, HAWK_KWID_WHILE, &kw); hawk_getkwname (awk, HAWK_KWID_WHILE, &kw);
PUT_SRCSTRN (awk, kw.ptr, kw.len); PUT_SRCSTRN (awk, kw.ptr, kw.len);
PUT_SRCSTR (awk, HAWK_T(" (")); PUT_SRCSTR (awk, HAWK_T(" ("));
PRINT_EXPR (awk, px->test); PRINT_EXPR (awk, px->test);
PUT_SRCSTR (awk, HAWK_T(");")); PUT_SRCSTR (awk, HAWK_T(");"));
PUT_NL (awk); PUT_NL (awk);

2
hawk/lib/val.c
View File

@ -1078,7 +1078,7 @@ hawk_val_t* hawk_rtx_setmapvalfld (hawk_rtx_t* rtx, hawk_val_t* map, const hawk_
{ {
HAWK_ASSERT (HAWK_RTX_GETVALTYPE (rtx, map) == HAWK_VAL_MAP); HAWK_ASSERT (HAWK_RTX_GETVALTYPE (rtx, map) == HAWK_VAL_MAP);
if (hawk_map_upsert (((hawk_val_map_t*)map)->map, (hawk_ooch_t*)kptr, klen, v, 0) == HAWK_NULL) return HAWK_NULL; if (hawk_map_upsert(((hawk_val_map_t*)map)->map, (hawk_ooch_t*)kptr, klen, v, 0) == HAWK_NULL) return HAWK_NULL;
/* the value is passed in by an external party. we can't refup() /* the value is passed in by an external party. we can't refup()
* and refdown() the value if htb_upsert() fails. that way, the value * and refdown() the value if htb_upsert() fails. that way, the value