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

added hawk::cap(), hawk::size()

Browse Source
This commit is contained in:
hyung-hwan
2025-07-06 11:26:51 +09:00
parent 9a87e03b5e
commit 6be6ad9b9a
6 changed files with 304 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
lib/Hawk.cpp
View File

@ -850,13 +850,76 @@ int Hawk::Value::setMbs (Run* r, const hawk_bch_t* str)
return n;
}
int Hawk::Value::setArrayVal (hawk_ooi_t idx, hawk_val_t* v)
///////////////////////////////////////////////////////////////////
int Hawk::Value::scaleArrayed (hawk_ooi_t size)
{
if (HAWK_UNLIKELY(!this->run)) return -1;
return this->setArrayVal(this->run, idx, v);
return this->scaleArrayed(this->run, size);
}
int Hawk::Value::setArrayVal (Run* r, hawk_ooi_t idx, hawk_val_t* v)
int Hawk::Value::scaleArrayed (Run* r, hawk_ooi_t size)
{
HAWK_ASSERT (r != HAWK_NULL);
if (HAWK_RTX_GETVALTYPE(r->rtx, this->val) != HAWK_VAL_ARR)
{
// the previous value is not a arr.
// a new arr value needs to be created first.
hawk_val_t* arr = hawk_rtx_makearrval(r->rtx, size); // TODO: can we change this to accept the initial value in the constructor
if (arr == HAWK_NULL)
{
r->hawk->retrieveError (r);
return -1;
}
hawk_rtx_refupval(r->rtx, arr);
// free the previous value
if (this->run)
{
// if val is not nil, this->run can't be NULL
hawk_rtx_refdownval(this->run->rtx, this->val);
}
this->run = r;
this->val = arr;
}
else
{
HAWK_ASSERT (run != HAWK_NULL);
// if the previous value is a arr, things are a bit simpler
// however it needs to check if the runtime context matches
// with the previous one.
if (this->run != r)
{
// it can't span across multiple runtime contexts
this->run->setError(HAWK_EINVAL);
this->run->hawk->retrieveError (run);
return -1;
}
/* TODO: RESIZE THE EXISTING ARRAY...
// update the arr with a given value
if (hawk_rtx_setarrvalfld(r->rtx, val, idx, v) == HAWK_NULL)
{
r->hawk->retrieveError (r);
return -1;
}
*/
}
return 0;
}
int Hawk::Value::setArrayedVal (hawk_ooi_t idx, hawk_val_t* v)
{
if (HAWK_UNLIKELY(!this->run)) return -1;
return this->setArrayedVal(this->run, idx, v);
}
int Hawk::Value::setArrayedVal (Run* r, hawk_ooi_t idx, hawk_val_t* v)
{
HAWK_ASSERT (r != HAWK_NULL);
@ -917,6 +980,40 @@ int Hawk::Value::setArrayVal (Run* r, hawk_ooi_t idx, hawk_val_t* v)
return 0;
}
bool Hawk::Value::isArrayed () const
{
HAWK_ASSERT (val != HAWK_NULL);
return HAWK_RTX_GETVALTYPE(this->run->rtx, val) == HAWK_VAL_ARR;
}
int Hawk::Value::getArrayed (hawk_ooi_t idx, Value* v) const
{
HAWK_ASSERT (val != HAWK_NULL);
// not a map. v is just nil. not an error
if (HAWK_RTX_GETVALTYPE(this->run->rtx, val) != HAWK_VAL_ARR)
{
v->clear ();
return 0;
}
// get the value from the map.
hawk_val_t* fv = hawk_rtx_getarrvalfld(this->run->rtx, val, idx);
// the key is not found. it is not an error. v is just nil
if (fv == HAWK_NULL)
{
v->clear ();
return 0;
}
// if v.set fails, it should return an error
return v->setVal(this->run, fv);
}
///////////////////////////////////////////////////////////////////
int Hawk::Value::setIndexedVal (const Index& idx, hawk_val_t* v)
{
if (HAWK_UNLIKELY(!this->run)) return -1;

17
lib/Hawk.hpp
View File

@ -1076,8 +1076,17 @@ public:
int setMbs (const hawk_bch_t* str);
int setMbs (Run* r, const hawk_bch_t* str);
int setArrayVal (hawk_ooi_t idx, hawk_val_t* v);
int setArrayVal (Run* r, hawk_ooi_t idx, hawk_val_t* v);
int setArrayedVal (hawk_ooi_t idx, hawk_val_t* v);
int setArrayedVal (Run* r, hawk_ooi_t idx, hawk_val_t* v);
int scaleArrayed (hawk_ooi_t size);
int scaleArrayed (Run* r, hawk_ooi_t size);
bool isArrayed () const;
int getArrayed (
hawk_ooi_t idx, ///< array index
Value* val ///< value holder
) const;
int setIndexedVal (const Index& idx, hawk_val_t* v);
int setIndexedVal (Run* r, const Index& idx, hawk_val_t* v);
@ -1102,7 +1111,7 @@ public:
int setIndexedMbs (Run* r, const Index& idx, const hawk_bch_t* str);
///
/// The isIndexed() function determines if a value is arrayed.
/// The isIndexed() function determines if a value is a map.
/// \return true if indexed, false if not.
///
bool isIndexed () const;
@ -1113,7 +1122,7 @@ public:
/// \return 0 on success, -1 on failure
///
int getIndexed (
const Index& idx, ///< array index
const Index& idx, ///< map index
Value* val ///< value holder
) const;

2
lib/fnc-prv.h
View File

@ -58,7 +58,7 @@ hawk_fnc_t* hawk_findfncwithucs (hawk_t* hawk, const hawk_ucs_t* name);
/* EXPORT is required for linking on windows as they are referenced by mod-str.c */
HAWK_EXPORT int hawk_fnc_gsub (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
HAWK_EXPORT int hawk_fnc_index (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
HAWK_EXPORT int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
HAWK_EXPORT int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int mode);
HAWK_EXPORT int hawk_fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
HAWK_EXPORT int hawk_fnc_rindex (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
HAWK_EXPORT int hawk_fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);

290
lib/fnc.c
View File

@ -24,11 +24,12 @@
#include "hawk-prv.h"
static int fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_asorti (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_close (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_fflush (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_int (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_asorti (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
static int fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
#define A_MAX HAWK_TYPE_MAX(hawk_oow_t)
@ -61,7 +62,7 @@ static hawk_fnc_t sysfnctab[] =
/* string functions */
{ {HAWK_T("gsub"), 4}, 0, { {2, 3, HAWK_T("xvr")}, hawk_fnc_gsub, 0 }, HAWK_NULL},
{ {HAWK_T("index"), 5}, 0, { {2, 3, HAWK_NULL}, hawk_fnc_index, 0 }, HAWK_NULL},
{ {HAWK_T("length"), 6}, 1, { {0, 1, HAWK_NULL}, hawk_fnc_length, 0 }, HAWK_NULL},
{ {HAWK_T("length"), 6}, 1, { {0, 1, HAWK_NULL}, fnc_length, 0 }, HAWK_NULL},
{ {HAWK_T("match"), 5}, 0, { {2, 3, HAWK_T("vxr")}, fnc_match, 0 }, HAWK_NULL},
{ {HAWK_T("split"), 5}, 0, { {2, 3, HAWK_T("vrx")}, hawk_fnc_split, 0 }, HAWK_NULL},
{ {HAWK_T("sprintf"), 7}, 0, { {1, A_MAX, HAWK_NULL}, hawk_fnc_sprintf, 0 }, HAWK_NULL},
@ -345,7 +346,7 @@ static int fnc_close (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
nargs = hawk_rtx_getnargs(rtx);
HAWK_ASSERT (nargs == 1 || nargs == 2);
a0 = hawk_rtx_getarg (rtx, 0);
a0 = hawk_rtx_getarg(rtx, 0);
if (nargs >= 2) a1 = hawk_rtx_getarg(rtx, 1);
HAWK_ASSERT (a0 != HAWK_NULL);
@ -401,19 +402,19 @@ static int fnc_close (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
* flagged by the return value of close().
if (n <= -1 && rtx->errinf.num != HAWK_EIONMNF)
{
if (a0->type != HAWK_VAL_STR) hawk_rtx_freemem (rtx, name);
if (a0->type != HAWK_VAL_STR) hawk_rtx_freemem(rtx, name);
return -1;
}
*/
skip_close:
if (a1) hawk_rtx_freevaloocstr (rtx, a1, opt);
hawk_rtx_freevaloocstr (rtx, a0, name);
if (a1) hawk_rtx_freevaloocstr(rtx, a1, opt);
hawk_rtx_freevaloocstr(rtx, a0, name);
v = hawk_rtx_makeintval (rtx, (hawk_int_t)n);
v = hawk_rtx_makeintval(rtx, (hawk_int_t)n);
if (!v) return -1;
hawk_rtx_setretval (rtx, v);
hawk_rtx_setretval(rtx, v);
return 0;
}
@ -530,13 +531,13 @@ static int fnc_fflush (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
if (n != 0) n = -1;
skip_flush:
hawk_rtx_freevaloocstr (rtx, a0, str0);
hawk_rtx_freevaloocstr(rtx, a0, str0);
}
v = hawk_rtx_makeintval (rtx, (hawk_int_t)n);
v = hawk_rtx_makeintval(rtx, (hawk_int_t)n);
if (!v) return -1;
hawk_rtx_setretval (rtx, v);
hawk_rtx_setretval(rtx, v);
return 0;
}
@ -608,7 +609,7 @@ static int index_or_rindex (hawk_rtx_t* rtx, int rindex)
idx = (ptr? ((hawk_int_t)(ptr - str0) + 1): 0);
hawk_rtx_freevalbcstr (rtx, a1, str1);
hawk_rtx_freevalbcstr(rtx, a1, str1);
break;
}
@ -623,7 +624,7 @@ static int index_or_rindex (hawk_rtx_t* rtx, int rindex)
str1 = hawk_rtx_getvaloocstr(rtx, a1, &len1);
if (!str1)
{
hawk_rtx_freevaloocstr (rtx, a0, str0);
hawk_rtx_freevaloocstr(rtx, a0, str0);
return -1;
}
@ -654,8 +655,8 @@ static int index_or_rindex (hawk_rtx_t* rtx, int rindex)
idx = (ptr? ((hawk_int_t)(ptr - str0) + 1): 0);
hawk_rtx_freevaloocstr (rtx, a1, str1);
hawk_rtx_freevaloocstr (rtx, a0, str0);
hawk_rtx_freevaloocstr(rtx, a1, str1);
hawk_rtx_freevaloocstr(rtx, a0, str0);
}
break;
}
@ -663,7 +664,7 @@ static int index_or_rindex (hawk_rtx_t* rtx, int rindex)
a0 = hawk_rtx_makeintval(rtx, idx);
if (HAWK_UNLIKELY(!a0)) return -1;
hawk_rtx_setretval (rtx, a0);
hawk_rtx_setretval(rtx, a0);
return 0;
}
@ -677,7 +678,7 @@ int hawk_fnc_rindex (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
return index_or_rindex(rtx, 1);
}
int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int mode)
{
hawk_oow_t nargs;
hawk_val_t* v;
@ -696,17 +697,43 @@ int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
else
{
v = hawk_rtx_getarg(rtx, 0);
vtype = HAWK_RTX_GETVALTYPE (rtx, v);
vtype = HAWK_RTX_GETVALTYPE(rtx, v);
switch (vtype)
{
case HAWK_VAL_MAP:
/* map size */
len = HAWK_MAP_SIZE(((hawk_val_map_t*)v)->map);
switch (mode)
{
case 2: /* capacity */
len = hawk_map_getcapa(((hawk_val_map_t*)v)->map);
break;
case 1: /* size */
case 0: /* length */
default:
len = HAWK_MAP_SIZE(((hawk_val_map_t*)v)->map);
break;
}
break;
case HAWK_VAL_ARR: /* returns the number of set items instead of the last index + 1 */
len = HAWK_ARR_TALLY(((hawk_val_arr_t*)v)->arr);
switch (mode)
{
case 2: /* capacity */
len = HAWK_ARR_SIZE(((hawk_val_arr_t*)v)->arr);
break;
case 1: /* size */
len = HAWK_ARR_SIZE(((hawk_val_arr_t*)v)->arr);
break;
case 0: /* length */
default:
len = HAWK_ARR_TALLY(((hawk_val_arr_t*)v)->arr);
break;
}
break;
case HAWK_VAL_BCHR:
@ -729,18 +756,23 @@ int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
default:
/* convert to string and get length */
str = hawk_rtx_valtooocstrdup(rtx, v, &len);
if (!str) return -1;
hawk_rtx_freemem (rtx, str);
if (HAWK_UNLIKELY(!str)) return -1;
hawk_rtx_freemem(rtx, str);
}
}
v = hawk_rtx_makeintval(rtx, len);
if (!v) return -1;
if (HAWK_UNLIKELY(!v)) return -1;
hawk_rtx_setretval (rtx, v);
hawk_rtx_setretval(rtx, v);
return 0;
}
int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
return hawk_fnc_length(rtx, fi, 0);
}
int hawk_fnc_substr (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
hawk_oow_t nargs;
@ -784,7 +816,7 @@ int hawk_fnc_substr (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
if (lcount > (hawk_int_t)len - lindex) lcount = (hawk_int_t)len - lindex;
r = hawk_rtx_makembsvalwithbchars(rtx, &str[lindex], (hawk_oow_t)lcount);
hawk_rtx_freevalbcstr (rtx, a0, str);
hawk_rtx_freevalbcstr(rtx, a0, str);
if (HAWK_UNLIKELY(!r)) return -1;
break;
}
@ -801,13 +833,13 @@ int hawk_fnc_substr (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
if (lcount > (hawk_int_t)len - lindex) lcount = (hawk_int_t)len - lindex;
r = hawk_rtx_makestrvalwithoochars(rtx, &str[lindex], (hawk_oow_t)lcount);
hawk_rtx_freevaloocstr (rtx, a0, str);
hawk_rtx_freevaloocstr(rtx, a0, str);
if (HAWK_UNLIKELY(!r)) return -1;
break;
}
}
hawk_rtx_setretval (rtx, r);
hawk_rtx_setretval(rtx, r);
return 0;
}
@ -837,7 +869,7 @@ static int fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int use_array)
HAWK_ASSERT (nargs >= 2 && nargs <= 3);
a0 = hawk_rtx_getarg(rtx, 0);
a2 = (nargs >= 3)? hawk_rtx_getarg (rtx, 2): HAWK_NULL;
a2 = (nargs >= 3)? hawk_rtx_getarg(rtx, 2): HAWK_NULL;
str.ptr = HAWK_NULL;
str.len = 0;
@ -918,7 +950,7 @@ static int fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int use_array)
{
HAWK_ASSERT (fs_free = fs.ptr);
hawk_rtx_freevaloocstr (rtx, t0, fs_free);
hawk_rtx_freevaloocstr(rtx, t0, fs_free);
fs.ptr = (hawk_ooch_t*)hawk_rtx_getvalbcstr(rtx, t0, &fs.len);
if (HAWK_UNLIKELY(!fs.ptr)) goto oops;
@ -929,9 +961,9 @@ static int fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int use_array)
t1 = use_array? hawk_rtx_makearrval(rtx, 16): hawk_rtx_makemapval(rtx);
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*)hawk_rtx_getarg(rtx, 1), t1);
hawk_rtx_refdownval (rtx, t1);
hawk_rtx_refdownval(rtx, t1);
if (HAWK_UNLIKELY(x <= -1)) goto oops;
/* fill the map with actual values */
@ -968,7 +1000,7 @@ static int fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int use_array)
/* create the field string - however, the split function must
* create a numeric value if the string is a number */
/*t2 = hawk_rtx_makestrvalwithoocs (rtx, &tok);*/
/*t2 = hawk_rtx_makestrvalwithoocs(rtx, &tok);*/
/*t2 = hawk_rtx_makenstrvalwithoocs(rtx, &tok); */
t2 = byte_str? hawk_rtx_makenumormbsvalwithbchars(rtx, (hawk_bch_t*)tok.ptr, tok.len):
hawk_rtx_makenumorstrvalwithoochars(rtx, tok.ptr, tok.len);
@ -978,8 +1010,8 @@ static int fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int use_array)
{
if (!hawk_rtx_setarrvalfld(rtx, t1, ++nflds, t2))
{
hawk_rtx_refupval (rtx, t2);
hawk_rtx_refdownval (rtx, t2);
hawk_rtx_refupval(rtx, t2);
hawk_rtx_refdownval(rtx, t2);
goto oops;
}
}
@ -994,8 +1026,8 @@ static int fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int use_array)
if (!hawk_rtx_setmapvalfld(rtx, t1, key_buf, key_len, t2))
{
hawk_rtx_refupval (rtx, t2);
hawk_rtx_refdownval (rtx, t2);
hawk_rtx_refupval(rtx, t2);
hawk_rtx_refdownval(rtx, t2);
goto oops;
}
}
@ -1006,54 +1038,54 @@ static int fnc_split (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int use_array)
str.len = org_len - (p - str.ptr);
}
if (do_fld) { hawk_rtx_freemem (rtx, str.ptr); }
else if (byte_str) { hawk_rtx_freevalbcstr (rtx, a0, (hawk_bch_t*)str.ptr); }
else { hawk_rtx_freevaloocstr (rtx, a0, str.ptr); }
if (do_fld) { hawk_rtx_freemem(rtx, str.ptr); }
else if (byte_str) { hawk_rtx_freevalbcstr(rtx, a0, (hawk_bch_t*)str.ptr); }
else { hawk_rtx_freevaloocstr(rtx, a0, str.ptr); }
if (fs_free)
{
if (byte_str && switch_fs_to_bchr)
hawk_rtx_freevalbcstr (rtx, t0, (hawk_bch_t*)fs_free);
hawk_rtx_freevalbcstr(rtx, t0, (hawk_bch_t*)fs_free);
else
hawk_rtx_freevaloocstr (rtx, t0, fs_free);
hawk_rtx_freevaloocstr(rtx, t0, fs_free);
}
if (fs_rex_free)
{
if (rtx->gbl.ignorecase)
hawk_rtx_freerex (rtx, HAWK_NULL, fs_rex_free);
hawk_rtx_freerex(rtx, HAWK_NULL, fs_rex_free);
else
hawk_rtx_freerex (rtx, fs_rex_free, HAWK_NULL);
hawk_rtx_freerex(rtx, fs_rex_free, HAWK_NULL);
}
t1 = hawk_rtx_makeintval(rtx, nflds);
if (HAWK_UNLIKELY(!t1)) return -1;
hawk_rtx_setretval (rtx, t1);
hawk_rtx_setretval(rtx, t1);
return 0;
oops:
if (str.ptr)
{
if (do_fld) { hawk_rtx_freemem (rtx, str.ptr); }
else if (byte_str) { hawk_rtx_freevalbcstr (rtx, a0, (hawk_bch_t*)str.ptr); }
else { hawk_rtx_freevaloocstr (rtx, a0, str.ptr); }
if (do_fld) { hawk_rtx_freemem(rtx, str.ptr); }
else if (byte_str) { hawk_rtx_freevalbcstr(rtx, a0, (hawk_bch_t*)str.ptr); }
else { hawk_rtx_freevaloocstr(rtx, a0, str.ptr); }
}
if (fs_free)
{
if (byte_str && switch_fs_to_bchr)
hawk_rtx_freevalbcstr (rtx, t0, (hawk_bch_t*)fs_free);
hawk_rtx_freevalbcstr(rtx, t0, (hawk_bch_t*)fs_free);
else
hawk_rtx_freevaloocstr (rtx, t0, fs_free);
hawk_rtx_freevaloocstr(rtx, t0, fs_free);
}
if (fs_rex_free)
{
if (rtx->gbl.ignorecase)
hawk_rtx_freerex (rtx, HAWK_NULL, fs_rex_free);
hawk_rtx_freerex(rtx, HAWK_NULL, fs_rex_free);
else
hawk_rtx_freerex (rtx, fs_rex_free, HAWK_NULL);
hawk_rtx_freerex(rtx, fs_rex_free, HAWK_NULL);
}
return -1;
}
@ -1091,7 +1123,7 @@ int hawk_fnc_tolower (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
str.ptr = hawk_rtx_getvalbcstr(rtx, a0, &str.len);
if (!str.ptr) return -1;
r = hawk_rtx_makembsvalwithbcs(rtx, &str);
hawk_rtx_freevalbcstr (rtx, a0, str.ptr);
hawk_rtx_freevalbcstr(rtx, a0, str.ptr);
if (HAWK_UNLIKELY(!r)) return -1;
str.ptr = ((hawk_val_mbs_t*)r)->val.ptr;
str.len = ((hawk_val_mbs_t*)r)->val.len;
@ -1114,7 +1146,7 @@ int hawk_fnc_tolower (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
str.ptr = hawk_rtx_getvaloocstr(rtx, a0, &str.len);
if (!str.ptr) return -1;
r = hawk_rtx_makestrvalwithoocs(rtx, &str);
hawk_rtx_freevaloocstr (rtx, a0, str.ptr);
hawk_rtx_freevaloocstr(rtx, a0, str.ptr);
if (HAWK_UNLIKELY(!r)) return -1;
str.ptr = ((hawk_val_str_t*)r)->val.ptr;
str.len = ((hawk_val_str_t*)r)->val.len;
@ -1123,7 +1155,7 @@ int hawk_fnc_tolower (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
}
}
hawk_rtx_setretval (rtx, r);
hawk_rtx_setretval(rtx, r);
return 0;
}
@ -1150,7 +1182,7 @@ int hawk_fnc_toupper (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
str.ptr = hawk_rtx_getvalbcstr(rtx, a0, &str.len);
if (!str.ptr) return -1;
r = hawk_rtx_makembsvalwithbcs(rtx, &str);
hawk_rtx_freevalbcstr (rtx, a0, str.ptr);
hawk_rtx_freevalbcstr(rtx, a0, str.ptr);
if (HAWK_UNLIKELY(!r)) return -1;
str.ptr = ((hawk_val_mbs_t*)r)->val.ptr;
str.len = ((hawk_val_mbs_t*)r)->val.len;
@ -1173,7 +1205,7 @@ int hawk_fnc_toupper (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
str.ptr = hawk_rtx_getvaloocstr(rtx, a0, &str.len);
if (!str.ptr) return -1;
r = hawk_rtx_makestrvalwithoocs(rtx, &str);
hawk_rtx_freevaloocstr (rtx, a0, str.ptr);
hawk_rtx_freevaloocstr(rtx, a0, str.ptr);
if (HAWK_UNLIKELY(!r)) return -1;
str.ptr = ((hawk_val_str_t*)r)->val.ptr;
str.len = ((hawk_val_str_t*)r)->val.len;
@ -1182,7 +1214,7 @@ int hawk_fnc_toupper (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
}
}
hawk_rtx_setretval (rtx, r);
hawk_rtx_setretval(rtx, r);
return 0;
}
@ -1503,19 +1535,19 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
if (rex_free)
{
if (rtx->gbl.ignorecase)
hawk_rtx_freerex (rtx, HAWK_NULL, rex_free);
hawk_rtx_freerex(rtx, HAWK_NULL, rex_free);
else
hawk_rtx_freerex (rtx, rex_free, HAWK_NULL);
hawk_rtx_freerex(rtx, rex_free, HAWK_NULL);
rex_free = HAWK_NULL;
}
switch (s2_free)
{
case 1:
hawk_rtx_freevaloocstr (rtx, r2, s2.ptr);
hawk_rtx_freevaloocstr(rtx, r2, s2.ptr);
break;
case 2:
hawk_rtx_freevalbcstr (rtx, r2, s2.ptr);
hawk_rtx_freevalbcstr(rtx, r2, s2.ptr);
break;
}
s2.ptr = HAWK_NULL;
@ -1523,17 +1555,17 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
switch (s1_free)
{
case 1:
hawk_rtx_freevaloocstr (rtx, a1, s1.ptr);
hawk_rtx_freevaloocstr(rtx, a1, s1.ptr);
break;
case 2:
hawk_rtx_freevalbcstr (rtx, a1, s1.ptr);
hawk_rtx_freevalbcstr(rtx, a1, s1.ptr);
break;
}
s1.ptr = HAWK_NULL;
if (s0.ptr)
{
hawk_rtx_freevaloocstr (rtx, a0, s0.ptr);
hawk_rtx_freevaloocstr(rtx, a0, s0.ptr);
s0.ptr = HAWK_NULL;
}
@ -1551,9 +1583,9 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
hawk_rtx_makestrvalwithoocs(rtx, HAWK_OOECS_OOCS(&rtx->fnc.oout));
if (HAWK_UNLIKELY(!v)) goto oops;
hawk_rtx_refupval (rtx, v);
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);
hawk_rtx_refdownval(rtx, v);
}
if (HAWK_UNLIKELY(n <= -1)) goto oops;
}
@ -1561,16 +1593,16 @@ static int __substitute (hawk_rtx_t* rtx, hawk_oow_t max_count)
v = hawk_rtx_makeintval(rtx, sub_count);
if (HAWK_UNLIKELY(!v)) return -1;
hawk_rtx_setretval (rtx, v);
hawk_rtx_setretval(rtx, v);
return 0;
oops:
if (rex_free)
{
if (rtx->gbl.ignorecase)
hawk_rtx_freerex (rtx, HAWK_NULL, rex_free);
hawk_rtx_freerex(rtx, HAWK_NULL, rex_free);
else
hawk_rtx_freerex (rtx, rex_free, HAWK_NULL);
hawk_rtx_freerex(rtx, rex_free, HAWK_NULL);
}
if (s2.ptr)
@ -1578,10 +1610,10 @@ oops:
switch (s2_free)
{
case 1:
hawk_rtx_freevaloocstr (rtx, r2, s2.ptr);
hawk_rtx_freevaloocstr(rtx, r2, s2.ptr);
break;
case 2:
hawk_rtx_freevalbcstr (rtx, r2, s2.ptr);
hawk_rtx_freevalbcstr(rtx, r2, s2.ptr);
break;
}
}
@ -1591,15 +1623,15 @@ oops:
switch (s1_free)
{
case 1:
hawk_rtx_freevaloocstr (rtx, a1, s1.ptr);
hawk_rtx_freevaloocstr(rtx, a1, s1.ptr);
break;
case 2:
hawk_rtx_freevalbcstr (rtx, a1, s1.ptr);
hawk_rtx_freevalbcstr(rtx, a1, s1.ptr);
break;
}
}
if (s0.ptr) hawk_rtx_freevaloocstr (rtx, a0, s0.ptr);
if (s0.ptr) hawk_rtx_freevaloocstr(rtx, a0, s0.ptr);
return -1;
}
@ -1677,7 +1709,7 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
tmp.len = len0 - start + 1;
n = hawk_rtx_matchvalwithbcs(rtx, a1, &tmp, &tmp, &mat.b, (nargs >= support_start_index + 3? submat.b: HAWK_NULL));
hawk_rtx_freevalbcstr (rtx, a0, str0.b);
hawk_rtx_freevalbcstr(rtx, a0, str0.b);
if (n <= -1) return -1;
@ -1699,7 +1731,7 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
tmp.len = len0 - start + 1;
n = hawk_rtx_matchvalwithoocs(rtx, a1, &tmp, &tmp, &mat.o, (nargs >= support_start_index + 3? submat.o: HAWK_NULL));
hawk_rtx_freevaloocstr (rtx, a0, str0.o);
hawk_rtx_freevaloocstr(rtx, a0, str0.o);
if (n <= -1) return -1;
@ -1709,13 +1741,13 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
x0 = hawk_rtx_makeintval(rtx, idx);
if (!x0) goto oops;
hawk_rtx_refupval (rtx, x0);
hawk_rtx_refupval(rtx, x0);
/* RLENGTH: -1 on no match */
HAWK_ASSERT (&mat.o.len == &mat.b.len);
x1 = hawk_rtx_makeintval(rtx, ((n == 0)? (hawk_int_t)-1: (hawk_int_t)mat.o.len)); /* just use mat.o.len regardless of a0_type */
if (!x1) goto oops;
hawk_rtx_refupval (rtx, x1);
hawk_rtx_refupval(rtx, x1);
if (nargs >= (3 + support_start_index))
{
@ -1729,7 +1761,7 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
x2 = hawk_rtx_makemapval(rtx);
if (HAWK_UNLIKELY(!x2)) goto oops;
hawk_rtx_refupval (rtx, x2);
hawk_rtx_refupval(rtx, x2);
/* add the full match value to the array at index "0" */
if (hawk_ooecs_fmt(&rtx->fnc.oout, HAWK_T("%d"), 0) == (hawk_oow_t)-1) goto oops;
@ -1739,8 +1771,8 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
if (HAWK_UNLIKELY(!tv)) goto oops;
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);
hawk_rtx_refupval(rtx, tv);
hawk_rtx_refdownval(rtx, tv);
goto oops;
}
@ -1753,8 +1785,8 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
if (HAWK_UNLIKELY(!tv)) goto oops;
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);
hawk_rtx_refupval(rtx, tv);
hawk_rtx_refdownval(rtx, tv);
goto oops;
}
@ -1766,8 +1798,8 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
if (HAWK_UNLIKELY(!tv)) goto oops;
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);
hawk_rtx_refupval(rtx, tv);
hawk_rtx_refdownval(rtx, tv);
goto oops;
}
@ -1787,8 +1819,8 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
if (HAWK_UNLIKELY(!tv)) goto oops;
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);
hawk_rtx_refupval(rtx, tv);
hawk_rtx_refdownval(rtx, tv);
goto oops;
}
@ -1800,8 +1832,8 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
if (HAWK_UNLIKELY(!tv)) goto oops;
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);
hawk_rtx_refupval(rtx, tv);
hawk_rtx_refdownval(rtx, tv);
goto oops;
}
@ -1812,8 +1844,8 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
if (HAWK_UNLIKELY(!tv)) goto oops;
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);
hawk_rtx_refupval(rtx, tv);
hawk_rtx_refdownval(rtx, tv);
goto oops;
}
}
@ -1829,17 +1861,17 @@ static int __fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int support_
goto oops;
}
hawk_rtx_setretval (rtx, x0);
hawk_rtx_setretval(rtx, x0);
if (x2) hawk_rtx_refdownval (rtx, x2);
hawk_rtx_refdownval (rtx, x1);
hawk_rtx_refdownval (rtx, x0);
if (x2) hawk_rtx_refdownval(rtx, x2);
hawk_rtx_refdownval(rtx, x1);
hawk_rtx_refdownval(rtx, x0);
return 0;
oops:
if (x2) hawk_rtx_refdownval (rtx, x2);
if (x1) hawk_rtx_refdownval (rtx, x1);
if (x0) hawk_rtx_refdownval (rtx, x0);
if (x2) hawk_rtx_refdownval(rtx, x2);
if (x1) hawk_rtx_refdownval(rtx, x1);
if (x0) hawk_rtx_refdownval(rtx, x0);
return -1;
}
@ -1897,14 +1929,14 @@ int hawk_fnc_sprintf (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
if (HAWK_UNLIKELY(!cs0.ptr)) goto oops_mbs;
x.ptr = hawk_rtx_formatmbs(rtx, &rtx->fnc.bout, &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 (HAWK_UNLIKELY(!x.ptr)) goto oops_mbs;
a0 = hawk_rtx_makembsvalwithbcs(rtx, &x);
if (HAWK_UNLIKELY(!a0)) goto oops_mbs;
hawk_becs_fini (&fbu);
hawk_rtx_setretval (rtx, a0);
hawk_rtx_setretval(rtx, a0);
return 0;
oops_mbs:
@ -1926,14 +1958,14 @@ int hawk_fnc_sprintf (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
if (HAWK_UNLIKELY(!cs0.ptr)) goto oops;
x.ptr = hawk_rtx_format(rtx, &rtx->fnc.oout, &fbu, cs0.ptr, cs0.len, nargs, HAWK_NULL, &x.len);
hawk_rtx_freevaloocstr (rtx, a0, cs0.ptr);
hawk_rtx_freevaloocstr(rtx, a0, cs0.ptr);
if (HAWK_UNLIKELY(!x.ptr)) goto oops;
a0 = hawk_rtx_makestrvalwithoocs(rtx, &x);
if (HAWK_UNLIKELY(!a0)) goto oops;
hawk_ooecs_fini (&fbu);
hawk_rtx_setretval (rtx, a0);
hawk_rtx_setretval(rtx, a0);
return 0;
oops:
@ -1958,7 +1990,7 @@ static int fnc_int (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
r = hawk_rtx_makeintval(rtx, lv);
if (!r) return -1;
hawk_rtx_setretval (rtx, r);
hawk_rtx_setretval(rtx, r);
return 0;
}
@ -2029,14 +2061,14 @@ static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi,
if (HAWK_UNLIKELY(!fun))
{
if (hawk_rtx_geterrnum(rtx) == HAWK_EINVAL)
hawk_rtx_seterrfmt (rtx, HAWK_NULL, HAWK_EINVAL, HAWK_T("comparator not a function"));
hawk_rtx_seterrfmt(rtx, HAWK_NULL, HAWK_EINVAL, HAWK_T("comparator not a function"));
return -1;
}
if (fun->nargs < 2)
{
/* the comparison accepts less than 2 arguments */
hawk_rtx_seterrfmt (rtx, HAWK_NULL, HAWK_EINVAL, HAWK_T("%.*js not accepting 2 arguments"), fun->name.len, fun->name.ptr);
hawk_rtx_seterrfmt(rtx, HAWK_NULL, HAWK_EINVAL, HAWK_T("%.*js not accepting 2 arguments"), fun->name.len, fun->name.ptr);
return -1;
}
}
@ -2054,7 +2086,7 @@ static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi,
goto val_arr;
default:
hawk_rtx_seterrnum (rtx, HAWK_NULL, HAWK_ENOTIDXACC);
hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_ENOTIDXACC);
return -1;
}
@ -2087,12 +2119,12 @@ val_map:
while (i > 0)
{
--i;
hawk_rtx_refdownval (rtx, va[i]);
hawk_rtx_refdownval(rtx, va[i]);
}
hawk_rtx_freemem (rtx, va);
hawk_rtx_freemem(rtx, va);
return -1;
}
hawk_rtx_refupval (rtx, va[i]);
hawk_rtx_refupval(rtx, va[i]);
i++;
}
while (hawk_rtx_getnextmapvalitr(rtx, a0_val, &itr));
@ -2102,7 +2134,7 @@ val_map:
do
{
va[i] = (hawk_val_t*)HAWK_VAL_MAP_ITR_VAL(&itr);
hawk_rtx_refupval (rtx, va[i]);
hawk_rtx_refupval(rtx, va[i]);
i++;
}
while (hawk_rtx_getnextmapvalitr(rtx, a0_val, &itr));
@ -2122,8 +2154,8 @@ val_map:
if (x <= -1 || !(rrv = hawk_rtx_makemapval(rtx)))
{
for (i = 0; i < msz; i++) hawk_rtx_refdownval (rtx, va[i]);
hawk_rtx_freemem (rtx, va);
for (i = 0; i < msz; i++) hawk_rtx_refdownval(rtx, va[i]);
hawk_rtx_freemem(rtx, va);
return -1;
}
@ -2147,20 +2179,20 @@ val_map:
/* decrement the reference count of the values not added to the map */
do
{
hawk_rtx_refdownval (rtx, va[i]);
hawk_rtx_refdownval(rtx, va[i]);
i++;
}
while (i < msz);
hawk_rtx_freeval (rtx, rrv, 0); /* this derefs the elements added. */
hawk_rtx_freemem (rtx, va);
hawk_rtx_freeval(rtx, rrv, 0); /* this derefs the elements added. */
hawk_rtx_freemem(rtx, va);
return -1;
}
hawk_rtx_refdownval (rtx, va[i]); /* deref it as it has been added to the map */
hawk_rtx_refdownval(rtx, va[i]); /* deref it as it has been added to the map */
}
rv = msz;
hawk_rtx_freemem (rtx, va);
hawk_rtx_freemem(rtx, va);
goto done;
}
@ -2189,7 +2221,7 @@ val_arr:
if (HAWK_ARR_SLOT(arr, j))
{
va[i] = sort_keys? hawk_rtx_makeintval(rtx, j): HAWK_ARR_DPTR(arr, j);
hawk_rtx_refupval (rtx, va[i]);
hawk_rtx_refupval(rtx, va[i]);
i++;
}
}
@ -2208,8 +2240,8 @@ val_arr:
if (x <= -1 || !(rrv = hawk_rtx_makearrval(rtx, -1)))
{
for (i = 0; i < msz; i++) hawk_rtx_refdownval (rtx, va[i]);
hawk_rtx_freemem (rtx, va);
for (i = 0; i < msz; i++) hawk_rtx_refdownval(rtx, va[i]);
hawk_rtx_freemem(rtx, va);
return -1;
}
@ -2220,20 +2252,20 @@ val_arr:
/* decrement the reference count of the values not added to the map */
do
{
hawk_rtx_refdownval (rtx, va[i]);
hawk_rtx_refdownval(rtx, va[i]);
i++;
}
while (i < msz);
hawk_rtx_freeval (rtx, rrv, 0); /* this derefs the elements added. */
hawk_rtx_freemem (rtx, va);
hawk_rtx_freeval(rtx, rrv, 0); /* this derefs the elements added. */
hawk_rtx_freemem(rtx, va);
return -1;
}
hawk_rtx_refdownval (rtx, va[i]); /* deref it as it has been added to the map */
hawk_rtx_refdownval(rtx, va[i]); /* deref it as it has been added to the map */
}
rv = msz;
hawk_rtx_freemem (rtx, va);
hawk_rtx_freemem(rtx, va);
goto done;
}
@ -2246,17 +2278,17 @@ done:
int x;
/* rrv can be NULL when a jump has been made for an empty source
* at the beginning of this fucntion */
hawk_rtx_refupval (rtx, rrv);
hawk_rtx_refupval(rtx, rrv);
x = hawk_rtx_setrefval(rtx, (hawk_val_ref_t*)hawk_rtx_getarg(rtx, (nargs >= 2)), rrv);
hawk_rtx_refdownval (rtx, rrv);
hawk_rtx_refdownval(rtx, rrv);
if (x <= -1)
{
hawk_rtx_freeval (rtx, r, 0);
hawk_rtx_freeval(rtx, r, 0);
return -1;
}
}
hawk_rtx_setretval (rtx, r);
hawk_rtx_setretval(rtx, r);
return 0;
}

