fixed a wrong assertion

lib/hawk-prv.h

@@ -69,10 +69,12 @@ typedef struct hawk_tree_t hawk_tree_t;
 #define HAWK_ENABLE_ATOMIC_SIG
 #endif
 
+/* this part is kept for preservation of experiment only.
 #if defined(HAVE_UCONTEXT_H)
 #include <ucontext.h>
 #define HAWK_ENABLE_UCONTEXT
 #endif
+*/
 
 /* Use iterative (heap-stack) expression evaluation instead of C recursion.
  * eval_expression, eval_expression0, and hawk_rtx_evalcall automatically
@@ -473,7 +475,10 @@ enum hawk_ef_state_t
 	HAWK_EF_LAND_LEFT,      /* logical AND: awaiting left result */
 	HAWK_EF_LAND_RIGHT,     /* logical AND: left done and true (val=left), awaiting right */
 	HAWK_EF_LOR_LEFT,       /* logical OR: awaiting left result */
-	HAWK_EF_LOR_RIGHT       /* logical OR: left done and false (val=left), awaiting right */
+	HAWK_EF_LOR_RIGHT,      /* logical OR: left done and false (val=left), awaiting right */
+#if defined(HAWK_ENABLE_XSTACK_EVAL)
+	HAWK_EF_FNCALL_FUN_AWAIT /* user fn body executing on exec_stack; aux=exec_body_base */
+#endif
 };
 typedef enum hawk_ef_state_t hawk_ef_state_t;
 
@@ -482,9 +487,24 @@ struct hawk_eframe_t
 	hawk_ef_state_t state;
 	hawk_nde_t*     nde;  /* composite node being processed */
 	hawk_val_t*     val;  /* intermediate value (refcount incremented) */
+	hawk_oow_t      aux;  /* FNCALL_FUN_AWAIT: exec_stack size when body frames were pushed */
 };
 typedef struct hawk_eframe_t hawk_eframe_t;
 
