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

changed arr to use gem instead of hawk

Browse Source
This commit is contained in:
hyung-hwan 2019-12-16 15:09:58 +00:00
parent 58d06e55b3
commit e21d307a8c
11 changed files with 124 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
hawk/lib/Hawk.cpp
View File

@ -28,7 +28,7 @@
#include "hawk-prv.h"
/////////////////////////////////
HAWK_BEGIN_NAMESPACE(QSE)
HAWK_BEGIN_NAMESPACE(HAWK)
/////////////////////////////////
//////////////////////////////////////////////////////////////////
@ -1702,7 +1702,7 @@ int Hawk::dispatch_function (Run* run, const fnc_info_t* fi)
// call the default constructor on the space allocated above.
// no exception handling is implemented here as i know
// that Value::Value() doesn't throw an exception
new((QSE::Mmgr*)HAWK_NULL, (void*)&args[i]) Value ();
new((HAWK::Mmgr*)HAWK_NULL, (void*)&args[i]) Value ();
}
#endif
}
@ -2449,5 +2449,5 @@ void* Hawk::modsym (awk_t* awk, void* handle, const char_t* name)
return xtn->awk->modsym (handle, name);
}
/////////////////////////////////
HAWK_END_NAMESPACE(QSE)
HAWK_END_NAMESPACE(HAWK)
/////////////////////////////////

4
hawk/lib/Hawk.hpp
View File

@ -44,7 +44,7 @@
/// AWK Interpreter
/////////////////////////////////
HAWK_BEGIN_NAMESPACE(QSE)
HAWK_BEGIN_NAMESPACE(HAWK)
/////////////////////////////////
///
@ -1424,7 +1424,7 @@ private:
};
/////////////////////////////////
HAWK_END_NAMESPACE(QSE)
HAWK_END_NAMESPACE(HAWK)
/////////////////////////////////
#endif

4
hawk/lib/StdHawk.cpp
View File

@ -47,7 +47,7 @@
/////////////////////////////////
HAWK_BEGIN_NAMESPACE(QSE)
HAWK_BEGIN_NAMESPACE(HAWK)
/////////////////////////////////
StdHawk::ioattr_t StdHawk::default_ioattr;
@ -1371,6 +1371,6 @@ StdHawk::ssize_t StdHawk::SourceString::write (Data& io, const char_t* buf, size
}
/////////////////////////////////
HAWK_END_NAMESPACE(QSE)
HAWK_END_NAMESPACE(HAWK)
/////////////////////////////////

4
hawk/lib/StdHawk.hpp
View File

@ -34,7 +34,7 @@
/// Standard AWK Interpreter
/////////////////////////////////
HAWK_BEGIN_NAMESPACE(QSE)
HAWK_BEGIN_NAMESPACE(HAWK)
////////////////////////////////
///
@ -219,7 +219,7 @@ private:
};
/////////////////////////////////
HAWK_END_NAMESPACE(QSE)
HAWK_END_NAMESPACE(HAWK)
/////////////////////////////////
#endif

115
hawk/lib/arr.c
View File

