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);

44
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},
@ -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;
@ -703,11 +704,37 @@ int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
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 */
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:
len = 1;
@ -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;
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);
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;

21
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;
@ -521,6 +539,7 @@ 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("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 } }
};

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) */