added hawk_rtx_matchvalwithucs() and hawk_rtx_matchvalwithbcs()
renamed hawk_rtx_matchval() to hawk_rtx_matchvalwithoocs() updated code concerning the call to hawk_rtx_setrefval()
This commit is contained in:
parent
260df21f85
commit
bae06804ef
199
hawk/lib/fnc.c
199
hawk/lib/fnc.c
@ -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)
|
||||
{
|
||||
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_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_int_t nflds;
|
||||
|
||||
hawk_errnum_t errnum;
|
||||
int x;
|
||||
|
||||
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);
|
||||
|
||||
a0 = hawk_rtx_getarg(rtx, 0);
|
||||
a1 = hawk_rtx_getarg(rtx, 1);
|
||||
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);
|
||||
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);
|
||||
if (t1 == HAWK_NULL) goto oops;
|
||||
if (HAWK_UNLIKELY(!t1)) goto oops;
|
||||
|
||||
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);
|
||||
if (x <= -1) goto oops;
|
||||
if (HAWK_UNLIKELY(x <= -1)) goto oops;
|
||||
|
||||
/* fill the map with actual values */
|
||||
p = str.ptr; str_left = str.len; org_len = str.len;
|
||||
nflds = 0;
|
||||
|
||||
while (p != HAWK_NULL)
|
||||
while (p)
|
||||
{
|
||||
hawk_ooch_t key_buf[HAWK_SIZEOF(hawk_int_t)*8+2];
|
||||
hawk_oow_t key_len;
|
||||
@ -1246,7 +1240,7 @@ oops:
|
||||
static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
|
||||
{
|
||||
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_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_free = HAWK_NULL;
|
||||
|
||||
hawk_oow_t sub_count;
|
||||
|
||||
s0.ptr = HAWK_NULL;
|
||||
@ -1268,14 +1261,10 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
|
||||
s1.len = 0;
|
||||
|
||||
nargs = hawk_rtx_getnargs(rtx);
|
||||
HAWK_ASSERT (nargs >= 2 && nargs <= 3);
|
||||
|
||||
a0 = hawk_rtx_getarg(rtx, 0);
|
||||
a1 = hawk_rtx_getarg(rtx, 1);
|
||||
a2 = (nargs >= 3)? hawk_rtx_getarg(rtx, 2): HAWK_NULL;
|
||||
|
||||
a0_vtype = HAWK_RTX_GETVALTYPE(rtx, a0);
|
||||
HAWK_ASSERT (a2 == HAWK_NULL || HAWK_RTX_GETVALTYPE(rtx, a2) == HAWK_VAL_REF);
|
||||
|
||||
/* the first argument - pattern */
|
||||
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 */
|
||||
if (a2 == HAWK_NULL)
|
||||
if (nargs < 3)
|
||||
{
|
||||
/* is this correct? any needs to use inrec.d0? */
|
||||
s2.ptr = HAWK_OOECS_PTR(&rtx->inrec.line);
|
||||
@ -1299,9 +1288,13 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
|
||||
s1.ptr = hawk_rtx_getvaloocstr(rtx, a1, &s1.len);
|
||||
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));
|
||||
|
||||
if (HAWK_RTX_GETVALTYPE(rtx, r2) == HAWK_VAL_MBS)
|
||||
{
|
||||
s2.ptr = hawk_rtx_getvalbcstr(rtx, r2, &s2.len);
|
||||
s2_free = 2;
|
||||
|
||||
/* the second argument - substitute */
|
||||
@ -1310,13 +1303,14 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
|
||||
}
|
||||
else
|
||||
{
|
||||
s2.ptr = hawk_rtx_getvaloocstr(rtx, a2, &s2.len);
|
||||
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;
|
||||
|
||||
@ -1335,13 +1329,13 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
|
||||
sub_count = max_count;
|
||||
if (s2_free == 2)
|
||||
{
|
||||
hawk_becs_clear(&rtx->subst.bout);
|
||||
if (__substitute_bcs(rtx, &sub_count, rex, (hawk_bcs_t*)&s1, (hawk_bcs_t*)&s2, &rtx->subst.bout) <= -1) goto oops;
|
||||
hawk_becs_clear(&rtx->fnc.bout);
|
||||
if (__substitute_bcs(rtx, &sub_count, rex, (hawk_bcs_t*)&s1, (hawk_bcs_t*)&s2, &rtx->fnc.bout) <= -1) goto oops;
|
||||
}
|
||||
else
|
||||
{
|
||||
hawk_ooecs_clear(&rtx->subst.oout);
|
||||
if (__substitute_oocs(rtx, &sub_count, rex, (hawk_oocs_t*)&s1, (hawk_oocs_t*)&s2, &rtx->subst.oout) <= -1) goto oops;
|
||||
hawk_ooecs_clear(&rtx->fnc.oout);
|
||||
if (__substitute_oocs(rtx, &sub_count, rex, (hawk_oocs_t*)&s1, (hawk_oocs_t*)&s2, &rtx->fnc.oout) <= -1) goto oops;
|
||||
}
|
||||
|
||||
if (rex_free)
|
||||
@ -1353,37 +1347,16 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
|
||||
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)
|
||||
{
|
||||
case 1:
|
||||
hawk_rtx_freevaloocstr (rtx, a2, s2.ptr);
|
||||
hawk_rtx_freevaloocstr (rtx, r2, s2.ptr);
|
||||
break;
|
||||
case 2:
|
||||
hawk_rtx_freevalbcstr (rtx, a2, s2.ptr);
|
||||
hawk_rtx_freevalbcstr (rtx, r2, s2.ptr);
|
||||
break;
|
||||
}
|
||||
s2.ptr = HAWK_NULL;
|
||||
|
||||
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);
|
||||
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);
|
||||
if (HAWK_UNLIKELY(!v)) return -1;
|
||||
@ -1417,10 +1416,10 @@ oops:
|
||||
switch (s2_free)
|
||||
{
|
||||
case 1:
|
||||
hawk_rtx_freevaloocstr (rtx, a2, s2.ptr);
|
||||
hawk_rtx_freevaloocstr (rtx, r2, s2.ptr);
|
||||
break;
|
||||
case 2:
|
||||
hawk_rtx_freevalbcstr (rtx, a2, s2.ptr);
|
||||
hawk_rtx_freevalbcstr (rtx, r2, s2.ptr);
|
||||
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)
|
||||
{
|
||||
/*
|
||||
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_val_t* a0, * a1, * a3;
|
||||
hawk_val_t* a0, * a1;
|
||||
hawk_val_type_t a0_type;
|
||||
hawk_ooch_t* str0;
|
||||
hawk_oow_t len0;
|
||||
hawk_int_t idx, start = 1;
|
||||
hawk_val_t* x0 = HAWK_NULL, * x1 = HAWK_NULL, * x2 = HAWK_NULL;
|
||||
int n;
|
||||
hawk_oocs_t mat, submat[9];
|
||||
hawk_ooecs_t* tmpbuf = HAWK_NULL;
|
||||
|
||||
nargs = hawk_rtx_getnargs(rtx);
|
||||
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 */
|
||||
n = hawk_rtx_valtoint(rtx, a2, &start);
|
||||
if (n <= -1) return -1;
|
||||
|
||||
if (nargs >= 4) a3 = hawk_rtx_getarg(rtx, 3);
|
||||
}
|
||||
|
||||
/* TODO: match support MBS */
|
||||
#if 0
|
||||
if (HAWK_RTX_GETVALTYPE(rtx, a0) == HAWK_VAL_MBS)
|
||||
a0_type = HAWK_RTX_GETVALTYPE(rtx, a0);
|
||||
/*if (a0_type == HAWK_VAL_MBS)
|
||||
{
|
||||
str0 = ((hawk_val_mbs_t*)a0)->val.ptr;
|
||||
len0 = ((hawk_val_mbs_t*)a0)->val.len;
|
||||
str0 = hawk_rtx_getvalbcstr(rtx, a0, &len0);
|
||||
}
|
||||
#endif
|
||||
|
||||
else
|
||||
{*/
|
||||
str0 = hawk_rtx_getvaloocstr(rtx, a0, &len0);
|
||||
if (str0 == HAWK_NULL) return -1;
|
||||
/*}*/
|
||||
if (HAWK_UNLIKELY(!str0)) return -1;
|
||||
|
||||
if (start == 0) 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;
|
||||
|
||||
/*TODO: must use str0,len0? */
|
||||
tmp.ptr = str0 + 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 (a0_type == HAWK_VAL_MBS)
|
||||
{
|
||||
hawk_rtx_freevalbcstr (rtx, a0, str0);
|
||||
}
|
||||
else
|
||||
{*/
|
||||
hawk_rtx_freevaloocstr (rtx, a0, str0);
|
||||
/*}*/
|
||||
|
||||
/* RSTART: 0 on no match */
|
||||
idx = (n == 0)? 0: ((hawk_int_t)(mat.ptr - str0) + 1);
|
||||
@ -1537,11 +1550,10 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
|
||||
hawk_oow_t i, xlen;
|
||||
hawk_val_t* tv;
|
||||
|
||||
tmpbuf = hawk_ooecs_open(hawk_rtx_getgem(rtx), 0, 64);
|
||||
if (!tmpbuf) goto oops;
|
||||
hawk_ooecs_clear (&rtx->fnc.oout);
|
||||
|
||||
x2 = hawk_rtx_makemapval(rtx);
|
||||
if (!x2) goto oops;
|
||||
if (HAWK_UNLIKELY(!x2)) goto oops;
|
||||
hawk_rtx_refupval (rtx, x2);
|
||||
|
||||
submatcount = 0;
|
||||
@ -1552,26 +1564,26 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
|
||||
|
||||
submatcount++;
|
||||
|
||||
if (hawk_ooecs_fmt(tmpbuf, HAWK_T("%d"), (int)submatcount) == (hawk_oow_t)-1 ||
|
||||
hawk_ooecs_ncat(tmpbuf, subsep->ptr, subsep->len) == (hawk_oow_t)-1) goto oops;
|
||||
xlen = HAWK_OOECS_LEN(tmpbuf);
|
||||
if (hawk_ooecs_ncat(tmpbuf, HAWK_T("start"), 5) == (hawk_oow_t)-1) goto oops;
|
||||
if (hawk_ooecs_fmt(&rtx->fnc.oout, HAWK_T("%d"), (int)submatcount) == (hawk_oow_t)-1 ||
|
||||
hawk_ooecs_ncat(&rtx->fnc.oout, subsep->ptr, subsep->len) == (hawk_oow_t)-1) goto oops;
|
||||
xlen = HAWK_OOECS_LEN(&rtx->fnc.oout);
|
||||
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);
|
||||
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_refdownval (rtx, tv);
|
||||
goto oops;
|
||||
}
|
||||
|
||||
if (hawk_ooecs_setlen(tmpbuf, xlen) == (hawk_oow_t)-1 ||
|
||||
hawk_ooecs_ncat(tmpbuf, HAWK_T("length"), 6) == (hawk_oow_t)-1) goto oops;
|
||||
if (hawk_ooecs_setlen(&rtx->fnc.oout, xlen) == (hawk_oow_t)-1 ||
|
||||
hawk_ooecs_ncat(&rtx->fnc.oout, HAWK_T("length"), 6) == (hawk_oow_t)-1) goto oops;
|
||||
|
||||
tv = hawk_rtx_makeintval(rtx, submat[i].len);
|
||||
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_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
|
||||
* 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 ||
|
||||
@ -1592,14 +1604,12 @@ int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
|
||||
|
||||
hawk_rtx_setretval (rtx, x0);
|
||||
|
||||
if (tmpbuf) hawk_ooecs_close (tmpbuf);
|
||||
if (x2) hawk_rtx_refdownval (rtx, x2);
|
||||
hawk_rtx_refdownval (rtx, x1);
|
||||
hawk_rtx_refdownval (rtx, x0);
|
||||
return 0;
|
||||
|
||||
oops:
|
||||
if (tmpbuf) hawk_ooecs_close (tmpbuf);
|
||||
if (x2) hawk_rtx_refdownval (rtx, x2);
|
||||
if (x1) hawk_rtx_refdownval (rtx, x1);
|
||||
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;
|
||||
|
||||
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);
|
||||
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);
|
||||
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)
|
||||
{
|
||||
/*
|
||||
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_val_t* a0, * a0_val, * a1, * a2;
|
||||
hawk_val_t* a0, * a0_val, * a2;
|
||||
hawk_val_type_t a0_type, v_type;
|
||||
hawk_val_t* r, * rmap = HAWK_NULL;
|
||||
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)
|
||||
{
|
||||
a1 = hawk_rtx_getarg(rtx, 1); /* destination map */
|
||||
|
||||
if (nargs >= 3)
|
||||
{
|
||||
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 */
|
||||
|
||||
@ -1940,7 +1961,7 @@ done:
|
||||
/* rmap can be NULL when a jump has been made for an empty source
|
||||
* at the beginning of this fucntion */
|
||||
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);
|
||||
if (x <= -1)
|
||||
{
|
||||
|
||||
@ -463,7 +463,7 @@ struct hawk_rtx_t
|
||||
{
|
||||
hawk_becs_t bout;
|
||||
hawk_ooecs_t oout;
|
||||
} subst; /* output buffer for gsub and sub */
|
||||
} fnc; /* output buffer simple functions like gsub, sub, match*/
|
||||
|
||||
struct
|
||||
{
|
||||
|
||||
@ -3127,7 +3127,7 @@ HAWK_EXPORT hawk_uch_t* hawk_rtx_valtoucstrdupwithcmgr (
|
||||
*/
|
||||
HAWK_EXPORT hawk_ooch_t* hawk_rtx_getvaloocstrwithcmgr (
|
||||
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_cmgr_t* cmgr
|
||||
);
|
||||
@ -3142,14 +3142,14 @@ HAWK_EXPORT hawk_ooch_t* hawk_rtx_getvaloocstrwithcmgr (
|
||||
*/
|
||||
HAWK_EXPORT void hawk_rtx_freevaloocstr (
|
||||
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_EXPORT hawk_bch_t* hawk_rtx_getvalbcstrwithcmgr (
|
||||
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_cmgr_t* cmgr
|
||||
);
|
||||
@ -3158,7 +3158,7 @@ HAWK_EXPORT hawk_bch_t* hawk_rtx_getvalbcstrwithcmgr (
|
||||
|
||||
HAWK_EXPORT void hawk_rtx_freevalbcstr (
|
||||
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 */
|
||||
);
|
||||
|
||||
|
||||
@ -70,12 +70,17 @@ hawk_ooch_t* hawk_rtx_strxnfld (
|
||||
hawk_oocs_t* tok
|
||||
);
|
||||
|
||||
int hawk_rtx_matchval (
|
||||
int hawk_rtx_matchvalwithucs (
|
||||
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]
|
||||
const hawk_ucs_t* str, const hawk_ucs_t* substr,
|
||||
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 (
|
||||
hawk_rtx_t* rtx, hawk_tre_t* code,
|
||||
@ -90,8 +95,10 @@ int hawk_rtx_matchrexwithbcs (
|
||||
);
|
||||
|
||||
#if defined(HAWK_OOCH_IS_UCH)
|
||||
# define hawk_rtx_matchvalwithoocs hawk_rtx_matchvalwithucs
|
||||
# define hawk_rtx_matchrexwithoocs hawk_rtx_matchrexwithucs
|
||||
#else
|
||||
# define hawk_rtx_matchvalwithoocs hawk_rtx_matchvalwithbcs
|
||||
# define hawk_rtx_matchrexwithoocs hawk_rtx_matchrexwithbcs
|
||||
#endif
|
||||
|
||||
|
||||
@ -510,15 +510,17 @@ static int matchtre_bcs (hawk_tre_t* tre, int opt, const hawk_bcs_t* str, hawk_b
|
||||
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 opt = HAWK_TRE_BACKTRACKING; /* TODO: option... HAWK_TRE_BACKTRACKING ??? */
|
||||
hawk_tre_t* code;
|
||||
hawk_val_type_t v_type;
|
||||
|
||||
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];
|
||||
}
|
||||
@ -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 defined(HAWK_OOCH_IS_UCH)
|
||||
|
||||
x = matchtre_ucs(
|
||||
#else
|
||||
x = matchtre_bcs(
|
||||
#endif
|
||||
code, ((str->ptr == substr->ptr)? opt: (opt | HAWK_TRE_NOTBOL)),
|
||||
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 */
|
||||
}
|
||||
@ -557,6 +556,53 @@ int hawk_rtx_matchval (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_oocs_t* str,
|
||||
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 opt = HAWK_TRE_BACKTRACKING; /* TODO: option... HAWK_TRE_BACKTRACKING or others??? */
|
||||
|
||||
@ -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.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_ooecs_init(&rtx->subst.oout, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_10;
|
||||
if (hawk_becs_init(&rtx->fnc.bout, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_9;
|
||||
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);
|
||||
@ -1107,9 +1107,9 @@ oops_13:
|
||||
oops_12:
|
||||
hawk_htb_close (rtx->named);
|
||||
oops_11:
|
||||
hawk_becs_fini (&rtx->subst.oout);
|
||||
hawk_becs_fini (&rtx->fnc.oout);
|
||||
oops_10:
|
||||
hawk_becs_fini (&rtx->subst.bout);
|
||||
hawk_becs_fini (&rtx->fnc.bout);
|
||||
oops_9:
|
||||
hawk_becs_fini (&rtx->formatmbs.fmt);
|
||||
oops_8:
|
||||
@ -1196,8 +1196,8 @@ static void fini_rtx (hawk_rtx_t* rtx, int fini_globals)
|
||||
rtx->gbl.subsep.len = 0;
|
||||
}
|
||||
|
||||
hawk_ooecs_fini (&rtx->subst.oout);
|
||||
hawk_becs_fini (&rtx->subst.bout);
|
||||
hawk_ooecs_fini (&rtx->fnc.oout);
|
||||
hawk_becs_fini (&rtx->fnc.bout);
|
||||
|
||||
hawk_rtx_freemem (rtx, rtx->formatmbs.tmp.ptr);
|
||||
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
|
||||
}
|
||||
|
||||
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);
|
||||
if (free_vs) hawk_rtx_freevaloocstr (rtx, rtx->inrec.d0, vs.ptr);
|
||||
if (n <= -1)
|
||||
@ -5389,17 +5389,17 @@ static hawk_val_t* eval_binop_match0 (
|
||||
out.ptr = hawk_rtx_getvaloocstr (rtx, left, &out.len);
|
||||
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);
|
||||
|
||||
if (n <= -1)
|
||||
if (HAWK_UNLIKELY(n <= -1))
|
||||
{
|
||||
ADJERR_LOC (rtx, lloc);
|
||||
return HAWK_NULL;
|
||||
}
|
||||
|
||||
res = hawk_rtx_makeintval(rtx, (n == ret));
|
||||
if (res == HAWK_NULL)
|
||||
if (HAWK_UNLIKELY(!res))
|
||||
{
|
||||
ADJERR_LOC (rtx, lloc);
|
||||
return HAWK_NULL;
|
||||
|
||||
100
hawk/lib/val.c
100
hawk/lib/val.c
@ -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_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
int x;
|
||||
hawk_int_t l;
|
||||
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_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
int x;
|
||||
hawk_int_t l;
|
||||
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_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
int x;
|
||||
hawk_val_t* v;
|
||||
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_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
int x;
|
||||
hawk_val_t* v;
|
||||
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_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
int x;
|
||||
hawk_int_t l;
|
||||
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_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
int x;
|
||||
hawk_int_t l;
|
||||
hawk_flt_t r;
|
||||
@ -1594,54 +1588,110 @@ hawk_uch_t* hawk_rtx_valtoucstrdupwithcmgr (hawk_rtx_t* rtx, const hawk_val_t* v
|
||||
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))
|
||||
{
|
||||
case HAWK_VAL_STR:
|
||||
#if 0
|
||||
plain_str:
|
||||
#endif
|
||||
if (len) *len = ((hawk_val_str_t*)v)->val.len;
|
||||
return ((hawk_val_str_t*)v)->val.ptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
#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 ||
|
||||
str != ((hawk_val_str_t*)v)->val.ptr)
|
||||
switch (HAWK_RTX_GETVALTYPE(rtx, v))
|
||||
{
|
||||
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))
|
||||
{
|
||||
case HAWK_VAL_MBS:
|
||||
#if 0
|
||||
plain_mbs:
|
||||
#endif
|
||||
if (len) *len = ((hawk_val_mbs_t*)v)->val.len;
|
||||
return ((hawk_val_mbs_t*)v)->val.ptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
#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 ||
|
||||
str != ((hawk_val_mbs_t*)v)->val.ptr)
|
||||
switch (HAWK_RTX_GETVALTYPE(rtx, v))
|
||||
{
|
||||
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)
|
||||
{
|
||||
hawk_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
|
||||
switch (ref->id)
|
||||
{
|
||||
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)
|
||||
{
|
||||
hawk_val_type_t vtype = HAWK_RTX_GETVALTYPE(rtx, v);
|
||||
hawk_t* hawk = hawk_rtx_gethawk(rtx);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
case HAWK_VAL_REF_GBL:
|
||||
{
|
||||
hawk_oow_t idx;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user