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

Compare commits

base: hyung-hwan/hawk:main
Branches Tags
hyung-hwan/hawk:main
..
compare: hyung-hwan/hawk:f3dc3052a717562736e5bc8db6d5b817f61ae386
Branches Tags
hyung-hwan/hawk:main

2 Commits
main .. f3dc3052a7

Author SHA1 Message Date
hyung-hwan f3dc3052a7 added some test cases to cover unary with relational ops
continuous-integration/drone/push Build is failing
Details
2026-05-25 10:28:23 +09:00
hyung-hwan ece6c0e286 interim checkpoint for execution stack implementation 2026-05-24 20:07:48 +09:00
5 changed files with 180 additions and 88 deletions
Expand all files Collapse all files
lib/hawk-htb.h
+2 -2
View File
@@ -510,7 +510,7 @@ HAWK_EXPORT hawk_htb_pair_t* hawk_htb_update (
* if (pair == HAWK_NULL)
* {
* // no existing key for the key
* return hawk_htb_allocpair(htb, kptr, klen, v->ptr, v->len);
* return hawk_htb_allocpair (htb, kptr, klen, v->ptr, v->len);
* }
* else
* {
@@ -523,7 +523,7 @@ HAWK_EXPORT hawk_htb_pair_t* hawk_htb_update (
*
* // allocate a new pair, but without filling the actual value.
* // note vptr is given HAWK_NULL for that purpose
* new_pair = hawk_htb_allocpair(
* new_pair = hawk_htb_allocpair (
* htb, kptr, klen, HAWK_NULL, HAWK_HTB_VLEN(pair) + 1 + v->len);
* if (new_pair == HAWK_NULL) return HAWK_NULL;
*
lib/hawk-prv.h
+14
View File
@@ -437,6 +437,15 @@ struct hawk_var_xinfo_t
hawk_loc_t loc;
};
/* item to to in the exec stack */
struct hawk_exec_stack_t
{
int state;
hawk_nde_t* nde;
};
typedef struct hawk_exec_stack_t hawk_exec_stack_t;
struct hawk_rtx_t
{
HAWK_RTX_HDR;
@@ -451,6 +460,11 @@ struct hawk_rtx_t
hawk_oow_t stack_base;
hawk_oow_t stack_limit;
/* stack for executing statements */
hawk_exec_stack_t* exec_stack;
hawk_oow_t exec_stack_size;
hawk_oow_t exec_stack_limit;
int exit_level;
int init_called;
lib/htb.c
+9 -19
View File
@@ -46,7 +46,7 @@
#define KTOB(htb,len) ((len) * (htb)->scale[HAWK_HTB_KEY])
#define VTOB(htb,len) ((len) * (htb)->scale[HAWK_HTB_VAL])
static HAWK_INLINE_ALWAYS pair_t* alloc_pair (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
HAWK_INLINE pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
{
pair_t* n;
copier_t kcop, vcop;
@@ -115,7 +115,7 @@ static HAWK_INLINE_ALWAYS pair_t* alloc_pair (hawk_htb_t* htb, void* kptr, hawk_
return n;
}
static HAWK_INLINE_ALWAYS void free_pair (hawk_htb_t* htb, pair_t* pair)
HAWK_INLINE void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair)
{
if (htb->style->freeer[HAWK_HTB_KEY] != HAWK_NULL)
htb->style->freeer[HAWK_HTB_KEY](htb, KPTR(pair), KLEN(pair));
@@ -124,17 +124,7 @@ static HAWK_INLINE_ALWAYS void free_pair (hawk_htb_t* htb, pair_t* pair)
hawk_gem_freemem(htb->gem, pair);
}
pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
{
return alloc_pair(htb, kptr, klen, vptr, vlen);
}
void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair)
{
free_pair(htb, pair);
}
static HAWK_INLINE_ALWAYS pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void* vptr, hawk_oow_t vlen)
static HAWK_INLINE pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void* vptr, hawk_oow_t vlen)
{
if (VPTR(pair) == vptr && VLEN(pair) == vlen)
{
@@ -167,9 +157,9 @@ static HAWK_INLINE_ALWAYS pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair
else
{
/* need to reconstruct the pair */
pair_t* p = alloc_pair(htb, KPTR(pair), KLEN(pair), vptr, vlen);
pair_t* p = hawk_htb_allocpair(htb, KPTR(pair), KLEN(pair), vptr, vlen);
if (HAWK_UNLIKELY(!p)) return HAWK_NULL;
free_pair(htb, pair);
hawk_htb_freepair(htb, pair);
return p;
}
}
@@ -446,7 +436,7 @@ static HAWK_INLINE int reorganize (hawk_htb_t* htb)
#define ENSERT 3
#define INSERT 4
static HAWK_INLINE_ALWAYS pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen, int opt)
static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen, int opt)
{
pair_t* pair, * p, * prev, * next;
hawk_oow_t hc;
@@ -517,7 +507,7 @@ static HAWK_INLINE_ALWAYS pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_
HAWK_ASSERT(pair == HAWK_NULL);
pair = alloc_pair(htb, kptr, klen, vptr, vlen);
pair = hawk_htb_allocpair(htb, kptr, klen, vptr, vlen);
if (HAWK_UNLIKELY(!pair)) return HAWK_NULL; /* error */
NEXT(pair) = htb->bucket[hc];
@@ -627,7 +617,7 @@ int hawk_htb_delete (hawk_htb_t* htb, const void* kptr, hawk_oow_t klen)
htb->bucket[hc] = NEXT(pair);
else NEXT(prev) = NEXT(pair);
free_pair(htb, pair);
hawk_htb_freepair(htb, pair);
htb->size--;
htb->rev++;
@@ -655,7 +645,7 @@ void hawk_htb_clear (hawk_htb_t* htb)
while (pair)
{
next = NEXT(pair);
free_pair(htb, pair);
hawk_htb_freepair(htb, pair);
htb->size--;
pair = next;
}
lib/rbt.c
+7 -17
View File
@@ -53,7 +53,7 @@
#define rotate_left(rbt,pivot) rotate(rbt,pivot,1);
#define rotate_right(rbt,pivot) rotate(rbt,pivot,0);
static HAWK_INLINE_ALWAYS hawk_rbt_pair_t* alloc_pair (
HAWK_INLINE hawk_rbt_pair_t* hawk_rbt_allocpair (
hawk_rbt_t* rbt, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
{
hawk_rbt_pair_t* pair;
@@ -120,7 +120,7 @@ static HAWK_INLINE_ALWAYS hawk_rbt_pair_t* alloc_pair (
return pair;
}
static HAWK_INLINE_ALWAYS void free_pair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
HAWK_INLINE void hawk_rbt_freepair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
{
if (rbt->style->freeer[HAWK_RBT_KEY])
rbt->style->freeer[HAWK_RBT_KEY](rbt, KPTR(pair), KLEN(pair));
@@ -129,16 +129,6 @@ static HAWK_INLINE_ALWAYS void free_pair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair
hawk_gem_freemem(rbt->gem, pair);
}
hawk_rbt_pair_t* hawk_rbt_allocpair (hawk_rbt_t* rbt, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
{
return alloc_pair(rbt, kptr, klen, vptr, vlen);
}
void hawk_rbt_freepair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
{
free_pair(rbt, pair);
}
static hawk_rbt_style_t style[] =
{
{
@@ -460,7 +450,7 @@ static hawk_rbt_pair_t* change_pair_val (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair,
else
{
/* need to reconstruct the pair */
hawk_rbt_pair_t* p = alloc_pair(rbt, KPTR(pair), KLEN(pair), vptr, vlen);
hawk_rbt_pair_t* p = hawk_rbt_allocpair(rbt, KPTR(pair), KLEN(pair), vptr, vlen);
if (HAWK_UNLIKELY(!p)) return HAWK_NULL;
p->color = pair->color;
@@ -485,7 +475,7 @@ static hawk_rbt_pair_t* change_pair_val (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair,
if (pair == rbt->root) rbt->root = p;
free_pair(rbt, pair);
hawk_rbt_freepair(rbt, pair);
return p;
}
}
@@ -549,7 +539,7 @@ static hawk_rbt_pair_t* insert (hawk_rbt_t* rbt, void* kptr, hawk_oow_t klen, vo
return HAWK_NULL;
}
x_new = alloc_pair(rbt, kptr, klen, vptr, vlen);
x_new = hawk_rbt_allocpair(rbt, kptr, klen, vptr, vlen);
if (HAWK_UNLIKELY(!x_new)) return HAWK_NULL;
if (x_par == HAWK_NULL)
@@ -829,7 +819,7 @@ static void delete_pair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
if (y->color == HAWK_RBT_BLACK && !IS_NIL(rbt,x))
adjust_for_delete(rbt, x, parent);
free_pair(rbt, y);
hawk_rbt_freepair(rbt, y);
}
else
{
@@ -854,7 +844,7 @@ static void delete_pair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
if (pair->left->parent == pair) pair->left->parent = y;
if (pair->right->parent == pair) pair->right->parent = y;
free_pair(rbt, pair);
hawk_rbt_freepair(rbt, pair);
}
rbt->size--;
lib/run.c
+148 -50
View File
@@ -108,11 +108,12 @@ static void refdown_globals (hawk_rtx_t* rtx, int pop);
static int run_pblocks (hawk_rtx_t* rtx);
static int run_pblock_chain (hawk_rtx_t* rtx, hawk_chain_t* cha);
static int run_pblock (hawk_rtx_t* rtx, hawk_chain_t* cha, hawk_oow_t bno);
static int run_null_block_for_blockless_pattern (hawk_rtx_t* rtx);
static int run_block (hawk_rtx_t* rtx, hawk_nde_blk_t* nde);
static int run_statement (hawk_rtx_t* rtx, hawk_nde_t* nde);
static int run_if (hawk_rtx_t* rtx, hawk_nde_if_t* nde);
static int run_switch (hawk_rtx_t* rtx, hawk_nde_switch_t* nde);
static int run_while (hawk_rtx_t* rtx, hawk_nde_while_t* nde);
static int run_while (hawk_rtx_t* rtx, int state, hawk_nde_while_t* nde);
static int run_for (hawk_rtx_t* rtx, hawk_nde_for_t* nde);
static int run_forin (hawk_rtx_t* rtx, hawk_nde_forin_t* nde);
static int run_break (hawk_rtx_t* rtx, hawk_nde_break_t* nde);
@@ -690,7 +691,6 @@ static int set_global (hawk_rtx_t* rtx, int idx, hawk_nde_var_t* var, hawk_val_t
if (ecb->gblset) ecb->gblset(rtx, idx, val, ecb->ctx);
}
}
return 0;
}
@@ -2498,6 +2498,7 @@ static int run_pblock (hawk_rtx_t* rtx, hawk_chain_t* cha, hawk_oow_t bno)
if (!ptn)
{
/* just execute the block */
HAWK_ASSERT(blk != HAWK_NULL); /* not possible to have no statement block */
rtx->active_block = blk;
if (run_block(rtx, blk) <= -1) return -1;
}
@@ -2515,8 +2516,10 @@ static int run_pblock (hawk_rtx_t* rtx, hawk_chain_t* cha, hawk_oow_t bno)
if (hawk_rtx_valtobool(rtx, v1))
{
rtx->active_block = blk;
if (run_block(rtx, blk) <= -1)
int n;
rtx->active_block = blk; /* this may be null for a blockless pattern */
n = blk? run_block(rtx, blk): run_null_block_for_blockless_pattern(rtx);
if (n <= -1)
{
hawk_rtx_refdownval_inline(rtx, v1);
return -1;
@@ -2561,37 +2564,35 @@ static int run_pblock (hawk_rtx_t* rtx, hawk_chain_t* cha, hawk_oow_t bno)
return 0;
}
static HAWK_INLINE int run_null_block_for_blockless_pattern (hawk_rtx_t* rtx)
{
int n;
/* blockless pattern - execute print $0*/
hawk_rtx_refupval_inline(rtx, rtx->inrec.d0);
n = hawk_rtx_writeiostr(rtx, HAWK_OUT_CONSOLE, HAWK_T(""), HAWK_OOECS_PTR(&rtx->inrec.line), HAWK_OOECS_LEN(&rtx->inrec.line));
if (n <= -1) goto oops;
n = hawk_rtx_writeiostr(rtx, HAWK_OUT_CONSOLE, HAWK_T(""), rtx->gbl.ors.ptr, rtx->gbl.ors.len);
if (n <= -1) goto oops;
hawk_rtx_refdownval_inline(rtx, rtx->inrec.d0);
return 0;
oops:
hawk_rtx_refdownval_inline(rtx, rtx->inrec.d0);
/* ADJERR_LOC(rtx, &nde->loc); - can't adjust error location as nde is null */
return -1;
}
static HAWK_INLINE int run_block0 (hawk_rtx_t* rtx, hawk_nde_blk_t* nde)
{
hawk_nde_t* p;
/*hawk_oow_t saved_stack_top;*/
int n = 0;
if (nde == HAWK_NULL)
{
/* blockless pattern - execute print $0*/
hawk_rtx_refupval_inline(rtx, rtx->inrec.d0);
n = hawk_rtx_writeiostr(rtx, HAWK_OUT_CONSOLE, HAWK_T(""), HAWK_OOECS_PTR(&rtx->inrec.line), HAWK_OOECS_LEN(&rtx->inrec.line));
if (n <= -1)
{
hawk_rtx_refdownval_inline(rtx, rtx->inrec.d0);
/* ADJERR_LOC(rtx, &nde->loc); - can't adjust error location as nde is null */
return -1;
}
n = hawk_rtx_writeiostr(rtx, HAWK_OUT_CONSOLE, HAWK_T(""), rtx->gbl.ors.ptr, rtx->gbl.ors.len);
if (n <= -1)
{
hawk_rtx_refdownval_inline(rtx, rtx->inrec.d0);
/* ADJERR_LOC(rtx, &nde->loc); - can't adjust error location as nde is null */
return -1;
}
hawk_rtx_refdownval_inline(rtx, rtx->inrec.d0);
return 0;
}
HAWK_ASSERT(nde != HAWK_NULL);
HAWK_ASSERT(nde->type == HAWK_NDE_BLK);
/*saved_stack_top = rtx->stack_top;*/
@@ -2928,7 +2929,34 @@ static HAWK_INLINE int run_pending_signal_handlers (hawk_rtx_t* rtx)
return 0;
}
static int run_statement (hawk_rtx_t* rtx, hawk_nde_t* nde)
static int push_exec_stack (hawk_rtx_t* rtx, int state, hawk_nde_t* nde)
{
if (rtx->exec_stack_size >= rtx->exec_stack_limit)
{
hawk_oow_t new_limit;
hawk_exec_stack_t* tmp;
new_limit = rtx->exec_stack_limit + 1;
new_limit = HAWK_ALIGN_POW2(new_limit, 64); /* TODO: change align factor */
tmp = hawk_rtx_reallocmem(rtx, rtx->exec_stack, HAWK_SIZEOF(*tmp) * new_limit);
if (HAWK_UNLIKELY(!tmp)) return -1;
rtx->exec_stack = tmp;
rtx->exec_stack_limit = new_limit;
}
rtx->exec_stack[rtx->exec_stack_size].state = state;
rtx->exec_stack[rtx->exec_stack_size].nde = nde;
rtx->exec_stack_size++;
return 0;
}
/* TODO: return the item pointer? */
static hawk_exec_stack_t* pop_exec_stack (hawk_rtx_t* rtx, hawk_exec_stack_t* es)
{
if (rtx->exec_stack_size <= 0) return HAWK_NULL;
*es = rtx->exec_stack[--rtx->exec_stack_size];
return es;
}
static int run_statement0 (hawk_rtx_t* rtx, int state, hawk_nde_t* nde)
{
int xret;
hawk_val_t* tmp;
@@ -2965,7 +2993,7 @@ static int run_statement (hawk_rtx_t* rtx, hawk_nde_t* nde)
case HAWK_NDE_WHILE:
case HAWK_NDE_DOWHILE:
xret = run_while(rtx, (hawk_nde_while_t*)nde);
xret = run_while(rtx, state, (hawk_nde_while_t*)nde);
break;
case HAWK_NDE_FOR:
@@ -3035,6 +3063,36 @@ static int run_statement (hawk_rtx_t* rtx, hawk_nde_t* nde)
return xret;
}
static int run_statement (hawk_rtx_t* rtx, hawk_nde_t* nde)
{
int xret;
hawk_oow_t base;
hawk_exec_stack_t es;
HAWK_ASSERT(nde != HAWK_NULL);
// TODO: maybe the caller of this function can push nde to exec stack and call it without the parameter
base = rtx->exec_stack_size;
if (push_exec_stack(rtx, 0, nde) <= -1) return -1;
while (1)
{
if (!pop_exec_stack(rtx, &es)) break;
xret = run_statement0(rtx, es.state, es.nde);
if (xret <= -1)
{
/*while (rtx->exec_stack_size > base) pop_exec_stack(rtx);*/
rtx->exec_stack_size = base; /* restore the stack */
break;
}
if (rtx->exec_stack_size == base) break;
}
return xret;
}
static int run_if (hawk_rtx_t* rtx, hawk_nde_if_t* nde)
{
hawk_val_t* test;
@@ -3051,11 +3109,13 @@ static int run_if (hawk_rtx_t* rtx, hawk_nde_if_t* nde)
hawk_rtx_refupval_inline(rtx, test);
if (hawk_rtx_valtobool(rtx, test))
{
n = run_statement(rtx, nde->then_part);
//n = run_statement(rtx, nde->then_part);
n = push_exec_stack(rtx, 0, nde->then_part);
}
else if (nde->else_part)
{
n = run_statement(rtx, nde->else_part);
//n = run_statement(rtx, nde->else_part);
n = push_exec_stack(rtx, 0, nde->else_part);
}
hawk_rtx_refdownval_inline(rtx, test); /* TODO: is this correct?*/
@@ -3130,7 +3190,6 @@ static int run_switch (hawk_rtx_t* rtx, hawk_nde_switch_t* nde)
action = action->next;
}
while(action);
}
}
}
@@ -3177,41 +3236,33 @@ done:
return ret;
}
static int run_while (hawk_rtx_t* rtx, hawk_nde_while_t* nde)
static int run_while (hawk_rtx_t* rtx, int state, hawk_nde_while_t* nde)
{
hawk_val_t* test;
if (nde->type == HAWK_NDE_WHILE)
{
#if 0
/* no chained expressions are allowed for the test
* expression of the while statement */
HAWK_ASSERT(nde->test->next == HAWK_NULL);
while (1)
{
int verdict;
ON_STATEMENT(rtx, nde->test);
test = eval_expression(rtx, nde->test);
if (HAWK_UNLIKELY(!test)) return -1;
hawk_rtx_refupval_inline(rtx, test);
if (hawk_rtx_valtobool(rtx, test))
{
if (run_statement(rtx,nde->body) <= -1)
{
hawk_rtx_refdownval_inline(rtx, test);
return -1;
}
}
else
{
hawk_rtx_refdownval_inline(rtx, test);
break;
}
verdict = hawk_rtx_valtobool(rtx, test);
hawk_rtx_refdownval_inline(rtx, test);
if (!verdict) break;
if (run_statement(rtx, nde->body) <= -1) return -1;
if (rtx->exit_level == EXIT_BREAK)
{
rtx->exit_level = EXIT_NONE;
@@ -3223,6 +3274,53 @@ static int run_while (hawk_rtx_t* rtx, hawk_nde_while_t* nde)
}
else if (rtx->exit_level != EXIT_NONE) break;
}
#else
/* no chained expressions are allowed for the test
* expression of the while statement */
HAWK_ASSERT(nde->test->next == HAWK_NULL);
ON_STATEMENT(rtx, nde->test);
if (state >= 1)
{
int verdict;
hawk_val_t* v;
if (state == 2)
{
if (rtx->exit_level == EXIT_BREAK)
{
rtx->exit_level = EXIT_NONE;
goto done;
}
else if (rtx->exit_level == EXIT_CONTINUE)
{
rtx->exit_level = EXIT_NONE;
}
else if (rtx->exit_level != EXIT_ONE)
{
goto done;
}
}
v = pop_eval_stack(rtx); /* result of the test */
hawk_rtx_refupval_inline(rtx, v);
verdict = hawk_rtx_valtobool(rtx, v);
hawk_rtx_refdownval_inline(rtx, v);
if (verdict)
{
if (push_exec_stack(rtx, 2, (hawk_nde_t*)nde) <= -1 ||
push_exec_stack(rtx, 0, nde->body) <= -1) return -1;
}
}
else
{
if (push_exec_stack(rtx, 1, (hawk_nde_t*)nde) <= -1) return -1;
if (push_exec_stack(rtx, 0, nde->test) <= -1) return -1;
}
#endif
}
else if (nde->type == HAWK_NDE_DOWHILE)
{