removed redundant return in a void function

refactored htb and rbt a bit

lib/hawk-prv.h

@@ -437,15 +437,6 @@ 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;
@@ -460,11 +451,6 @@ 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

@@ -46,7 +46,7 @@
 #define KTOB(htb,len) ((len) * (htb)->scale[HAWK_HTB_KEY])
 #define VTOB(htb,len) ((len) * (htb)->scale[HAWK_HTB_VAL])
 
-HAWK_INLINE pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen)
+static HAWK_INLINE_ALWAYS pair_t* alloc_pair (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 @@ HAWK_INLINE pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t
 	return n;
 }
 
-HAWK_INLINE void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair)
+static HAWK_INLINE_ALWAYS void free_pair (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,7 +124,17 @@ HAWK_INLINE void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair)
 	hawk_gem_freemem(htb->gem, pair);
 }
 
-static HAWK_INLINE pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void* vptr, hawk_oow_t vlen)
+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)
 {
 	if (VPTR(pair) == vptr && VLEN(pair) == vlen)
 	{
@@ -157,9 +167,9 @@ static HAWK_INLINE pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void*
 			else
 			{
 				/* need to reconstruct the pair */
-				pair_t* p = hawk_htb_allocpair(htb, KPTR(pair), KLEN(pair), vptr, vlen);
+				pair_t* p = alloc_pair(htb, KPTR(pair), KLEN(pair), vptr, vlen);
 				if (HAWK_UNLIKELY(!p)) return HAWK_NULL;
-				hawk_htb_freepair(htb, pair);
+				free_pair(htb, pair);
 				return p;
 			}
 		}
@@ -436,7 +446,7 @@ static HAWK_INLINE int reorganize (hawk_htb_t* htb)
 #define ENSERT 3
 #define INSERT 4
 
-static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, void* vptr, hawk_oow_t vlen, int opt)
+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)
 {
 	pair_t* pair, * p, * prev, * next;
 	hawk_oow_t hc;
@@ -507,7 +517,7 @@ static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen,
 
 	HAWK_ASSERT(pair == HAWK_NULL);
 
-	pair = hawk_htb_allocpair(htb, kptr, klen, vptr, vlen);
+	pair = alloc_pair(htb, kptr, klen, vptr, vlen);
 	if (HAWK_UNLIKELY(!pair)) return HAWK_NULL; /* error */
 
 	NEXT(pair) = htb->bucket[hc];
@@ -617,7 +627,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);
 
-			hawk_htb_freepair(htb, pair);
+			free_pair(htb, pair);
 			htb->size--;
 			htb->rev++;
 
@@ -645,7 +655,7 @@ void hawk_htb_clear (hawk_htb_t* htb)
 		while (pair)
 		{
 			next = NEXT(pair);
-			hawk_htb_freepair(htb, pair);
+			free_pair(htb, pair);
 			htb->size--;
 			pair = next;
 		}

lib/rbt.c

@@ -53,7 +53,7 @@
 #define rotate_left(rbt,pivot) rotate(rbt,pivot,1);
 #define rotate_right(rbt,pivot) rotate(rbt,pivot,0);
 