25
lib/mod-hawk.c
View File

@ -339,6 +339,24 @@ static int fnc_gcrefs (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
/* -------------------------------------------------------------------------- */
static int fnc_cap (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
/* capacity */
return hawk_fnc_length (rtx, fi, 2);
}
static int fnc_size (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
/* similar to length, but it returns the ubound + 1 for the array */
return hawk_fnc_length (rtx, fi, 1);
}
static int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
return hawk_fnc_length (rtx, fi, 0);
}
/* -------------------------------------------------------------------------- */
static int fnc_array (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
hawk_val_t* tmp;
@ -519,8 +537,9 @@ static int fnc_hash (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
static hawk_mod_fnc_tab_t fnctab[] =
{
/* keep this table sorted for binary search in query(). */
{ HAWK_T("array"), { { 0, A_MAX, HAWK_NULL }, fnc_array, 0 } },
{ HAWK_T("array"), { { 0, A_MAX, HAWK_NULL }, fnc_array, 0 } },
{ HAWK_T("call"), { { 1, A_MAX, HAWK_T("vR") }, fnc_call, 0 } },
{ HAWK_T("cap"), { { 1, 1, HAWK_NULL }, fnc_cap, 0 } },
{ HAWK_T("cmgr_exists"), { { 1, 1, HAWK_NULL }, fnc_cmgr_exists, 0 } },
{ HAWK_T("function_exists"), { { 1, 1, HAWK_NULL }, fnc_function_exists, 0 } },
{ HAWK_T("gc"), { { 0, 1, HAWK_NULL }, fnc_gc, 0 } },
@ -532,8 +551,10 @@ static hawk_mod_fnc_tab_t fnctab[] =
{ HAWK_T("isarray"), { { 1, 1, HAWK_NULL }, fnc_isarr, 0 } },
{ HAWK_T("ismap"), { { 1, 1, HAWK_NULL }, fnc_ismap, 0 } },
{ HAWK_T("isnil"), { { 1, 1, HAWK_NULL }, fnc_isnil, 0 } },
{ HAWK_T("length"), { { 1, 1, HAWK_NULL }, fnc_length, 0 } },
{ HAWK_T("map"), { { 0, A_MAX, HAWK_NULL }, fnc_map, 0 } },
{ HAWK_T("modlibdirs"), { { 0, 0, HAWK_NULL }, fnc_modlibdirs, 0 } },
{ HAWK_T("size"), { { 1, 1, HAWK_NULL }, fnc_size, 0 } },
{ HAWK_T("type"), { { 1, 1, HAWK_NULL }, fnc_type, 0 } },
{ HAWK_T("typename"), { { 1, 1, HAWK_NULL }, fnc_typename, 0 } }
};
@ -543,7 +564,7 @@ static hawk_mod_int_tab_t inttab[] =
/* keep this table sorted for binary search in query(). */
{ HAWK_T("GC_NUM_GENS"), { HAWK_GC_NUM_GENS } },
/* synchronize this table with enum hawk_val_type_t in hawk.h */
/* synchronize this table with enum hawk_val_type_t in hawk.h */
/* the names follow the val_type_name table in val.c */
{ HAWK_T("VAL_ARRAY"), { HAWK_VAL_ARR } },
{ HAWK_T("VAL_BCHAR"), { HAWK_VAL_BCHR } },

7
lib/mod-str.c
View File

@ -25,6 +25,11 @@
#include "mod-str.h"
#include "hawk-prv.h"
static int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
return hawk_fnc_length(rtx, fi, 0);
}
static int fnc_normspace (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
{
/* normalize spaces
@ -763,7 +768,7 @@ static hawk_mod_fnc_tab_t fnctab[] =
{ HAWK_T("isspace"), { { 1, 1, HAWK_NULL }, fnc_isspace, 0 } },
{ HAWK_T("isupper"), { { 1, 1, HAWK_NULL }, fnc_isupper, 0 } },
{ HAWK_T("isxdigit"), { { 1, 1, HAWK_NULL }, fnc_isxdigit, 0 } },
{ HAWK_T("length"), { { 1, 1, HAWK_NULL }, hawk_fnc_length, 0 } },
{ HAWK_T("length"), { { 1, 1, HAWK_NULL }, fnc_length, 0 } },
{ HAWK_T("ltrim"), { { 1, 1, HAWK_NULL }, fnc_ltrim, 0 } },
{ HAWK_T("match"), { { 2, 4, HAWK_T("vxvr") }, hawk_fnc_match, 0 } },
{ HAWK_T("normspace"), { { 1, 1, HAWK_NULL }, fnc_normspace, 0 } }, /* deprecated, use trim("xxx", str::TRIM_PAC_SPACES) */