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

added hawk_rtx_matchvalwithucs() and hawk_rtx_matchvalwithbcs()

Browse Source 
renamed hawk_rtx_matchval() to hawk_rtx_matchvalwithoocs()
updated code concerning the call to hawk_rtx_setrefval()
This commit is contained in:
hyung-hwan 2020-03-10 08:36:31 +00:00
parent 260df21f85
commit bae06804ef
8 changed files with 290 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
hawk/lib/fnc.c
View File

@ -800,7 +800,7 @@ int hawk_fnc_substr (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
int hawk_fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi) int hawk_fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{ {
hawk_oow_t nargs; hawk_oow_t nargs;
hawk_val_t* a0, * a1, * a2, * t1, * t2; hawk_val_t* a0, * a2, * t1, * t2;
hawk_val_type_t a1_vtype, a2_vtype, t1_vtype; hawk_val_type_t a1_vtype, a2_vtype, t1_vtype;
hawk_oocs_t str; hawk_oocs_t str;
@ -813,8 +813,6 @@ int hawk_fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
hawk_oocs_t tok; hawk_oocs_t tok;
hawk_int_t nflds; hawk_int_t nflds;
hawk_errnum_t errnum;
int x; int x;
str.ptr = HAWK_NULL; str.ptr = HAWK_NULL;
@ -824,12 +822,8 @@ int hawk_fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
HAWK_ASSERT (nargs >= 2 && nargs <= 3); HAWK_ASSERT (nargs >= 2 && nargs <= 3);
a0 = hawk_rtx_getarg(rtx, 0); a0 = hawk_rtx_getarg(rtx, 0);
a1 = hawk_rtx_getarg(rtx, 1);
a2 = (nargs >= 3)? hawk_rtx_getarg (rtx, 2): HAWK_NULL; a2 = (nargs >= 3)? hawk_rtx_getarg (rtx, 2): HAWK_NULL;
a1_vtype = HAWK_RTX_GETVALTYPE (rtx, a1);
HAWK_ASSERT (a1_vtype == HAWK_VAL_REF);
str.ptr = hawk_rtx_getvaloocstr(rtx, a0, &str.len); str.ptr = hawk_rtx_getvaloocstr(rtx, a0, &str.len);
if (str.ptr == HAWK_NULL) goto oops; if (str.ptr == HAWK_NULL) goto oops;
@ -900,18 +894,18 @@ int hawk_fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
} }
t1 = hawk_rtx_makemapval(rtx); t1 = hawk_rtx_makemapval(rtx);
if (t1 == HAWK_NULL) goto oops; if (HAWK_UNLIKELY(!t1)) goto oops;
hawk_rtx_refupval (rtx, t1); hawk_rtx_refupval (rtx, t1);
x = hawk_rtx_setrefval (rtx, (hawk_val_ref_t*)a1, t1); x = hawk_rtx_setrefval(rtx, (hawk_val_ref_t*)hawk_rtx_getarg(rtx, 1), t1);
hawk_rtx_refdownval (rtx, t1); hawk_rtx_refdownval (rtx, t1);
if (x <= -1) goto oops; if (HAWK_UNLIKELY(x <= -1)) goto oops;
/* fill the map with actual values */ /* fill the map with actual values */
p = str.ptr; str_left = str.len; org_len = str.len; p = str.ptr; str_left = str.len; org_len = str.len;
nflds = 0; nflds = 0;
while (p != HAWK_NULL) while (p)
{ {
hawk_ooch_t key_buf[HAWK_SIZEOF(hawk_int_t)*8+2]; hawk_ooch_t key_buf[HAWK_SIZEOF(hawk_int_t)*8+2];
hawk_oow_t key_len; hawk_oow_t key_len;
@ -1246,7 +1240,7 @@ oops:
static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count) static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
{ {
hawk_oow_t nargs; hawk_oow_t nargs;
hawk_val_t* a0, * a1, * a2, * v; hawk_val_t* a0, * a1, * r2, * v;
hawk_val_type_t a0_vtype; hawk_val_type_t a0_vtype;
hawk_oocs_t s0; hawk_oocs_t s0;
@ -1258,7 +1252,6 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
hawk_tre_t* rex = HAWK_NULL; hawk_tre_t* rex = HAWK_NULL;
hawk_tre_t* rex_free = HAWK_NULL; hawk_tre_t* rex_free = HAWK_NULL;
hawk_oow_t sub_count; hawk_oow_t sub_count;
s0.ptr = HAWK_NULL; s0.ptr = HAWK_NULL;
@ -1268,14 +1261,10 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
s1.len = 0; s1.len = 0;
nargs = hawk_rtx_getnargs(rtx); nargs = hawk_rtx_getnargs(rtx);
HAWK_ASSERT (nargs >= 2 && nargs <= 3);
a0 = hawk_rtx_getarg(rtx, 0); a0 = hawk_rtx_getarg(rtx, 0);
a1 = hawk_rtx_getarg(rtx, 1); a1 = hawk_rtx_getarg(rtx, 1);
a2 = (nargs >= 3)? hawk_rtx_getarg(rtx, 2): HAWK_NULL;
a0_vtype = HAWK_RTX_GETVALTYPE(rtx, a0); a0_vtype = HAWK_RTX_GETVALTYPE(rtx, a0);
HAWK_ASSERT (a2 == HAWK_NULL || HAWK_RTX_GETVALTYPE(rtx, a2) == HAWK_VAL_REF);
/* the first argument - pattern */ /* the first argument - pattern */
if (a0_vtype == HAWK_VAL_REX) if (a0_vtype == HAWK_VAL_REX)
@ -1289,7 +1278,7 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
} }
/* the optional third argument - string to manipulate */ /* the optional third argument - string to manipulate */
if (a2 == HAWK_NULL) if (nargs < 3)
{ {
/* is this correct? any needs to use inrec.d0? */ /* is this correct? any needs to use inrec.d0? */
s2.ptr = HAWK_OOECS_PTR(&rtx->inrec.line); s2.ptr = HAWK_OOECS_PTR(&rtx->inrec.line);
@ -1299,23 +1288,28 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
s1.ptr = hawk_rtx_getvaloocstr(rtx, a1, &s1.len); s1.ptr = hawk_rtx_getvaloocstr(rtx, a1, &s1.len);
s1_free = 1; s1_free = 1;
} }
else if (hawk_rtx_getrefvaltype(rtx, (hawk_val_ref_t*)a2) == HAWK_VAL_MBS) else
{ {
s2.ptr = hawk_rtx_getvalbcstr(rtx, a2, &s2.len); r2 = hawk_rtx_getrefval(rtx, (hawk_val_ref_t*)hawk_rtx_getarg(rtx, 2));
s2_free = 2;
/* the second argument - substitute */ if (HAWK_RTX_GETVALTYPE(rtx, r2) == HAWK_VAL_MBS)
s1.ptr = hawk_rtx_getvalbcstr(rtx, a1, &s1.len); {
s1_free = 2; s2.ptr = hawk_rtx_getvalbcstr(rtx, r2, &s2.len);
} s2_free = 2;
else
{
s2.ptr = hawk_rtx_getvaloocstr(rtx, a2, &s2.len);
s2_free = 1;
/* the second argument - substitute */ /* the second argument - substitute */
s1.ptr = hawk_rtx_getvaloocstr(rtx, a1, &s1.len); s1.ptr = hawk_rtx_getvalbcstr(rtx, a1, &s1.len);
s1_free = 1; s1_free = 2;
}
else
{
s2.ptr = hawk_rtx_getvaloocstr(rtx, r2, &s2.len);
s2_free = 1;
/* the second argument - substitute */
s1.ptr = hawk_rtx_getvaloocstr(rtx, a1, &s1.len);
s1_free = 1;
}
} }
if (HAWK_UNLIKELY(!s1.ptr || !s2.ptr)) goto oops; if (HAWK_UNLIKELY(!s1.ptr || !s2.ptr)) goto oops;
@ -1335,13 +1329,13 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
sub_count = max_count; sub_count = max_count;
if (s2_free == 2) if (s2_free == 2)
{ {
hawk_becs_clear(&rtx->subst.bout); hawk_becs_clear(&rtx->fnc.bout);
if (__substitute_bcs(rtx, &sub_count, rex, (hawk_bcs_t*)&s1, (hawk_bcs_t*)&s2, &rtx->subst.bout) <= -1) goto oops; if (__substitute_bcs(rtx, &sub_count, rex, (hawk_bcs_t*)&s1, (hawk_bcs_t*)&s2, &rtx->fnc.bout) <= -1) goto oops;
} }
else else
{ {
hawk_ooecs_clear(&rtx->subst.oout); hawk_ooecs_clear(&rtx->fnc.oout);
if (__substitute_oocs(rtx, &sub_count, rex, (hawk_oocs_t*)&s1, (hawk_oocs_t*)&s2, &rtx->subst.oout) <= -1) goto oops; if (__substitute_oocs(rtx, &sub_count, rex, (hawk_oocs_t*)&s1, (hawk_oocs_t*)&s2, &rtx->fnc.oout) <= -1) goto oops;
} }
if (rex_free) if (rex_free)
@ -1353,37 +1347,16 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
rex_free = HAWK_NULL; rex_free = HAWK_NULL;
} }
if (sub_count > 0)
{
int n;
if (a2 == HAWK_NULL)
{
n = hawk_rtx_setrec(rtx, 0, HAWK_OOECS_OOCS(&rtx->subst.oout), 0);
if (HAWK_UNLIKELY(n <= -1)) goto oops;
}
else
{
v = (s2_free == 2)?
hawk_rtx_makembsvalwithbcs(rtx, HAWK_BECS_BCS(&rtx->subst.bout)):
hawk_rtx_makestrvalwithoocs(rtx, HAWK_OOECS_OOCS(&rtx->subst.oout));
if (HAWK_UNLIKELY(!v)) goto oops;
hawk_rtx_refupval (rtx, v);
n = hawk_rtx_setrefval(rtx, (hawk_val_ref_t*)a2, v);
hawk_rtx_refdownval (rtx, v);
}
if (HAWK_UNLIKELY(n <= -1)) goto oops;
}
switch (s2_free) switch (s2_free)
{ {
case 1: case 1:
hawk_rtx_freevaloocstr (rtx, a2, s2.ptr); hawk_rtx_freevaloocstr (rtx, r2, s2.ptr);
break; break;
case 2: case 2:
hawk_rtx_freevalbcstr (rtx, a2, s2.ptr); hawk_rtx_freevalbcstr (rtx, r2, s2.ptr);
break; break;
} }
s2.ptr = HAWK_NULL;
switch (s1_free) switch (s1_free)
{ {
@ -1394,8 +1367,34 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
hawk_rtx_freevalbcstr (rtx, a1, s1.ptr); hawk_rtx_freevalbcstr (rtx, a1, s1.ptr);
break; break;
} }
s1.ptr = HAWK_NULL;
if (s0.ptr) hawk_rtx_freevaloocstr (rtx, a0, s0.ptr); if (s0.ptr)
{
hawk_rtx_freevaloocstr (rtx, a0, s0.ptr);
s0.ptr = HAWK_NULL;
}
if (sub_count > 0)
{
int n;
if (nargs < 3)
{
n = hawk_rtx_setrec(rtx, 0, HAWK_OOECS_OOCS(&rtx->fnc.oout), 0);
}
else
{
v = (s2_free == 2)?
hawk_rtx_makembsvalwithbcs(rtx, HAWK_BECS_BCS(&rtx->fnc.bout)):
hawk_rtx_makestrvalwithoocs(rtx, HAWK_OOECS_OOCS(&rtx->fnc.oout));
if (HAWK_UNLIKELY(!v)) goto oops;
hawk_rtx_refupval (rtx, v);
n = hawk_rtx_setrefval(rtx, (hawk_val_ref_t*)hawk_rtx_getarg(rtx, 2), v);
hawk_rtx_refdownval (rtx, v);
}
if (HAWK_UNLIKELY(n <= -1)) goto oops;
}
v = hawk_rtx_makeintval(rtx, sub_count); v = hawk_rtx_makeintval(rtx, sub_count);
if (HAWK_UNLIKELY(!v)) return -1; if (HAWK_UNLIKELY(!v)) return -1;
@ -1417,10 +1416,10 @@ oops:
switch (s2_free) switch (s2_free)
{ {
case 1: case 1:
hawk_rtx_freevaloocstr (rtx, a2, s2.ptr); hawk_rtx_freevaloocstr (rtx, r2, s2.ptr);
break; break;
case 2: case 2:
hawk_rtx_freevalbcstr (rtx, a2, s2.ptr); hawk_rtx_freevalbcstr (rtx, r2, s2.ptr);
break; break;
} }
} }
@ -1458,15 +1457,25 @@ int hawk_fnc_sub (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi) int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{ {
/*
match("abcdefg", "cde");
match("abcdefgdefx", "def", 7);
------------------------------------
match("abcdefgdefx", /(def)g(.+)/, 1, x);
q = length(x) / 2;
for (i = 1; i <= q; i++) print x[i,"start"], x[i,"length"];
print RSTART, RLENGTH;
*/
hawk_oow_t nargs; hawk_oow_t nargs;
hawk_val_t* a0, * a1, * a3; hawk_val_t* a0, * a1;
hawk_val_type_t a0_type;
hawk_ooch_t* str0; hawk_ooch_t* str0;
hawk_oow_t len0; hawk_oow_t len0;
hawk_int_t idx, start = 1; hawk_int_t idx, start = 1;
hawk_val_t* x0 = HAWK_NULL, * x1 = HAWK_NULL, * x2 = HAWK_NULL; hawk_val_t* x0 = HAWK_NULL, * x1 = HAWK_NULL, * x2 = HAWK_NULL;
int n; int n;
hawk_oocs_t mat, submat[9]; hawk_oocs_t mat, submat[9];
hawk_ooecs_t* tmpbuf = HAWK_NULL;
nargs = hawk_rtx_getnargs(rtx); nargs = hawk_rtx_getnargs(rtx);
HAWK_ASSERT (nargs >= 2 && nargs <= 4); HAWK_ASSERT (nargs >= 2 && nargs <= 4);
@ -1483,21 +1492,19 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
* it is treated as a match start index */ * it is treated as a match start index */
n = hawk_rtx_valtoint(rtx, a2, &start); n = hawk_rtx_valtoint(rtx, a2, &start);
if (n <= -1) return -1; if (n <= -1) return -1;
if (nargs >= 4) a3 = hawk_rtx_getarg(rtx, 3);
} }
/* TODO: match support MBS */ /* TODO: match support MBS */
#if 0 a0_type = HAWK_RTX_GETVALTYPE(rtx, a0);
if (HAWK_RTX_GETVALTYPE(rtx, a0) == HAWK_VAL_MBS) /*if (a0_type == HAWK_VAL_MBS)
{ {
str0 = ((hawk_val_mbs_t*)a0)->val.ptr; str0 = hawk_rtx_getvalbcstr(rtx, a0, &len0);
len0 = ((hawk_val_mbs_t*)a0)->val.len;
} }
#endif else
{*/
str0 = hawk_rtx_getvaloocstr(rtx, a0, &len0); str0 = hawk_rtx_getvaloocstr(rtx, a0, &len0);
if (str0 == HAWK_NULL) return -1; /*}*/
if (HAWK_UNLIKELY(!str0)) return -1;
if (start == 0) start = 1; if (start == 0) start = 1;
else if (start < 0) start = len0 + start + 1; else if (start < 0) start = len0 + start + 1;
@ -1508,15 +1515,21 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{ {
hawk_oocs_t tmp; hawk_oocs_t tmp;
/*TODO: must use str0,len0? */
tmp.ptr = str0 + start - 1; tmp.ptr = str0 + start - 1;
tmp.len = len0 - start + 1; tmp.len = len0 - start + 1;
n = hawk_rtx_matchval(rtx, a1, &tmp, &tmp, &mat, (nargs >= 4? submat: HAWK_NULL)); n = hawk_rtx_matchvalwithoocs(rtx, a1, &tmp, &tmp, &mat, (nargs >= 4? submat: HAWK_NULL));
if (n <= -1) return -1; if (n <= -1) return -1;
} }
hawk_rtx_freevaloocstr (rtx, a0, str0); /*if (a0_type == HAWK_VAL_MBS)
{
hawk_rtx_freevalbcstr (rtx, a0, str0);
}
else
{*/
hawk_rtx_freevaloocstr (rtx, a0, str0);
/*}*/
/* RSTART: 0 on no match */ /* RSTART: 0 on no match */
idx = (n == 0)? 0: ((hawk_int_t)(mat.ptr - str0) + 1); idx = (n == 0)? 0: ((hawk_int_t)(mat.ptr - str0) + 1);
@ -1537,41 +1550,40 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
hawk_oow_t i, xlen; hawk_oow_t i, xlen;
hawk_val_t* tv; hawk_val_t* tv;
tmpbuf = hawk_ooecs_open(hawk_rtx_getgem(rtx), 0, 64); hawk_ooecs_clear (&rtx->fnc.oout);
if (!tmpbuf) goto oops;
x2 = hawk_rtx_makemapval(rtx); x2 = hawk_rtx_makemapval(rtx);
if (!x2) goto oops; if (HAWK_UNLIKELY(!x2)) goto oops;
hawk_rtx_refupval (rtx, x2); hawk_rtx_refupval (rtx, x2);
submatcount =0; submatcount = 0;
subsep = hawk_rtx_getsubsep (rtx); subsep = hawk_rtx_getsubsep(rtx);
for (i = 0; i < HAWK_COUNTOF(submat); i++) for (i = 0; i < HAWK_COUNTOF(submat); i++)
{ {
if (!submat[i].ptr) break; if (!submat[i].ptr) break;
submatcount++; submatcount++;
if (hawk_ooecs_fmt(tmpbuf, HAWK_T("%d"), (int)submatcount) == (hawk_oow_t)-1 || if (hawk_ooecs_fmt(&rtx->fnc.oout, HAWK_T("%d"), (int)submatcount) == (hawk_oow_t)-1 ||
hawk_ooecs_ncat(tmpbuf, subsep->ptr, subsep->len) == (hawk_oow_t)-1) goto oops; hawk_ooecs_ncat(&rtx->fnc.oout, subsep->ptr, subsep->len) == (hawk_oow_t)-1) goto oops;
xlen = HAWK_OOECS_LEN(tmpbuf); xlen = HAWK_OOECS_LEN(&rtx->fnc.oout);
if (hawk_ooecs_ncat(tmpbuf, HAWK_T("start"), 5) == (hawk_oow_t)-1) goto oops; if (hawk_ooecs_ncat(&rtx->fnc.oout, HAWK_T("start"), 5) == (hawk_oow_t)-1) goto oops;
tv = hawk_rtx_makeintval(rtx, submat[i].ptr - str0 + 1); tv = hawk_rtx_makeintval(rtx, submat[i].ptr - str0 + 1);
if (!tv) goto oops; if (!tv) goto oops;
if (!hawk_rtx_setmapvalfld(rtx, x2, HAWK_OOECS_PTR(tmpbuf), HAWK_OOECS_LEN(tmpbuf), tv)) if (!hawk_rtx_setmapvalfld(rtx, x2, HAWK_OOECS_PTR(&rtx->fnc.oout), HAWK_OOECS_LEN(&rtx->fnc.oout), tv))
{ {
hawk_rtx_refupval (rtx, tv); hawk_rtx_refupval (rtx, tv);
hawk_rtx_refdownval (rtx, tv); hawk_rtx_refdownval (rtx, tv);
goto oops; goto oops;
} }
if (hawk_ooecs_setlen(tmpbuf, xlen) == (hawk_oow_t)-1 || if (hawk_ooecs_setlen(&rtx->fnc.oout, xlen) == (hawk_oow_t)-1 ||
hawk_ooecs_ncat(tmpbuf, HAWK_T("length"), 6) == (hawk_oow_t)-1) goto oops; hawk_ooecs_ncat(&rtx->fnc.oout, HAWK_T("length"), 6) == (hawk_oow_t)-1) goto oops;
tv = hawk_rtx_makeintval(rtx, submat[i].len); tv = hawk_rtx_makeintval(rtx, submat[i].len);
if (!tv) goto oops; if (!tv) goto oops;
if (!hawk_rtx_setmapvalfld(rtx, x2, HAWK_OOECS_PTR(tmpbuf), HAWK_OOECS_LEN(tmpbuf), tv)) if (!hawk_rtx_setmapvalfld(rtx, x2, HAWK_OOECS_PTR(&rtx->fnc.oout), HAWK_OOECS_LEN(&rtx->fnc.oout), tv))
{ {
hawk_rtx_refupval (rtx, tv); hawk_rtx_refupval (rtx, tv);
hawk_rtx_refdownval (rtx, tv); hawk_rtx_refdownval (rtx, tv);
@ -1581,7 +1593,7 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
/* the caller of this function must be able to get the submatch count by /* the caller of this function must be able to get the submatch count by
* dividing the array size by 2 */ * dividing the array size by 2 */
if (hawk_rtx_setrefval(rtx, (hawk_val_ref_t*)a3, x2) <= -1) goto oops; if (hawk_rtx_setrefval(rtx, (hawk_val_ref_t*)hawk_rtx_getarg(rtx, 3), x2) <= -1) goto oops;
} }
if (hawk_rtx_setgbl(rtx, HAWK_GBL_RSTART, x0) <= -1 || if (hawk_rtx_setgbl(rtx, HAWK_GBL_RSTART, x0) <= -1 ||
@ -1592,14 +1604,12 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
hawk_rtx_setretval (rtx, x0); hawk_rtx_setretval (rtx, x0);
if (tmpbuf) hawk_ooecs_close (tmpbuf);
if (x2) hawk_rtx_refdownval (rtx, x2); if (x2) hawk_rtx_refdownval (rtx, x2);
hawk_rtx_refdownval (rtx, x1); hawk_rtx_refdownval (rtx, x1);
hawk_rtx_refdownval (rtx, x0); hawk_rtx_refdownval (rtx, x0);
return 0; return 0;
oops: oops:
if (tmpbuf) hawk_ooecs_close (tmpbuf);
if (x2) hawk_rtx_refdownval (rtx, x2); if (x2) hawk_rtx_refdownval (rtx, x2);
if (x1) hawk_rtx_refdownval (rtx, x1); if (x1) hawk_rtx_refdownval (rtx, x1);
if (x0) hawk_rtx_refdownval (rtx, x0); if (x0) hawk_rtx_refdownval (rtx, x0);
@ -1629,11 +1639,11 @@ int hawk_fnc_sprintf (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
fbu_inited = 1; fbu_inited = 1;
cs0.ptr = hawk_rtx_getvalbcstr(rtx, a0, &cs0.len); cs0.ptr = hawk_rtx_getvalbcstr(rtx, a0, &cs0.len);
if (cs0.ptr == HAWK_NULL) goto oops_mbs; if (HAWK_UNLIKELY(!cs0.ptr)) goto oops_mbs;
x.ptr = hawk_rtx_formatmbs(rtx, &out, &fbu, cs0.ptr, cs0.len, nargs, HAWK_NULL, &x.len); x.ptr = hawk_rtx_formatmbs(rtx, &out, &fbu, cs0.ptr, cs0.len, nargs, HAWK_NULL, &x.len);
hawk_rtx_freevalbcstr (rtx, a0, cs0.ptr); hawk_rtx_freevalbcstr (rtx, a0, cs0.ptr);
if (!x.ptr) goto oops_mbs; if (HAWK_UNLIKELY(!x.ptr)) goto oops_mbs;
a0 = hawk_rtx_makembsvalwithbcs(rtx, &x); a0 = hawk_rtx_makembsvalwithbcs(rtx, &x);
if (a0 == HAWK_NULL) goto oops_mbs; if (a0 == HAWK_NULL) goto oops_mbs;
@ -1777,8 +1787,25 @@ static HAWK_INLINE int asort_compare_ud (const void* x1, const void* x2, void* c
static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int sort_keys) static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int sort_keys)
{ {
/*
a["tt"]=20; a[2]=10; a[3]=99;
asort(a);
for (i in a) print i, a[i];
---------------------------------------------
a["tt"]=20; a[2]=10; a[3]=99;
asort(a, b);
for (i in b) print i, b[i];
----------------------------------------------
function cmp(a, b) { return b - a; }
BEGIN {
a["tt"]=20; a[2]=10; a[3]=99; a[4]=66;
asort(a, b, cmp);
for (i in b) print i, b[i];
}
*/
hawk_oow_t nargs; hawk_oow_t nargs;
hawk_val_t* a0, * a0_val, * a1, * a2; hawk_val_t* a0, * a0_val, * a2;
hawk_val_type_t a0_type, v_type; hawk_val_type_t a0_type, v_type;
hawk_val_t* r, * rmap = HAWK_NULL; hawk_val_t* r, * rmap = HAWK_NULL;
hawk_int_t rv = 0; /* as if no element in the map */ hawk_int_t rv = 0; /* as if no element in the map */
@ -1812,8 +1839,6 @@ static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi,
if (nargs >= 2) if (nargs >= 2)
{ {
a1 = hawk_rtx_getarg(rtx, 1); /* destination map */
if (nargs >= 3) if (nargs >= 3)
{ {
a2 = hawk_rtx_getarg(rtx, 2); a2 = hawk_rtx_getarg(rtx, 2);
@ -1832,10 +1857,6 @@ static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi,
} }
} }
} }
else
{
a1 = a0; /* let a0 be the destination. a0 is both source and destination */
}
if (!hawk_rtx_getfirstmapvalitr(rtx, a0_val, &itr)) goto done; /* map empty */ if (!hawk_rtx_getfirstmapvalitr(rtx, a0_val, &itr)) goto done; /* map empty */
@ -1940,7 +1961,7 @@ done:
/* rmap can be NULL when a jump has been made for an empty source /* rmap can be NULL when a jump has been made for an empty source
* at the beginning of this fucntion */ * at the beginning of this fucntion */
hawk_rtx_refupval (rtx, rmap); hawk_rtx_refupval (rtx, rmap);
x = hawk_rtx_setrefval (rtx, (hawk_val_ref_t*)a1, rmap); x = hawk_rtx_setrefval(rtx, (hawk_val_ref_t*)hawk_rtx_getarg(rtx, (nargs >= 2)), rmap);
hawk_rtx_refdownval (rtx, rmap); hawk_rtx_refdownval (rtx, rmap);
if (x <= -1) if (x <= -1)
{ {

2
hawk/lib/hawk-prv.h
View File

@ -463,7 +463,7 @@ struct hawk_rtx_t
{ {
hawk_becs_t bout; hawk_becs_t bout;
hawk_ooecs_t oout; hawk_ooecs_t oout;
} subst; /* output buffer for gsub and sub */ } fnc; /* output buffer simple functions like gsub, sub, match*/
struct struct
{ {

8
hawk/lib/hawk.h
View File

@ -3127,7 +3127,7 @@ HAWK_EXPORT hawk_uch_t* hawk_rtx_valtoucstrdupwithcmgr (
*/ */
HAWK_EXPORT hawk_ooch_t* hawk_rtx_getvaloocstrwithcmgr ( HAWK_EXPORT hawk_ooch_t* hawk_rtx_getvaloocstrwithcmgr (
hawk_rtx_t* rtx, /**< runtime context */ hawk_rtx_t* rtx, /**< runtime context */
const hawk_val_t* val, /**< value to convert */ hawk_val_t* val, /**< value to convert */
hawk_oow_t* len, /**< result length */ hawk_oow_t* len, /**< result length */
hawk_cmgr_t* cmgr hawk_cmgr_t* cmgr
); );
@ -3142,14 +3142,14 @@ HAWK_EXPORT hawk_ooch_t* hawk_rtx_getvaloocstrwithcmgr (
*/ */
HAWK_EXPORT void hawk_rtx_freevaloocstr ( HAWK_EXPORT void hawk_rtx_freevaloocstr (
hawk_rtx_t* rtx, /**< runtime context */ hawk_rtx_t* rtx, /**< runtime context */
const hawk_val_t* val, /**< value to convert */ hawk_val_t* val, /**< value to convert */
hawk_ooch_t* str /**< string pointer */ hawk_ooch_t* str /**< string pointer */
); );
HAWK_EXPORT hawk_bch_t* hawk_rtx_getvalbcstrwithcmgr ( HAWK_EXPORT hawk_bch_t* hawk_rtx_getvalbcstrwithcmgr (
hawk_rtx_t* rtx, /**< runtime context */ hawk_rtx_t* rtx, /**< runtime context */
const hawk_val_t* val, /**< value to convert */ hawk_val_t* val, /**< value to convert */
hawk_oow_t* len, /**< result length */ hawk_oow_t* len, /**< result length */
hawk_cmgr_t* cmgr hawk_cmgr_t* cmgr
); );
@ -3158,7 +3158,7 @@ HAWK_EXPORT hawk_bch_t* hawk_rtx_getvalbcstrwithcmgr (
HAWK_EXPORT void hawk_rtx_freevalbcstr ( HAWK_EXPORT void hawk_rtx_freevalbcstr (
hawk_rtx_t* rtx, /**< runtime context */ hawk_rtx_t* rtx, /**< runtime context */
const hawk_val_t* val, /**< value to convert */ hawk_val_t* val, /**< value to convert */
hawk_bch_t* str /**< string pointer */ hawk_bch_t* str /**< string pointer */
); );

13
hawk/lib/misc-prv.h
View File

@ -70,12 +70,17 @@ hawk_ooch_t* hawk_rtx_strxnfld (
hawk_oocs_t* tok hawk_oocs_t* tok
); );
int hawk_rtx_matchval ( int hawk_rtx_matchvalwithucs (
hawk_rtx_t* rtx, hawk_val_t* val, hawk_rtx_t* rtx, hawk_val_t* val,
const hawk_oocs_t* str, const hawk_oocs_t* substr, const hawk_ucs_t* str, const hawk_ucs_t* substr,
hawk_oocs_t* match, hawk_oocs_t submat[9] hawk_ucs_t* match, hawk_ucs_t submat[9]
); );
int hawk_rtx_matchvalwithbcs (
hawk_rtx_t* rtx, hawk_val_t* val,
const hawk_bcs_t* str, const hawk_bcs_t* substr,
hawk_bcs_t* match, hawk_bcs_t submat[9]
);
int hawk_rtx_matchrexwithucs ( int hawk_rtx_matchrexwithucs (
hawk_rtx_t* rtx, hawk_tre_t* code, hawk_rtx_t* rtx, hawk_tre_t* code,
@ -90,8 +95,10 @@ int hawk_rtx_matchrexwithbcs (
); );
#if defined(HAWK_OOCH_IS_UCH) #if defined(HAWK_OOCH_IS_UCH)
# define hawk_rtx_matchvalwithoocs hawk_rtx_matchvalwithucs
# define hawk_rtx_matchrexwithoocs hawk_rtx_matchrexwithucs # define hawk_rtx_matchrexwithoocs hawk_rtx_matchrexwithucs
#else #else
# define hawk_rtx_matchvalwithoocs hawk_rtx_matchvalwithbcs
# define hawk_rtx_matchrexwithoocs hawk_rtx_matchrexwithbcs # define hawk_rtx_matchrexwithoocs hawk_rtx_matchrexwithbcs
#endif #endif

60
hawk/lib/misc.c
View File

@ -510,15 +510,17 @@ static int matchtre_bcs (hawk_tre_t* tre, int opt, const hawk_bcs_t* str, hawk_b
return 1; return 1;
} }
int hawk_rtx_matchval (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_oocs_t* str, const hawk_oocs_t* substr, hawk_oocs_t* match, hawk_oocs_t submat[9]) int hawk_rtx_matchvalwithucs (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_ucs_t* str, const hawk_ucs_t* substr, hawk_ucs_t* match, hawk_ucs_t submat[9])
{ {
int ignorecase, x; int ignorecase, x;
int opt = HAWK_TRE_BACKTRACKING; /* TODO: option... HAWK_TRE_BACKTRACKING ??? */ int opt = HAWK_TRE_BACKTRACKING; /* TODO: option... HAWK_TRE_BACKTRACKING ??? */
hawk_tre_t* code; hawk_tre_t* code;
hawk_val_type_t v_type;
ignorecase = rtx->gbl.ignorecase; ignorecase = rtx->gbl.ignorecase;
if (HAWK_RTX_GETVALTYPE(rtx, val) == HAWK_VAL_REX) v_type = HAWK_RTX_GETVALTYPE(rtx, val);
if (v_type == HAWK_VAL_REX)
{ {
code = ((hawk_val_rex_t*)val)->code[ignorecase]; code = ((hawk_val_rex_t*)val)->code[ignorecase];
} }
@ -536,16 +538,13 @@ int hawk_rtx_matchval (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_oocs_t* str,
if (x <= -1) return -1; if (x <= -1) return -1;
} }
#if defined(HAWK_OOCH_IS_UCH)
x = matchtre_ucs( x = matchtre_ucs(
#else
x = matchtre_bcs(
#endif
code, ((str->ptr == substr->ptr)? opt: (opt | HAWK_TRE_NOTBOL)), code, ((str->ptr == substr->ptr)? opt: (opt | HAWK_TRE_NOTBOL)),
substr, match, submat, hawk_rtx_getgem(rtx) substr, match, submat, hawk_rtx_getgem(rtx)
); );
if (HAWK_RTX_GETVALTYPE(rtx, val) == HAWK_VAL_REX) if (v_type == HAWK_VAL_REX)
{ {
/* nothing to free */ /* nothing to free */
} }
@ -557,6 +556,53 @@ int hawk_rtx_matchval (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_oocs_t* str,
return x; return x;
} }
int hawk_rtx_matchvalwithbcs (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_bcs_t* str, const hawk_bcs_t* substr, hawk_bcs_t* match, hawk_bcs_t submat[9])
{
int ignorecase, x;
int opt = HAWK_TRE_BACKTRACKING; /* TODO: option... HAWK_TRE_BACKTRACKING ??? */
hawk_tre_t* code;
hawk_val_type_t v_type;
ignorecase = rtx->gbl.ignorecase;
v_type = HAWK_RTX_GETVALTYPE(rtx, val);
if (v_type == HAWK_VAL_REX)
{
code = ((hawk_val_rex_t*)val)->code[ignorecase];
}
else
{
/* convert to a string and build a regular expression */
hawk_oocs_t tmp;
tmp.ptr = hawk_rtx_getvaloocstr(rtx, val, &tmp.len);
if (HAWK_UNLIKELY(!tmp.ptr)) return -1;
x = ignorecase? hawk_rtx_buildrex(rtx, tmp.ptr, tmp.len, HAWK_NULL, &code):
hawk_rtx_buildrex(rtx, tmp.ptr, tmp.len, &code, HAWK_NULL);
hawk_rtx_freevaloocstr (rtx, val, tmp.ptr);
if (x <= -1) return -1;
}
x = matchtre_bcs(
code, ((str->ptr == substr->ptr)? opt: (opt | HAWK_TRE_NOTBOL)),
substr, match, submat, hawk_rtx_getgem(rtx)
);
if (v_type == HAWK_VAL_REX)
{
/* nothing to free */
}
else
{
hawk_tre_close (code);
}
return x;
}
int hawk_rtx_matchrexwithucs (hawk_rtx_t* rtx, hawk_tre_t* code, const hawk_ucs_t* str, const hawk_ucs_t* substr, hawk_ucs_t* match, hawk_ucs_t submat[9]) int hawk_rtx_matchrexwithucs (hawk_rtx_t* rtx, hawk_tre_t* code, const hawk_ucs_t* str, const hawk_ucs_t* substr, hawk_ucs_t* match, hawk_ucs_t submat[9])
{ {
int opt = HAWK_TRE_BACKTRACKING; /* TODO: option... HAWK_TRE_BACKTRACKING or others??? */ int opt = HAWK_TRE_BACKTRACKING; /* TODO: option... HAWK_TRE_BACKTRACKING or others??? */

22
hawk/lib/run.c
View File

@ -1055,8 +1055,8 @@ static int init_rtx (hawk_rtx_t* rtx, hawk_t* awk, hawk_rio_cbs_t* rio)
if (hawk_becs_init(&rtx->formatmbs.out, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_7; if (hawk_becs_init(&rtx->formatmbs.out, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_7;
if (hawk_becs_init(&rtx->formatmbs.fmt, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_8; if (hawk_becs_init(&rtx->formatmbs.fmt, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_8;
if (hawk_becs_init(&rtx->subst.bout, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_9; if (hawk_becs_init(&rtx->fnc.bout, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_9;
if (hawk_ooecs_init(&rtx->subst.oout, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_10; if (hawk_ooecs_init(&rtx->fnc.oout, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_10;
rtx->named = hawk_htb_open(hawk_rtx_getgem(rtx), HAWK_SIZEOF(rtx), 1024, 70, HAWK_SIZEOF(hawk_ooch_t), 1); rtx->named = hawk_htb_open(hawk_rtx_getgem(rtx), HAWK_SIZEOF(rtx), 1024, 70, HAWK_SIZEOF(hawk_ooch_t), 1);
@ -1107,9 +1107,9 @@ oops_13:
oops_12: oops_12:
hawk_htb_close (rtx->named); hawk_htb_close (rtx->named);
oops_11: oops_11:
hawk_becs_fini (&rtx->subst.oout); hawk_becs_fini (&rtx->fnc.oout);
oops_10: oops_10:
hawk_becs_fini (&rtx->subst.bout); hawk_becs_fini (&rtx->fnc.bout);
oops_9: oops_9:
hawk_becs_fini (&rtx->formatmbs.fmt); hawk_becs_fini (&rtx->formatmbs.fmt);
oops_8: oops_8:
@ -1196,8 +1196,8 @@ static void fini_rtx (hawk_rtx_t* rtx, int fini_globals)
rtx->gbl.subsep.len = 0; rtx->gbl.subsep.len = 0;
} }
hawk_ooecs_fini (&rtx->subst.oout); hawk_ooecs_fini (&rtx->fnc.oout);
hawk_becs_fini (&rtx->subst.bout); hawk_becs_fini (&rtx->fnc.bout);
hawk_rtx_freemem (rtx, rtx->formatmbs.tmp.ptr); hawk_rtx_freemem (rtx, rtx->formatmbs.tmp.ptr);
rtx->formatmbs.tmp.ptr = HAWK_NULL; rtx->formatmbs.tmp.ptr = HAWK_NULL;
@ -3369,7 +3369,7 @@ static hawk_val_t* eval_expression (hawk_rtx_t* rtx, hawk_nde_t* nde)
#endif #endif
} }
n = hawk_rtx_matchval(rtx, v, &vs, &vs, HAWK_NULL, HAWK_NULL); n = hawk_rtx_matchvalwithoocs(rtx, v, &vs, &vs, HAWK_NULL, HAWK_NULL);
hawk_rtx_refdownval (rtx, v); hawk_rtx_refdownval (rtx, v);
if (free_vs) hawk_rtx_freevaloocstr (rtx, rtx->inrec.d0, vs.ptr); if (free_vs) hawk_rtx_freevaloocstr (rtx, rtx->inrec.d0, vs.ptr);
if (n <= -1) if (n <= -1)
@ -5389,17 +5389,17 @@ static hawk_val_t* eval_binop_match0 (
out.ptr = hawk_rtx_getvaloocstr (rtx, left, &out.len); out.ptr = hawk_rtx_getvaloocstr (rtx, left, &out.len);
if (out.ptr == HAWK_NULL) return HAWK_NULL; if (out.ptr == HAWK_NULL) return HAWK_NULL;
n = hawk_rtx_matchval(rtx, right, &out, &out, HAWK_NULL, HAWK_NULL); n = hawk_rtx_matchvalwithoocs(rtx, right, &out, &out, HAWK_NULL, HAWK_NULL);
hawk_rtx_freevaloocstr (rtx, left, out.ptr); hawk_rtx_freevaloocstr (rtx, left, out.ptr);
if (n <= -1) if (HAWK_UNLIKELY(n <= -1))
{ {
ADJERR_LOC (rtx, lloc); ADJERR_LOC (rtx, lloc);
return HAWK_NULL; return HAWK_NULL;
} }
res = hawk_rtx_makeintval (rtx, (n == ret)); res = hawk_rtx_makeintval(rtx, (n == ret));
if (res == HAWK_NULL) if (HAWK_UNLIKELY(!res))
{ {
ADJERR_LOC (rtx, lloc); ADJERR_LOC (rtx, lloc);
return HAWK_NULL; return HAWK_NULL;

2
hawk/lib/std.c
View File

@ -3147,7 +3147,7 @@ done:
if (rv) if (rv)
{ {
hawk_rtx_refupval (rtx, rv); hawk_rtx_refupval (rtx, rv);
ret = hawk_rtx_setrefval (rtx, (hawk_val_ref_t*)hawk_rtx_getarg (rtx, 2), rv); ret = hawk_rtx_setrefval (rtx, (hawk_val_ref_t*)hawk_rtx_getarg(rtx, 2), rv);
hawk_rtx_refdownval (rtx, rv); hawk_rtx_refdownval (rtx, rv);
if (ret >= 0) hawk_rtx_setretval (rtx, HAWK_VAL_ZERO); if (ret >= 0) hawk_rtx_setretval (rtx, HAWK_VAL_ZERO);
} }

120
hawk/lib/val.c
View File

@ -302,7 +302,6 @@ hawk_val_t* hawk_rtx_makestrvalwithbchars2 (hawk_rtx_t* rtx, const hawk_bch_t* b
hawk_val_t* hawk_rtx_makenumorstrvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_t* ptr, hawk_oow_t len) hawk_val_t* hawk_rtx_makenumorstrvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_t* ptr, hawk_oow_t len)
{ {
hawk_t* hawk = hawk_rtx_gethawk(rtx);
int x; int x;
hawk_int_t l; hawk_int_t l;
hawk_flt_t r; hawk_flt_t r;
@ -316,7 +315,6 @@ hawk_val_t* hawk_rtx_makenumorstrvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_
hawk_val_t* hawk_rtx_makenumorstrvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len) hawk_val_t* hawk_rtx_makenumorstrvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len)
{ {
hawk_t* hawk = hawk_rtx_gethawk(rtx);
int x; int x;
hawk_int_t l; hawk_int_t l;
hawk_flt_t r; hawk_flt_t r;
@ -333,7 +331,6 @@ hawk_val_t* hawk_rtx_makenumorstrvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_
hawk_val_t* hawk_rtx_makenstrvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_t* ptr, hawk_oow_t len) hawk_val_t* hawk_rtx_makenstrvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_t* ptr, hawk_oow_t len)
{ {
hawk_t* hawk = hawk_rtx_gethawk(rtx);
int x; int x;
hawk_val_t* v; hawk_val_t* v;
hawk_int_t l; hawk_int_t l;
@ -357,7 +354,6 @@ hawk_val_t* hawk_rtx_makenstrvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_t* p
hawk_val_t* hawk_rtx_makenstrvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len) hawk_val_t* hawk_rtx_makenstrvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len)
{ {
hawk_t* hawk = hawk_rtx_gethawk(rtx);
int x; int x;
hawk_val_t* v; hawk_val_t* v;
hawk_int_t l; hawk_int_t l;
@ -460,7 +456,6 @@ hawk_val_t* hawk_rtx_makembsvalwithucs (hawk_rtx_t* rtx, const hawk_ucs_t* ucs)
hawk_val_t* hawk_rtx_makenumormbsvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_t* ptr, hawk_oow_t len) hawk_val_t* hawk_rtx_makenumormbsvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_t* ptr, hawk_oow_t len)
{ {
hawk_t* hawk = hawk_rtx_gethawk(rtx);
int x; int x;
hawk_int_t l; hawk_int_t l;
hawk_flt_t r; hawk_flt_t r;
@ -474,7 +469,6 @@ hawk_val_t* hawk_rtx_makenumormbsvalwithuchars (hawk_rtx_t* rtx, const hawk_uch_
hawk_val_t* hawk_rtx_makenumormbsvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len) hawk_val_t* hawk_rtx_makenumormbsvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len)
{ {
hawk_t* hawk = hawk_rtx_gethawk(rtx);
int x; int x;
hawk_int_t l; hawk_int_t l;
hawk_flt_t r; hawk_flt_t r;
@ -1362,7 +1356,7 @@ static int val_ref_to_str (hawk_rtx_t* rtx, const hawk_val_ref_t* ref, hawk_rtx_
case HAWK_VAL_REF_POS: case HAWK_VAL_REF_POS:
{ {
hawk_oow_t idx; hawk_oow_t idx;
/* special case when the reference value is /* special case when the reference value is
* pointing to the positional */ * pointing to the positional */
@ -1594,54 +1588,110 @@ hawk_uch_t* hawk_rtx_valtoucstrdupwithcmgr (hawk_rtx_t* rtx, const hawk_val_t* v
return wcs; return wcs;
} }
hawk_ooch_t* hawk_rtx_getvaloocstrwithcmgr (hawk_rtx_t* rtx, const hawk_val_t* v, hawk_oow_t* len, hawk_cmgr_t* cmgr) hawk_ooch_t* hawk_rtx_getvaloocstrwithcmgr (hawk_rtx_t* rtx, hawk_val_t* v, hawk_oow_t* len, hawk_cmgr_t* cmgr)
{ {
if (HAWK_RTX_GETVALTYPE(rtx, v) == HAWK_VAL_STR) switch (HAWK_RTX_GETVALTYPE(rtx, v))
{ {
if (len) *len = ((hawk_val_str_t*)v)->val.len; case HAWK_VAL_STR:
return ((hawk_val_str_t*)v)->val.ptr; #if 0
} plain_str:
else #endif
{ if (len) *len = ((hawk_val_str_t*)v)->val.len;
return hawk_rtx_valtooocstrdupwithcmgr(rtx, v, len, cmgr); return ((hawk_val_str_t*)v)->val.ptr;
#if 0
/* i'm commenting out this part because hawk_rtx_setrefval() changes v->adr
* and leads hawk_rtx_freevaloocstr() to check a wrong value obejct.
* if you know that a value is a reference, you can get the referenced value
* with hawk_rtx_getrefval() and call this function over it */
case HAWK_VAL_REF:
v = hawk_rtx_getrefval(rtx, (hawk_val_ref_t*)v);
if (HAWK_RTX_GETVALTYPE(rtx, v) == HAWK_VAL_STR) goto plain_str;
/* fall through */
#endif
default:
return hawk_rtx_valtooocstrdupwithcmgr(rtx, v, len, cmgr);
} }
} }
void hawk_rtx_freevaloocstr (hawk_rtx_t* rtx, const hawk_val_t* v, hawk_ooch_t* str) void hawk_rtx_freevaloocstr (hawk_rtx_t* rtx, hawk_val_t* v, hawk_ooch_t* str)
{ {
if (HAWK_RTX_GETVALTYPE(rtx, v) != HAWK_VAL_STR || switch (HAWK_RTX_GETVALTYPE(rtx, v))
str != ((hawk_val_str_t*)v)->val.ptr)
{ {
hawk_rtx_freemem (rtx, str); case HAWK_VAL_STR:
#if 0
plain_str:
#endif
if (str != ((hawk_val_str_t*)v)->val.ptr) hawk_rtx_freemem (rtx, str);
break;
#if 0
case HAWK_VAL_REF:
v = hawk_rtx_getrefval(rtx, (hawk_val_ref_t*)v);
if (HAWK_RTX_GETVALTYPE(rtx, v) == HAWK_VAL_STR) goto plain_str;
/* fall through */
#endif
default:
hawk_rtx_freemem (rtx, str);
break;
} }
} }
hawk_bch_t* hawk_rtx_getvalbcstrwithcmgr (hawk_rtx_t* rtx, const hawk_val_t* v, hawk_oow_t* len, hawk_cmgr_t* cmgr) hawk_bch_t* hawk_rtx_getvalbcstrwithcmgr (hawk_rtx_t* rtx, hawk_val_t* v, hawk_oow_t* len, hawk_cmgr_t* cmgr)
{ {
if (HAWK_RTX_GETVALTYPE(rtx, v) == HAWK_VAL_MBS) switch (HAWK_RTX_GETVALTYPE(rtx, v))
{ {
if (len) *len = ((hawk_val_mbs_t*)v)->val.len; case HAWK_VAL_MBS:
return ((hawk_val_mbs_t*)v)->val.ptr; #if 0
} plain_mbs:
else #endif
{ if (len) *len = ((hawk_val_mbs_t*)v)->val.len;
return hawk_rtx_valtobcstrdupwithcmgr(rtx, v, len, cmgr); return ((hawk_val_mbs_t*)v)->val.ptr;
#if 0
/* i'm commenting out this part because hawk_rtx_setrefval() changes v->adr
* and leads hawk_rtx_freevalbcstr() to check a wrong value obejct.
* if you know that a value is a reference, you can get the referenced value
* with hawk_rtx_getrefval() and call this function over it */
case HAWK_VAL_REF:
v = hawk_rtx_getrefval(rtx, (hawk_val_ref_t*)v);
if (HAWK_RTX_GETVALTYPE(rtx, v) == HAWK_VAL_MBS) goto plain_mbs;
/* fall through */
#endif
default:
return hawk_rtx_valtobcstrdupwithcmgr(rtx, v, len, cmgr);
} }
} }
void hawk_rtx_freevalbcstr (hawk_rtx_t* rtx, const hawk_val_t* v, hawk_bch_t* str) void hawk_rtx_freevalbcstr (hawk_rtx_t* rtx, hawk_val_t* v, hawk_bch_t* str)
{ {
if (HAWK_RTX_GETVALTYPE(rtx, v) != HAWK_VAL_MBS || switch (HAWK_RTX_GETVALTYPE(rtx, v))
str != ((hawk_val_mbs_t*)v)->val.ptr)
{ {
hawk_rtx_freemem (rtx, str); case HAWK_VAL_MBS:
#if 0
plain_mbs:
#endif
if (str != ((hawk_val_mbs_t*)v)->val.ptr) hawk_rtx_freemem (rtx, str);
break;
#if 0
case HAWK_VAL_REF:
v = hawk_rtx_getrefval(rtx, (hawk_val_ref_t*)v);
if (HAWK_RTX_GETVALTYPE(rtx, v) == HAWK_VAL_MBS) goto plain_mbs;
/* fall through */
#endif
default:
hawk_rtx_freemem (rtx, str);
break;
} }
} }
static int val_ref_to_num (hawk_rtx_t* rtx, const hawk_val_ref_t* ref, hawk_int_t* l, hawk_flt_t* r) static int val_ref_to_num (hawk_rtx_t* rtx, const hawk_val_ref_t* ref, hawk_int_t* l, hawk_flt_t* r)
{ {
hawk_t* hawk = hawk_rtx_gethawk(rtx);
switch (ref->id) switch (ref->id)
{ {
case HAWK_VAL_REF_POS: case HAWK_VAL_REF_POS:
@ -1698,7 +1748,6 @@ static int val_ref_to_num (hawk_rtx_t* rtx, const hawk_val_ref_t* ref, hawk_int_
int hawk_rtx_valtonum (hawk_rtx_t* rtx, const hawk_val_t* v, hawk_int_t* l, hawk_flt_t* r) int hawk_rtx_valtonum (hawk_rtx_t* rtx, const hawk_val_t* v, hawk_int_t* l, hawk_flt_t* r)
{ {
hawk_val_type_t vtype = HAWK_RTX_GETVALTYPE(rtx, v); hawk_val_type_t vtype = HAWK_RTX_GETVALTYPE(rtx, v);
hawk_t* hawk = hawk_rtx_gethawk(rtx);
switch (vtype) switch (vtype)
{ {
@ -1854,6 +1903,7 @@ hawk_val_type_t hawk_rtx_getrefvaltype (hawk_rtx_t* rtx, hawk_val_ref_t* ref)
{ {
return HAWK_VAL_STR; return HAWK_VAL_STR;
} }
case HAWK_VAL_REF_GBL: case HAWK_VAL_REF_GBL:
{ {
hawk_oow_t idx; hawk_oow_t idx;
@ -1902,7 +1952,7 @@ hawk_val_t* hawk_rtx_getrefval (hawk_rtx_t* rtx, hawk_val_ref_t* ref)
/* A reference value is not able to point to another /* A reference value is not able to point to another
* refernce value for the way values are represented * refernce value for the way values are represented
* in HAWKAWK */ * in HAWKAWK */
HAWK_ASSERT (HAWK_RTX_GETVALTYPE (rtx, *xref)!= HAWK_VAL_REF); HAWK_ASSERT (HAWK_RTX_GETVALTYPE(rtx, *xref) != HAWK_VAL_REF);
return *xref; return *xref;
} }
} }