-HAWK_INLINE hawk_rbt_pair_t* hawk_rbt_allocpair (
+static HAWK_INLINE_ALWAYS hawk_rbt_pair_t* alloc_pair (
 	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 @@ HAWK_INLINE hawk_rbt_pair_t* hawk_rbt_allocpair (
 	return pair;
 }
 
-HAWK_INLINE void hawk_rbt_freepair (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair)
+static HAWK_INLINE_ALWAYS void free_pair (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,6 +129,16 @@ HAWK_INLINE void hawk_rbt_freepair (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[] =
 {
 	{
@@ -450,7 +460,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 = hawk_rbt_allocpair(rbt, KPTR(pair), KLEN(pair), vptr, vlen);
+				hawk_rbt_pair_t* p = alloc_pair(rbt, KPTR(pair), KLEN(pair), vptr, vlen);
 				if (HAWK_UNLIKELY(!p)) return HAWK_NULL;
 
 				p->color = pair->color;
@@ -475,7 +485,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;
 
-				hawk_rbt_freepair(rbt, pair);
+				free_pair(rbt, pair);
 				return p;
 			}
 		}
@@ -539,7 +549,7 @@ static hawk_rbt_pair_t* insert (hawk_rbt_t* rbt, void* kptr, hawk_oow_t klen, vo
 		return HAWK_NULL;
 	}
 
-	x_new = hawk_rbt_allocpair(rbt, kptr, klen, vptr, vlen);
+	x_new = alloc_pair(rbt, kptr, klen, vptr, vlen);
 	if (HAWK_UNLIKELY(!x_new)) return HAWK_NULL;
 
 	if (x_par == HAWK_NULL)
@@ -819,7 +829,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);
 
-		hawk_rbt_freepair(rbt, y);
+		free_pair(rbt, y);
 	}
 	else
 	{
@@ -844,7 +854,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;
 
-		hawk_rbt_freepair(rbt, pair);
+		free_pair(rbt, pair);
 	}
 
 	rbt->size--;

lib/run.c

@@ -108,12 +108,11 @@ 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, int state, hawk_nde_while_t* nde);
+static int run_while (hawk_rtx_t* rtx, 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);
@@ -691,6 +690,7 @@ 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,7 +2498,6 @@ 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;
 	}
@@ -2516,10 +2515,8 @@ static int run_pblock (hawk_rtx_t* rtx, hawk_chain_t* cha, hawk_oow_t bno)
 
 			if (hawk_rtx_valtobool(rtx, v1))
 			{
-				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)
+				rtx->active_block = blk;
+				if (run_block(rtx, blk) <= -1)
 				{
 					hawk_rtx_refdownval_inline(rtx, v1);
 					return -1;
@@ -2564,35 +2561,37 @@ 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;
 
-	HAWK_ASSERT(nde != HAWK_NULL);
+	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->type == HAWK_NDE_BLK);
 	/*saved_stack_top = rtx->stack_top;*/
 
@@ -2929,34 +2928,7 @@ static HAWK_INLINE int run_pending_signal_handlers (hawk_rtx_t* rtx)
 	return 0;
 }
 
-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)
+static int run_statement (hawk_rtx_t* rtx, hawk_nde_t* nde)
 {
 	int xret;
 	hawk_val_t* tmp;
@@ -2993,7 +2965,7 @@ static int run_statement0 (hawk_rtx_t* rtx, int state, hawk_nde_t* nde)
 
 		case HAWK_NDE_WHILE:
 		case HAWK_NDE_DOWHILE:
-			xret = run_while(rtx, state, (hawk_nde_while_t*)nde);
+			xret = run_while(rtx, (hawk_nde_while_t*)nde);
 			break;
 
 		case HAWK_NDE_FOR:
@@ -3063,36 +3035,6 @@ static int run_statement0 (hawk_rtx_t* rtx, int state, 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;
@@ -3109,13 +3051,11 @@ 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 = push_exec_stack(rtx, 0, nde->then_part);
+		n = run_statement(rtx, nde->then_part);
 	}
 	else if (nde->else_part)
 	{
-		//n = run_statement(rtx, nde->else_part);
-		n = push_exec_stack(rtx, 0, nde->else_part);
+		n = run_statement(rtx, nde->else_part);
 	}
 
 	hawk_rtx_refdownval_inline(rtx, test); /* TODO: is this correct?*/
@@ -3190,6 +3130,7 @@ static int run_switch (hawk_rtx_t* rtx, hawk_nde_switch_t* nde)
 						action = action->next;
 					}
 					while(action);
+
 				}
 			}
 		}
@@ -3236,32 +3177,40 @@ done:
 	return ret;
 }
 
-static int run_while (hawk_rtx_t* rtx, int state, hawk_nde_while_t* nde)
+static int run_while (hawk_rtx_t* rtx, 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);
-			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 (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;
+			}
+
+			hawk_rtx_refdownval_inline(rtx, test);
 
 			if (rtx->exit_level == EXIT_BREAK)
 			{
@@ -3274,53 +3223,6 @@ static int run_while (hawk_rtx_t* rtx, int state, 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)
 	{