+#if defined(HAWK_ENABLE_XSTACK_EVAL)
+/* call frame: saves context for a user-defined function call made from within
+ * expression evaluation. stored in the call_stack. */
+struct hawk_call_frame_t
+{
+	hawk_nde_fncall_t* call;            /* call-site node */
+	hawk_fun_t*        fun;             /* resolved function */
+	hawk_oow_t         saved_stack_top; /* rtx->stack_top before the call */
+	hawk_oow_t         saved_stack_base;/* rtx->stack_base before the call */
+	hawk_oow_t         nargs;           /* actual argument count pushed */
+};
+typedef struct hawk_call_frame_t hawk_call_frame_t;
+#endif
+
 struct hawk_rtx_t
 {
 	HAWK_RTX_HDR;
@@ -509,7 +529,16 @@ struct hawk_rtx_t
 	hawk_oow_t eframe_stack_size;
 	hawk_oow_t eframe_stack_limit;
 
-#if defined(HAVE_UCONTEXT_H)
+#if defined(HAWK_ENABLE_XSTACK_EVAL)
+	/* heap-based call frame stack: user-defined function calls from eframe evaluation */
+	hawk_call_frame_t* call_stack;
+	hawk_oow_t call_stack_size;
+	hawk_oow_t call_stack_limit;
+	/* result register: eframe eval result delivered to exec AFTER_EVAL frames */
+	hawk_val_t* driver_eval_result;
+#endif
+
+#if defined(HAWK_ENABLE_UCONTEXT)
 	/* pool of reusable C stacks for coroutine-based function calls */
 	struct
 	{

lib/hawk.h

@@ -1922,12 +1922,14 @@ static HAWK_INLINE void hawk_geterruinf (hawk_t* hawk, hawk_erruinf_t* errinf) {
  * it automatically formatted.
  */
 #if defined(HAWK_HAVE_INLINE)
-static HAWK_INLINE void hawk_seterrnum (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum (hawk_getgem(hawk), errloc, errnum); }
-static HAWK_INLINE void hawk_seterrinf (hawk_t* hawk, const hawk_errinf_t* errinf) { hawk_gem_seterrinf (hawk_getgem(hawk), errinf); }
+static HAWK_INLINE void hawk_clrerror (hawk_t* hawk) { hawk_gem_seterrnum(hawk_getgem(hawk), HAWK_NULL, HAWK_ENOERR); }
+static HAWK_INLINE void hawk_seterrnum (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum(hawk_getgem(hawk), errloc, errnum); }
+static HAWK_INLINE void hawk_seterrinf (hawk_t* hawk, const hawk_errinf_t* errinf) { hawk_gem_seterrinf(hawk_getgem(hawk), errinf); }
 static HAWK_INLINE void hawk_seterror (hawk_t* hawk, const hawk_loc_t*  errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) { hawk_gem_seterror(hawk_getgem(hawk), errloc, errnum, errarg); }
 static HAWK_INLINE const hawk_ooch_t* hawk_backuperrmsg (hawk_t* hawk) { return hawk_gem_backuperrmsg(hawk_getgem(hawk)); }
 static HAWK_INLINE void hawk_geterror (hawk_t* hawk, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) { return hawk_gem_geterror(hawk_getgem(hawk), errnum, errmsg, errloc); }
 #else
+#define hawk_clrerror(hawk) hawk_gem_seterrnum(hawk_getgem(hawk), HAWK_NULL, HAWK_ENOERR)
 #define hawk_seterrnum(hawk, errloc, errnum) hawk_gem_seterrnum(hawk_getgem(hawk), errloc, errnum)
 #define hawk_seterrinf(hawk, errinf) hawk_gem_seterrinf(hawk_getgem(hawk), errinf)
 #define hawk_seterror(hawk, errloc, errnum, errarg) hawk_gem_seterror(hawk_getgem(hawk), errloc, errnum, errarg)
@@ -3119,11 +3121,13 @@ static HAWK_INLINE void hawk_rtx_geterror (hawk_rtx_t* rtx, hawk_errnum_t* errnu
  * The hawk_rtx_seterrinf() function sets error information.
  */
 #if defined(HAWK_HAVE_INLINE)
+static HAWK_INLINE void hawk_rtx_clrerror (hawk_rtx_t* rtx) { hawk_gem_seterrnum(hawk_rtx_getgem(rtx), HAWK_NULL, HAWK_ENOERR); }
 static HAWK_INLINE void hawk_rtx_seterrnum (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum (hawk_rtx_getgem(rtx), errloc, errnum); }
 static HAWK_INLINE void hawk_rtx_seterrinf (hawk_rtx_t* rtx, const hawk_errinf_t* errinf) { hawk_gem_seterrinf (hawk_rtx_getgem(rtx), errinf); }
 static HAWK_INLINE void hawk_rtx_seterror (hawk_rtx_t* rtx, const hawk_loc_t*  errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) { hawk_gem_seterror(hawk_rtx_getgem(rtx), errloc, errnum, errarg); }
 static HAWK_INLINE const hawk_ooch_t* hawk_rtx_backuperrmsg (hawk_rtx_t* rtx) { return hawk_gem_backuperrmsg(hawk_rtx_getgem(rtx)); }
 #else
+#define hawk_rtx_clrerror(rtx) hawk_gem_seterrnum(hawk_rtx_getgem(rtx), HAWK_NULL, HAWK_ENOERR)
 #define hawk_rtx_seterrnum(rtx, errloc, errnum) hawk_gem_seterrnum(hawk_rtx_getgem(rtx), errloc, errnum)
 #define hawk_rtx_seterrinf(rtx, errinf) hawk_gem_seterrinf(hawk_rtx_getgem(rtx), errinf)
 #define hawk_rtx_seterror(rtx, errloc, errnum, errarg) hawk_gem_seterror(hawk_rtx_getgem(rtx), errloc, errnum, errarg)

lib/run-prv.h

@@ -30,10 +30,10 @@ enum hawk_assop_type_t
 	/* if you change this, you have to change assop_str in tree.c.
 	 * synchronize it wit:
 	 *   - binop_func in eval_assignment of run.c
+	 *   - binop_func in eval_expression0_xstack in run.c
 	 *   - assop in assing_to_opcode of parse.c
 	 *   - TOK_XXX_ASSN in tok_t in parse.c
 	 *   - assop_str in tree.c
-	 *   - ass_binop in eval_expression0_xstack in run.c
 	 */
 	HAWK_ASSOP_NONE,
 	HAWK_ASSOP_PLUS,   /* += */
@@ -150,6 +150,7 @@ hawk_val_t* hawk_rtx_evalcall (
 	void* eharg
 );
 
+#if 0
 hawk_val_t* hawk_rtx_evalcall_xstack (
 	hawk_rtx_t* rtx,
 	hawk_nde_fncall_t* call,
@@ -159,6 +160,7 @@ hawk_val_t* hawk_rtx_evalcall_xstack (
 	void(*errhandler)(void*),
 	void* eharg
 );
+#endif
 
 int hawk_rtx_setsighandler (
 	hawk_rtx_t* rtx,

lib/tree.c

@@ -231,7 +231,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 			PUT_SRCSTR(hawk, HAWK_T(" "));
 			PRINT_EXPR(hawk, px->right);
 
-			HAWK_ASSERT (px->right->next == HAWK_NULL);
+			HAWK_ASSERT(px->right->next == HAWK_NULL);
 			break;
 		}
 
@@ -241,7 +241,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 
 			PUT_SRCSTR(hawk, HAWK_T("("));
 			PRINT_EXPR(hawk, px->left);
-			HAWK_ASSERT (px->left->next == HAWK_NULL);
+			HAWK_ASSERT(px->left->next == HAWK_NULL);
 
 			PUT_SRCSTR(hawk, HAWK_T(" "));
 			PUT_SRCSTR(hawk, binop_str[px->opcode][(hawk->opt.trait & HAWK_BLANKCONCAT)? 0: 1]);
@@ -252,7 +252,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 			PRINT_EXPR(hawk, px->right);
 			if (px->right->type == HAWK_NDE_ASS)
 				PUT_SRCSTR(hawk, HAWK_T(")"));
-			HAWK_ASSERT (px->right->next == HAWK_NULL);
+			HAWK_ASSERT(px->right->next == HAWK_NULL);
 			PUT_SRCSTR(hawk, HAWK_T(")"));
 			break;
 		}
@@ -260,7 +260,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 		case HAWK_NDE_EXP_UNR:
 		{
 			hawk_nde_exp_t* px = (hawk_nde_exp_t*)nde;
-			HAWK_ASSERT (px->right == HAWK_NULL);
+			HAWK_ASSERT(px->right == HAWK_NULL);
 
 			PUT_SRCSTR(hawk, HAWK_T("("));
 			PUT_SRCSTR(hawk, unrop_str[px->opcode]);
@@ -274,7 +274,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 		case HAWK_NDE_EXP_INCPRE:
 		{
 			hawk_nde_exp_t* px = (hawk_nde_exp_t*)nde;
-			HAWK_ASSERT (px->right == HAWK_NULL);
+			HAWK_ASSERT(px->right == HAWK_NULL);
 
 			PUT_SRCSTR(hawk, incop_str[px->opcode]);
 			PUT_SRCSTR(hawk, HAWK_T("("));
@@ -286,7 +286,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 		case HAWK_NDE_EXP_INCPST:
 		{
 			hawk_nde_exp_t* px = (hawk_nde_exp_t*)nde;
-			HAWK_ASSERT (px->right == HAWK_NULL);
+			HAWK_ASSERT(px->right == HAWK_NULL);
 
 			PUT_SRCSTR(hawk, HAWK_T("("));
 			PRINT_EXPR(hawk, px->left);
@@ -659,14 +659,14 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 			hawk_ooch_t tmp[HAWK_SIZEOF(hawk_int_t)*8+2];
 			hawk_oow_t n;
 			hawk_nde_var_t* px = (hawk_nde_var_t*)nde;
-			HAWK_ASSERT (px->id.idxa != (hawk_oow_t)-1);
+			HAWK_ASSERT(px->id.idxa != (hawk_oow_t)-1);
 
 			n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, tmp, HAWK_COUNTOF(tmp));
 
 			PUT_SRCSTR(hawk, HAWK_T("__p"));
 			PUT_SRCSTRN(hawk, tmp, n);
 
-			HAWK_ASSERT (px->idx == HAWK_NULL);
+			HAWK_ASSERT(px->idx == HAWK_NULL);
 			break;
 		}
 
@@ -674,8 +674,8 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 		{
 			hawk_oow_t n;
 			hawk_nde_var_t* px = (hawk_nde_var_t*)nde;
-			HAWK_ASSERT (px->id.idxa != (hawk_oow_t)-1);
-			HAWK_ASSERT (px->idx != HAWK_NULL);
+			HAWK_ASSERT(px->id.idxa != (hawk_oow_t)-1);
+			HAWK_ASSERT(px->idx != HAWK_NULL);
 
 			PUT_SRCSTR(hawk, HAWK_T("__p"));
 			n = hawk_int_to_oocstr(px->id.idxa, 10, HAWK_NULL, hawk->tmp.fmt, HAWK_COUNTOF(hawk->tmp.fmt));
@@ -687,10 +687,10 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 		case HAWK_NDE_NAMED:
 		{
 			hawk_nde_var_t* px = (hawk_nde_var_t*)nde;
-			/*HAWK_ASSERT (px->id.idxa == (hawk_oow_t)-1);
+			/*HAWK_ASSERT(px->id.idxa == (hawk_oow_t)-1);
 			 *  commented out the above assertion because
 			 *  id.idxa field holds an index to the rtx->named_slots. */
-			HAWK_ASSERT (px->idx == HAWK_NULL);
+			HAWK_ASSERT(px->idx == HAWK_NULL);
 
 			PUT_SRCSTRN(hawk, px->id.name.ptr, px->id.name.len);
 			break;
@@ -699,8 +699,10 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 		case HAWK_NDE_NAMEDIDX:
 		{
 			hawk_nde_var_t* px = (hawk_nde_var_t*)nde;
-			HAWK_ASSERT (px->id.idxa == (hawk_oow_t)-1);
-			HAWK_ASSERT (px->idx != HAWK_NULL);
+			/*HAWK_ASSERT(px->id.idxa == (hawk_oow_t)-1);
+			 *  commented out the above assertion because
+			 *  id.idxa field holds an index to the rtx->named_slots. */
+			HAWK_ASSERT(px->idx != HAWK_NULL);
 
 			PUT_SRCSTRN(hawk, px->id.name.ptr, px->id.name.len);
 			PRINT_EXPR_LIST_FOR_IDX(hawk, px->idx);
@@ -740,7 +742,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 			{
 				PUT_SRCSTRN(hawk, px->id.name.ptr, px->id.name.len);
 			}
-			HAWK_ASSERT (px->idx == HAWK_NULL);
+			HAWK_ASSERT(px->idx == HAWK_NULL);
 			break;
 		}
 
@@ -777,7 +779,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 			{
 				PUT_SRCSTRN(hawk, px->id.name.ptr, px->id.name.len);
 			}
-			HAWK_ASSERT (px->idx != HAWK_NULL);
+			HAWK_ASSERT(px->idx != HAWK_NULL);
 			PRINT_EXPR_LIST_FOR_IDX(hawk, px->idx);
 			break;
 		}
@@ -798,7 +800,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 			{
 				PUT_SRCSTRN(hawk, px->id.name.ptr, px->id.name.len);
 			}
-			HAWK_ASSERT (px->idx == HAWK_NULL);
+			HAWK_ASSERT(px->idx == HAWK_NULL);
 			break;
 		}
 
@@ -817,7 +819,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 			{
 				PUT_SRCSTRN(hawk, px->id.name.ptr, px->id.name.len);
 			}
-			HAWK_ASSERT (px->idx != HAWK_NULL);
+			HAWK_ASSERT(px->idx != HAWK_NULL);
 			PRINT_EXPR_LIST_FOR_IDX(hawk, px->idx);
 			break;
 		}
@@ -1027,7 +1029,7 @@ static int print_stmt (hawk_t* hawk, hawk_nde_t* p, int depth, int flags)
 			PRINT_EXPR(hawk, px->test);
 			PUT_SRCSTR(hawk, HAWK_T(") "));
 
-			HAWK_ASSERT (px->then_part != HAWK_NULL);
+			HAWK_ASSERT(px->then_part != HAWK_NULL);
 			xflags = STMT_FLAG_NO_LEAD_INDENT;
 			if (!px->else_part) xflags |= STMT_FLAG_NO_ENDING_NL;
 			xdepth = depth + (px->then_part->type != HAWK_NDE_BLK);
@@ -1202,7 +1204,7 @@ static int print_stmt (hawk_t* hawk, hawk_nde_t* p, int depth, int flags)
 				hawk_getkwname(hawk, HAWK_KWID_RETURN, &kw);
 				PUT_SRCSTRN(hawk, kw.ptr, kw.len);
 				PUT_SRCSTR(hawk, HAWK_T(" "));
-				HAWK_ASSERT (((hawk_nde_return_t*)p)->val->next == HAWK_NULL);
+				HAWK_ASSERT(((hawk_nde_return_t*)p)->val->next == HAWK_NULL);
 
 				PRINT_EXPR(hawk, ((hawk_nde_return_t*)p)->val);
 				PUT_SRCSTR(hawk, HAWK_T(";"));
@@ -1225,7 +1227,7 @@ static int print_stmt (hawk_t* hawk, hawk_nde_t* p, int depth, int flags)
 				hawk_getkwname(hawk, (px->abort? HAWK_KWID_XABORT: HAWK_KWID_EXIT), &kw);
 				PUT_SRCSTRN(hawk, kw.ptr, kw.len);
 				PUT_SRCSTR(hawk, HAWK_T(" "));
-				HAWK_ASSERT (px->val->next == HAWK_NULL);
+				HAWK_ASSERT(px->val->next == HAWK_NULL);
 				PRINT_EXPR(hawk, px->val);
 				PUT_SRCSTR(hawk, HAWK_T(";"));
 			}
@@ -1494,8 +1496,8 @@ void hawk_clrpt (hawk_t* hawk, hawk_nde_t* tree)
 			case HAWK_NDE_EXP_BIN:
 			{
 				hawk_nde_exp_t* px = (hawk_nde_exp_t*)p;
-				HAWK_ASSERT (px->left->next == HAWK_NULL);
-				HAWK_ASSERT (px->right->next == HAWK_NULL);
+				HAWK_ASSERT(px->left->next == HAWK_NULL);
+				HAWK_ASSERT(px->right->next == HAWK_NULL);
 
 				hawk_clrpt(hawk, px->left);
 				hawk_clrpt(hawk, px->right);
@@ -1508,7 +1510,7 @@ void hawk_clrpt (hawk_t* hawk, hawk_nde_t* tree)
 			case HAWK_NDE_EXP_INCPST:
 			{
 				hawk_nde_exp_t* px = (hawk_nde_exp_t*)p;
-				HAWK_ASSERT (px->right == HAWK_NULL);
+				HAWK_ASSERT(px->right == HAWK_NULL);
 				hawk_clrpt(hawk, px->left);
 				hawk_freemem(hawk, p);
 				break;
@@ -1605,7 +1607,7 @@ void hawk_clrpt (hawk_t* hawk, hawk_nde_t* tree)
 			case HAWK_NDE_ARG:
 			{
 				hawk_nde_var_t* px = (hawk_nde_var_t*)p;
-				HAWK_ASSERT (px->idx == HAWK_NULL);
+				HAWK_ASSERT(px->idx == HAWK_NULL);
 				if (px->id.name.ptr) hawk_freemem(hawk, px->id.name.ptr);
 				hawk_freemem(hawk, p);
 				break;
@@ -1617,7 +1619,7 @@ void hawk_clrpt (hawk_t* hawk, hawk_nde_t* tree)
 			case HAWK_NDE_ARGIDX:
 			{
 				hawk_nde_var_t* px = (hawk_nde_var_t*)p;
-				HAWK_ASSERT (px->idx != HAWK_NULL);
+				HAWK_ASSERT(px->idx != HAWK_NULL);
 				hawk_clrpt(hawk, px->idx);
 				if (px->id.name.ptr) hawk_freemem(hawk, px->id.name.ptr);
 				hawk_freemem(hawk, p);
@@ -1678,7 +1680,7 @@ void hawk_clrpt (hawk_t* hawk, hawk_nde_t* tree)
 
 			default:
 			{
-				HAWK_ASSERT (!"should never happen - invalid node type");
+				HAWK_ASSERT(!"should never happen - invalid node type");
 				hawk_freemem(hawk, p);
 				break;
 			}