@ -70,13 +70,13 @@ static HAWK_INLINE slot_t* alloc_slot (hawk_arr_t* arr, void* dptr, hawk_oow_t d
if (arr->copier == HAWK_ARR_COPIER_SIMPLE)
{
n = (slot_t*)hawk_allocmem(arr->hawk, HAWK_SIZEOF(slot_t));
n = (slot_t*)hawk_gem_allocmem(arr->gem, HAWK_SIZEOF(slot_t));
if (!n) return HAWK_NULL;
DPTR(n) = dptr;
}
else if (arr->copier == HAWK_ARR_COPIER_INLINE)
{
n = (slot_t*)hawk_allocmem(arr->hawk, HAWK_SIZEOF(slot_t) + TOB(arr,dlen));
n = (slot_t*)hawk_gem_allocmem(arr->gem, HAWK_SIZEOF(slot_t) + TOB(arr,dlen));
if (!n) return HAWK_NULL;
HAWK_MEMCPY (n + 1, dptr, TOB(arr,dlen));
@ -84,12 +84,12 @@ static HAWK_INLINE slot_t* alloc_slot (hawk_arr_t* arr, void* dptr, hawk_oow_t d
}
else
{
n = (slot_t*)hawk_allocmem(arr->hawk, HAWK_SIZEOF(slot_t));
n = (slot_t*)hawk_gem_allocmem(arr->gem, HAWK_SIZEOF(slot_t));
if (!n) return HAWK_NULL;
DPTR(n) = arr->copier (arr, dptr, dlen);
DPTR(n) = arr->copier(arr, dptr, dlen);
if (DPTR(n) == HAWK_NULL)
{
hawk_freemem (arr->hawk, n);
hawk_gem_freemem (arr->gem, n);
return HAWK_NULL;
}
}
@ -99,16 +99,16 @@ static HAWK_INLINE slot_t* alloc_slot (hawk_arr_t* arr, void* dptr, hawk_oow_t d
return n;
}
hawk_arr_t* hawk_arr_open (hawk_t* awk, hawk_oow_t xtnsize, hawk_oow_t capa)
hawk_arr_t* hawk_arr_open (hawk_gem_t* gem, hawk_oow_t xtnsize, hawk_oow_t capa)
{
hawk_arr_t* arr;
arr = (hawk_arr_t*)hawk_allocmem(awk, HAWK_SIZEOF(hawk_arr_t) + xtnsize);
arr = (hawk_arr_t*)hawk_gem_allocmem(gem, HAWK_SIZEOF(hawk_arr_t) + xtnsize);
if (arr == HAWK_NULL) return HAWK_NULL;
if (hawk_arr_init(arr, awk, capa) <= -1)
if (hawk_arr_init(arr, gem, capa) <= -1)
{
hawk_freemem (awk, arr);
hawk_gem_freemem (gem, arr);
return HAWK_NULL;
}
@ -119,14 +119,14 @@ hawk_arr_t* hawk_arr_open (hawk_t* awk, hawk_oow_t xtnsize, hawk_oow_t capa)
void hawk_arr_close (hawk_arr_t* arr)
{
hawk_arr_fini (arr);
hawk_freemem (arr->hawk, arr);
hawk_gem_freemem (arr->gem, arr);
}
int hawk_arr_init (hawk_arr_t* arr, hawk_t* awk, hawk_oow_t capa)
int hawk_arr_init (hawk_arr_t* arr, hawk_gem_t* gem, hawk_oow_t capa)
{
HAWK_MEMSET (arr, 0, HAWK_SIZEOF(*arr));
arr->hawk = awk;
arr->gem = gem;
arr->size = 0;
arr->capa = 0;
arr->slot = HAWK_NULL;
@ -145,7 +145,7 @@ void hawk_arr_fini (hawk_arr_t* arr)
if (arr->slot)
{
hawk_freemem (arr->hawk, arr->slot);
hawk_gem_freemem (arr->gem, arr->slot);
arr->slot = HAWK_NULL;
arr->capa = 0;
}
@ -160,7 +160,7 @@ void hawk_arr_setscale (hawk_arr_t* arr, int scale)
{
/* The scale should be larger than 0 and less than or equal to the
* maximum value that the hawk_uint8_t type can hold */
HAWK_ASSERT (arr->hawk, scale > 0 && scale <= HAWK_TYPE_MAX(hawk_uint8_t));
/*HAWK_ASSERT (arr->gem, scale > 0 && scale <= HAWK_TYPE_MAX(hawk_uint8_t));*/
if (scale <= 0) scale = 1;
if (scale > HAWK_TYPE_MAX(hawk_uint8_t)) scale = HAWK_TYPE_MAX(hawk_uint8_t);
@ -240,12 +240,12 @@ hawk_arr_t* hawk_arr_setcapa (hawk_arr_t* arr, hawk_oow_t capa)
{
/* to trigger freeers on the items truncated */
hawk_arr_delete (arr, capa, arr->size - capa);
HAWK_ASSERT (arr->hawk, arr->size <= capa);
/*HAWK_ASSERT (arr->gem, arr->size <= capa);*/
}
if (capa > 0)
{
tmp = (slot_t**)hawk_reallocmem(arr->hawk, arr->slot, HAWK_SIZEOF(*arr->slot) * capa);
tmp = (slot_t**)hawk_gem_reallocmem(arr->gem, arr->slot, HAWK_SIZEOF(*arr->slot) * capa);
if (!tmp) return HAWK_NULL;
}
else
@ -253,7 +253,7 @@ hawk_arr_t* hawk_arr_setcapa (hawk_arr_t* arr, hawk_oow_t capa)
if (arr->slot)
{
hawk_arr_clear (arr);
hawk_freemem (arr->hawk, arr->slot);
hawk_gem_freemem (arr->gem, arr->slot);
}
tmp = HAWK_NULL;
@ -272,12 +272,10 @@ hawk_oow_t hawk_arr_search (hawk_arr_t* arr, hawk_oow_t pos, const void* dptr, h
for (i = pos; i < arr->size; i++)
{
if (arr->slot[i] == HAWK_NULL) continue;
if (arr->comper (arr,
DPTR(arr->slot[i]), DLEN(arr->slot[i]),
dptr, dlen) == 0) return i;
if (arr->comper(arr, DPTR(arr->slot[i]), DLEN(arr->slot[i]), dptr, dlen) == 0) return i;
}
hawk_gem_seterrnum (arr->gem, HAWK_NULL, HAWK_ENOENT);
return HAWK_ARR_NIL;
}
@ -292,20 +290,18 @@ hawk_oow_t hawk_arr_rsearch (hawk_arr_t* arr, hawk_oow_t pos, const void* dptr,
for (i = pos + 1; i-- > 0; )
{
if (arr->slot[i] == HAWK_NULL) continue;
if (arr->comper (arr,
DPTR(arr->slot[i]), DLEN(arr->slot[i]),
dptr, dlen) == 0) return i;
if (arr->comper (arr, DPTR(arr->slot[i]), DLEN(arr->slot[i]), dptr, dlen) == 0) return i;
}
}
hawk_gem_seterrnum (arr->gem, HAWK_NULL, HAWK_ENOENT);
return HAWK_ARR_NIL;
}
hawk_oow_t hawk_arr_upsert (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oow_t dlen)
{
if (pos < arr->size) return hawk_arr_update (arr, pos, dptr, dlen);
return hawk_arr_insert (arr, pos, dptr, dlen);
return hawk_arr_insert(arr, pos, dptr, dlen);
}
hawk_oow_t hawk_arr_insert (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oow_t dlen)
@ -329,44 +325,46 @@ hawk_oow_t hawk_arr_insert (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oo
if (arr->sizer)
{
capa = arr->sizer (arr, mincapa);
capa = arr->sizer(arr, mincapa);
}
else
{
if (arr->capa <= 0)
{
HAWK_ASSERT (arr->hawk, arr->size <= 0);
capa = (pos < 16)? 16: (pos + 1);
/*HAWK_ASSERT (arr->gem, arr->size <= 0);*/
capa = HAWK_ALIGN_POW2(pos + 1, 64);
}
else
{
hawk_oow_t bound = (pos >= arr->size)? pos: arr->size;
capa = HAWK_ALIGN_POW2(bound + 1, 64);
do { capa = arr->capa * 2; } while (capa <= bound);
}
}
do
{
if (hawk_arr_setcapa(arr,capa) != HAWK_NULL) break;
if (hawk_arr_setcapa(arr, capa) != HAWK_NULL) break;
if (capa <= mincapa)
{
if (arr->freeer) arr->freeer (arr, DPTR(slot), DLEN(slot));
hawk_freemem (arr->hawk, slot);
hawk_gem_freemem (arr->gem, slot);
return HAWK_ARR_NIL;
}
capa--; /* let it retry after lowering the capacity */
}
while (1);
}
if (pos >= arr->capa || arr->size >= arr->capa)
{
/* the buffer is not still enough after resizing */
if (arr->freeer) arr->freeer (arr, DPTR(slot), DLEN(slot));
hawk_freemem (arr->hawk, slot);
return HAWK_ARR_NIL;
if (pos >= arr->capa || arr->size >= arr->capa) /* can happen if the sizer() callback isn't good enough */
{
/* the buffer is not still enough after resizing */
if (arr->freeer) arr->freeer (arr, DPTR(slot), DLEN(slot));
hawk_gem_freemem (arr->gem, slot);
hawk_gem_seterrnum (arr->gem, HAWK_NULL, HAWK_EBUFFULL);
return HAWK_ARR_NIL;
}
}
/* fill in the gap with HAWK_NULL */
@ -388,13 +386,17 @@ hawk_oow_t hawk_arr_update (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oo
{
slot_t* c;
if (pos >= arr->size) return HAWK_ARR_NIL;
if (pos >= arr->size)
{
hawk_gem_seterrnum (arr->gem, HAWK_NULL, HAWK_EINVAL);
return HAWK_ARR_NIL;
}
c = arr->slot[pos];
if (c == HAWK_NULL)
{
/* no previous data */
arr->slot[pos] = alloc_slot (arr, dptr, dlen);
arr->slot[pos] = alloc_slot(arr, dptr, dlen);
if (arr->slot[pos] == HAWK_NULL) return HAWK_ARR_NIL;
}
else
@ -407,11 +409,11 @@ hawk_oow_t hawk_arr_update (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oo
else
{
/* updated to different data */
slot_t* slot = alloc_slot (arr, dptr, dlen);
slot_t* slot = alloc_slot(arr, dptr, dlen);
if (slot == HAWK_NULL) return HAWK_ARR_NIL;
if (arr->freeer) arr->freeer (arr, DPTR(c), DLEN(c));
hawk_freemem (arr->hawk, c);
hawk_gem_freemem (arr->gem, c);
arr->slot[pos] = slot;
}
@ -436,8 +438,7 @@ hawk_oow_t hawk_arr_delete (hawk_arr_t* arr, hawk_oow_t index, hawk_oow_t count)
if (c != HAWK_NULL)
{
if (arr->freeer) arr->freeer (arr, DPTR(c), DLEN(c));
hawk_freemem (arr->hawk, c);
hawk_gem_freemem (arr->gem, c);
arr->slot[i] = HAWK_NULL;
}
}
@ -468,8 +469,7 @@ hawk_oow_t hawk_arr_uplete (hawk_arr_t* arr, hawk_oow_t index, hawk_oow_t count)
if (c != HAWK_NULL)
{
if (arr->freeer) arr->freeer (arr, DPTR(c), DLEN(c));
hawk_freemem (arr->hawk, c);
hawk_gem_freemem (arr->gem, c);
arr->slot[i] = HAWK_NULL;
}
}
@ -486,9 +486,8 @@ void hawk_arr_clear (hawk_arr_t* arr)
slot_t* c = arr->slot[i];
if (c != HAWK_NULL)
{
if (arr->freeer)
arr->freeer (arr, DPTR(c), DLEN(c));
hawk_freemem (arr->hawk, c);
if (arr->freeer) arr->freeer (arr, DPTR(c), DLEN(c));
hawk_gem_freemem (arr->gem, c);
arr->slot[i] = HAWK_NULL;
}
}
@ -568,7 +567,7 @@ hawk_oow_t hawk_arr_pushstack (hawk_arr_t* arr, void* dptr, hawk_oow_t dlen)
void hawk_arr_popstack (hawk_arr_t* arr)
{
HAWK_ASSERT (arr->hawk, arr->size > 0);
/*HAWK_ASSERT (arr->gem, arr->size > 0);*/
hawk_arr_delete (arr, arr->size - 1, 1);
}
@ -679,10 +678,10 @@ hawk_oow_t hawk_arr_pushheap (hawk_arr_t* arr, void* dptr, hawk_oow_t dlen)
/* add a value at the back of the array */
index = arr->size;
if (hawk_arr_insert (arr, index, dptr, dlen) == HAWK_ARR_NIL) return HAWK_ARR_NIL;
if (hawk_arr_insert(arr, index, dptr, dlen) == HAWK_ARR_NIL) return HAWK_ARR_NIL;
HEAP_UPDATE_POS (arr, index);
HAWK_ASSERT (arr->hawk, arr->size == index + 1);
/*HAWK_ASSERT (arr->gem, arr->size == index + 1);*/
/* move the item upto the top if it's greater than the parent items */
sift_up (arr, index);
@ -691,7 +690,7 @@ hawk_oow_t hawk_arr_pushheap (hawk_arr_t* arr, void* dptr, hawk_oow_t dlen)
void hawk_arr_popheap (hawk_arr_t* arr)
{
HAWK_ASSERT (arr->hawk, arr->size > 0);
/*HAWK_ASSERT (arr->gem, arr->size > 0);*/
hawk_arr_deleteheap (arr, 0);
}
@ -699,8 +698,8 @@ void hawk_arr_deleteheap (hawk_arr_t* arr, hawk_oow_t index)
{
slot_t* tmp;
HAWK_ASSERT (arr->hawk, arr->size > 0);
HAWK_ASSERT (arr->hawk, index < arr->size);
/*HAWK_ASSERT (arr->gem, arr->size > 0);
HAWK_ASSERT (arr->gem, index < arr->size);*/
/* remember the item to destroy */
tmp = arr->slot[index];
@ -725,7 +724,7 @@ void hawk_arr_deleteheap (hawk_arr_t* arr, hawk_oow_t index)
/* destroy the actual item */
if (arr->freeer) arr->freeer (arr, DPTR(tmp), DLEN(tmp));
hawk_freemem (arr->hawk, tmp);
hawk_gem_freemem (arr->gem, tmp);
/* empty the last slot */
arr->slot[arr->size] = HAWK_NULL;
@ -737,7 +736,7 @@ hawk_oow_t hawk_arr_updateheap (hawk_arr_t* arr, hawk_oow_t index, void* dptr, h
int n;
tmp = arr->slot[index];
HAWK_ASSERT (arr->hawk, tmp != HAWK_NULL);
/*HAWK_ASSERT (arr->gem, tmp != HAWK_NULL);*/
n = arr->comper(arr, dptr, dlen, DPTR(tmp), DLEN(tmp));
if (n)

4
hawk/lib/ecs.c
View File

@ -70,14 +70,12 @@ hawk_oow_t hawk_becs_ncatuchars (hawk_becs_t* str, const hawk_uch_t* s, hawk_oow
hawk_oow_t bcslen, ucslen;
ucslen = len;
//if (qse_wcsntombsnwithcmgr(s, &ucslen, QSE_NULL, &bcslen, cmgr) <= -1) return (hawk_oow_t)-1;
if (hawk_conv_uchars_to_bchars_with_cmgr(s, &ucslen, HAWK_NULL, &bcslen, cmgr) <= -1) return (hawk_oow_t)-1;
if (hawk_becs_resize_for_ncat(str, bcslen) <= 0) return -1;
ucslen = len;
bcslen = str->capa - str->val.len;
//qse_wcsntombsnwithcmgr(s, &ucslen, &str->val.ptr[str->val.len], &bcslen, cmgr);
hawk_conv_uchars_to_bchars_with_cmgr (s, &ucslen, &str->val.ptr[str->val.len], &bcslen, cmgr);
str->val.len += bcslen;
str->val.ptr[str->val.len] = '\0';
@ -90,14 +88,12 @@ hawk_oow_t hawk_uecs_ncatbchars (hawk_uecs_t* str, const hawk_bch_t* s, hawk_oow
hawk_oow_t bcslen, ucslen;
bcslen = len;
//if (qse_mbsntowcsnallwithcmgr(s, &bcslen, QSE_NULL, &ucslen, cmgr) <= -1) return (hawk_oow_t)-1;
if (hawk_conv_bchars_to_uchars_with_cmgr(s, &bcslen, HAWK_NULL, &ucslen, cmgr, all) <= -1) return (hawk_oow_t)-1;
if (hawk_uecs_resize_for_ncat(str, ucslen) <= 0) return -1;
bcslen = len;
ucslen = str->capa - str->val.len;
//qse_mbsntowcsnallwithcmgr(s, &bcslen, &str->val.ptr[str->val.len], &ucslen, cmgr);
hawk_conv_bchars_to_uchars_with_cmgr (s, &bcslen, &str->val.ptr[str->val.len], &ucslen, cmgr, all);
str->val.len += ucslen;
str->val.ptr[str->val.len] = '\0';

2
hawk/lib/err.c
View File

@ -92,7 +92,7 @@ const hawk_ooch_t* hawk_dflerrstr (hawk_t* awk, hawk_errnum_t errnum)
HAWK_T("variable '${0}' redefined"),
HAWK_T("duplicate parameter name '${0}'"),
HAWK_T("duplicate global variable '${0}'"),
HAWK_T("duplicate local variable '${0}'"),
HAWK_T("duplicate local variable"),
HAWK_T("'${0}' not a valid parameter name"),
HAWK_T("'${0}' not a valid variable name"),
HAWK_T("variable name missing"),

6
hawk/lib/hawk-arr.h
View File

@ -141,7 +141,7 @@ typedef hawk_arr_walk_t (*hawk_arr_walker_t) (
*/
struct hawk_arr_t
{
hawk_t* hawk;
hawk_gem_t* gem;
hawk_arr_copier_t copier; /* data copier */
hawk_arr_freeer_t freeer; /* data freeer */
hawk_arr_comper_t comper; /* data comparator */
@ -171,7 +171,7 @@ extern "C" {
* The hawk_arr_open() function creates a linear dynamic array.
*/
HAWK_EXPORT hawk_arr_t* hawk_arr_open (
hawk_t* awk, /**< memory manager */
hawk_gem_t* gem,
hawk_oow_t ext, /**< extension size in bytes */
hawk_oow_t capa /**< initial array capacity */
);
@ -188,7 +188,7 @@ HAWK_EXPORT void hawk_arr_close (
*/
HAWK_EXPORT int hawk_arr_init (
hawk_arr_t* arr,
hawk_t* awk,
hawk_gem_t* gem,
hawk_oow_t capa
);

6
hawk/lib/hawk.c
View File

@ -201,9 +201,9 @@ int hawk_init (hawk_t* awk, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr, const hawk_prm
awk->parse.funs = hawk_htb_open(hawk_getgem(awk), HAWK_SIZEOF(awk), 256, 70, HAWK_SIZEOF(hawk_ooch_t), 1);
awk->parse.named = hawk_htb_open(hawk_getgem(awk), HAWK_SIZEOF(awk), 256, 70, HAWK_SIZEOF(hawk_ooch_t), 1);
awk->parse.gbls = hawk_arr_open(awk, HAWK_SIZEOF(awk), 128);
awk->parse.lcls = hawk_arr_open(awk, HAWK_SIZEOF(awk), 64);
awk->parse.params = hawk_arr_open(awk, HAWK_SIZEOF(awk), 32);
awk->parse.gbls = hawk_arr_open(hawk_getgem(awk), HAWK_SIZEOF(awk), 128);
awk->parse.lcls = hawk_arr_open(hawk_getgem(awk), HAWK_SIZEOF(awk), 64);
awk->parse.params = hawk_arr_open(hawk_getgem(awk), HAWK_SIZEOF(awk), 32);
awk->fnc.sys = HAWK_NULL;
awk->fnc.user = hawk_htb_open(hawk_getgem(awk), HAWK_SIZEOF(awk), 512, 70, HAWK_SIZEOF(hawk_ooch_t), 1);

100
hawk/lib/parse.c
View File

@ -1327,7 +1327,7 @@ static hawk_nde_t* parse_function (hawk_t* awk)
if (hawk_arr_insert(awk->parse.params, HAWK_ARR_SIZE(awk->parse.params), pa, pal) == HAWK_ARR_NIL)
{
SETERR_LOC (awk, HAWK_ENOMEM, &awk->tok.loc);
ADJERR_LOC (awk, &awk->tok.loc);
goto oops;
}
@ -1977,7 +1977,7 @@ int hawk_addgblwithucstr (hawk_t* awk, const hawk_uch_t* name)
#define HAWK_NUM_STATIC_GBLS \
(HAWK_MAX_GBL_ID-HAWK_MIN_GBL_ID+1)
int hawk_delgblwithbcstr (hawk_t* awk, const hawk_bch_t* name)
int hawk_delgblwithbcstr (hawk_t* hawk, const hawk_bch_t* name)
{
hawk_oow_t n;
hawk_bcs_t ncs;
@ -1986,31 +1986,31 @@ int hawk_delgblwithbcstr (hawk_t* awk, const hawk_bch_t* name)
ncs.ptr = (hawk_bch_t*)name;
ncs.len = hawk_count_bcstr(name);
if (awk->tree.ngbls > awk->tree.ngbls_base)
if (hawk->tree.ngbls > hawk->tree.ngbls_base)
{
/* this function is not allow after hawk_parse is called */
hawk_seterrnum (awk, HAWK_EPERM, HAWK_NULL);
hawk_seterrnum (hawk, HAWK_EPERM, HAWK_NULL);
return -1;
}
#if defined(HAWK_OOCH_IS_BCH)
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &ncs);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT "no such global variable - %.*hs", ncs.len, ncs.ptr);
return -1;
}
#else
wcs.ptr = hawk_dupbtoucstr(awk, ncs.ptr, &wcs.len, 0);
wcs.ptr = hawk_dupbtoucstr(hawk, ncs.ptr, &wcs.len, 0);
if (!wcs.ptr) return -1;
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, wcs.ptr, wcs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, wcs.ptr, wcs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &wcs);
hawk_freemem (awk, wcs.ptr);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such global variable - %.*ls", wcs.len, wcs.ptr);
hawk_freemem (hawk, wcs.ptr);
return -1;
}
hawk_freemem (awk, wcs.ptr);
hawk_freemem (hawk, wcs.ptr);
#endif
/* invalidate the name if deletion is requested.
@ -2019,16 +2019,16 @@ int hawk_delgblwithbcstr (hawk_t* awk, const hawk_bch_t* name)
* again, the entry will be appended again.
* never call this funciton unless it is really required. */
/*
awk->parse.gbls.buf[n].name.ptr[0] = HAWK_T('\0');
awk->parse.gbls.buf[n].name.len = 0;
hawk->parse.gbls.buf[n].name.ptr[0] = HAWK_T('\0');
hawk->parse.gbls.buf[n].name.len = 0;
*/
n = hawk_arr_uplete(awk->parse.gbls, n, 1);
HAWK_ASSERT (awk, n == 1);
n = hawk_arr_uplete(hawk->parse.gbls, n, 1);
HAWK_ASSERT (hawk, n == 1);
return 0;
}
int hawk_delgblwithucstr (hawk_t* awk, const hawk_uch_t* name)
int hawk_delgblwithucstr (hawk_t* hawk, const hawk_uch_t* name)
{
hawk_oow_t n;
hawk_ucs_t ncs;
@ -2037,29 +2037,29 @@ int hawk_delgblwithucstr (hawk_t* awk, const hawk_uch_t* name)
ncs.ptr = (hawk_uch_t*)name;
ncs.len = hawk_count_ucstr(name);
if (awk->tree.ngbls > awk->tree.ngbls_base)
if (hawk->tree.ngbls > hawk->tree.ngbls_base)
{
/* this function is not allow after hawk_parse is called */
hawk_seterrnum (awk, HAWK_EPERM, HAWK_NULL);
hawk_seterrnum (hawk, HAWK_EPERM, HAWK_NULL);
return -1;
}
#if defined(HAWK_OOCH_IS_BCH)
mbs.ptr = hawk_duputobcstr(awk, ncs.ptr, &mbs.len);
mbs.ptr = hawk_duputobcstr(hawk, ncs.ptr, &mbs.len);
if (!mbs.ptr) return -1;
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, mbs.ptr, mbs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, mbs.ptr, mbs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &mbs);
hawk_freemem (awk, mbs.ptr);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such global variable - %.*hs", mbs.len, mbs.ptr);
hawk_freemem (hawk, mbs.ptr);
return -1;
}
hawk_freemem (awk, mbs.ptr);
hawk_freemem (hawk, mbs.ptr);
#else
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &ncs);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such global variable - %.*ls", ncs.len, ncs.ptr);
return -1;
}
#endif
@ -2070,16 +2070,16 @@ int hawk_delgblwithucstr (hawk_t* awk, const hawk_uch_t* name)
* again, the entry will be appended again.
* never call this funciton unless it is really required. */
/*
awk->parse.gbls.buf[n].name.ptr[0] = HAWK_T('\0');
awk->parse.gbls.buf[n].name.len = 0;
hawk->parse.gbls.buf[n].name.ptr[0] = HAWK_T('\0');
hawk->parse.gbls.buf[n].name.len = 0;
*/
n = hawk_arr_uplete(awk->parse.gbls, n, 1);
n = hawk_arr_uplete(hawk->parse.gbls, n, 1);
HAWK_ASSERT (awk, n == 1);
return 0;
}
int hawk_findgblwithbcstr (hawk_t* awk, const hawk_bch_t* name)
int hawk_findgblwithbcstr (hawk_t* hawk, const hawk_bch_t* name)
{
hawk_oow_t n;
hawk_bcs_t ncs;
@ -2089,29 +2089,29 @@ int hawk_findgblwithbcstr (hawk_t* awk, const hawk_bch_t* name)
ncs.len = hawk_count_bcstr(name);
#if defined(HAWK_OOCH_IS_BCH)
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &ncs);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such global variable - %.*hs", ncs.len, ncs.ptr);
return -1;
}
#else
wcs.ptr = hawk_dupbtoucstr(awk, ncs.ptr, &wcs.len, 0);
wcs.ptr = hawk_dupbtoucstr(hawk, ncs.ptr, &wcs.len, 0);
if (!wcs.ptr) return -1;
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, wcs.ptr, wcs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, wcs.ptr, wcs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &wcs);
hawk_freemem (awk, wcs.ptr);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such global variable - %.*ls", wcs.len, wcs.ptr);
hawk_freemem (hawk, wcs.ptr);
return -1;
}
hawk_freemem (awk, wcs.ptr);
hawk_freemem (hawk, wcs.ptr);
#endif
return (int)n;
}
int hawk_findgblwithucstr (hawk_t* awk, const hawk_uch_t* name)
int hawk_findgblwithucstr (hawk_t* hawk, const hawk_uch_t* name)
{
hawk_oow_t n;
hawk_ucs_t ncs;
@ -2121,21 +2121,21 @@ int hawk_findgblwithucstr (hawk_t* awk, const hawk_uch_t* name)
ncs.len = hawk_count_ucstr(name);
#if defined(HAWK_OOCH_IS_BCH)
mbs.ptr = hawk_duputobcstr(awk, ncs.ptr, &mbs.len);
mbs.ptr = hawk_duputobcstr(hawk, ncs.ptr, &mbs.len);
if (!mbs.ptr) return -1;
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, mbs.ptr, mbs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, mbs.ptr, mbs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &mbs);
hawk_freemem (awk, mbs.ptr);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such global variable - %.*hs", mbs.len, mbs.ptr);
hawk_freemem (hawk, mbs.ptr);
return -1;
}
hawk_freemem (awk, mbs.ptr);
hawk_freemem (hawk, mbs.ptr);
#else
n = hawk_arr_search(awk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
n = hawk_arr_search(hawk->parse.gbls, HAWK_NUM_STATIC_GBLS, ncs.ptr, ncs.len);
if (n == HAWK_ARR_NIL)
{
hawk_seterrnum (awk, HAWK_ENOENT, &ncs);
hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such global variable - %.*ls", ncs.len, ncs.ptr);
return -1;
}
#endif
@ -2257,32 +2257,32 @@ static hawk_t* collect_locals (hawk_t* awk, hawk_oow_t nlcls, int istop)
n = hawk_arr_search(awk->parse.lcls, nlcls, lcl.ptr, lcl.len);
if (n != HAWK_ARR_NIL)
{
SETERR_ARG_LOC (awk, HAWK_EDUPLCL, lcl.ptr, lcl.len, &awk->tok.loc);
hawk_seterrbfmt (awk, &awk->tok.loc, HAWK_EDUPLCL, "duplicate local variable - %.*js", lcl.len, lcl.ptr);
return HAWK_NULL;
}
/* check if it conflicts with global variable names */
n = find_global (awk, &lcl);
n = find_global(awk, &lcl);
if (n != HAWK_ARR_NIL)
{
if (n < awk->tree.ngbls_base)
{
/* it is a conflict only if it is one of a
* static global variable */
SETERR_ARG_LOC (awk, HAWK_EDUPLCL, lcl.ptr, lcl.len, &awk->tok.loc);
hawk_seterrbfmt (awk, &awk->tok.loc, HAWK_EDUPLCL, "duplicate local variable - %.*js", lcl.len, lcl.ptr);
return HAWK_NULL;
}
}
if (HAWK_ARR_SIZE(awk->parse.lcls) >= HAWK_MAX_LCLS)
{
SETERR_LOC (awk, HAWK_ELCLTM, &awk->tok.loc);
hawk_seterrbfmt (awk, &awk->tok.loc, HAWK_ELCLTM, "too many local variables defined - %.*js", lcl.len, lcl.ptr);
return HAWK_NULL;
}
if (hawk_arr_insert (awk->parse.lcls, HAWK_ARR_SIZE(awk->parse.lcls), lcl.ptr, lcl.len) == HAWK_ARR_NIL)
if (hawk_arr_insert(awk->parse.lcls, HAWK_ARR_SIZE(awk->parse.lcls), lcl.ptr, lcl.len) == HAWK_ARR_NIL)
{
SETERR_LOC (awk, HAWK_ENOMEM, &awk->tok.loc);
ADJERR_LOC (awk, &awk->tok.loc);
return HAWK_NULL;
}

2
hawk/lib/pma.c
View File

@ -25,7 +25,7 @@
*/
/*
* This is the TRE memory allocator modified for QSE.
* This is the TRE memory allocator modified for Hawk.
* See the original license notice below.
*/