added some missing atomic macro checks

bin/hawk.c

@@ -372,7 +372,9 @@ struct opttab_t
 	const hawk_bch_t* desc;
 } opttab[] =
 {
+	/* the values must be present in the "lng" table in process_argv[] */
 	{ "blankconcat",  HAWK_BLANKCONCAT,    "enable concatenation by blanks" },
+	{ "buildbc",      HAWK_BUILDBC,        "enable byte-code building" },
 	{ "crlf",         HAWK_CRLF,           "use CRLF for a newline" },
 	{ "flexmap",      HAWK_FLEXMAP,        "allow a map to be assigned or returned" },
 	{ "implicit",     HAWK_IMPLICIT,       "allow undeclared variables" },
@@ -391,6 +393,7 @@ struct opttab_t
 	{ "striprecspc",  HAWK_STRIPRECSPC,    "strip spaces in splitting a record" },
 	{ "stripstrspc",  HAWK_STRIPSTRSPC,    "strip spaces in string-to-number conversion" },
 	{ "tolerant",     HAWK_TOLERANT,       "make more fault-tolerant" },
+	{ "xcall",        HAWK_XCALL,          "enable the extended call syntax" },
 	{ HAWK_NULL,      0,                   HAWK_NULL }
 };
 
@@ -450,6 +453,7 @@ static int process_argv (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_ar
 	static hawk_bcli_lng_t lng[] =
 	{
 		{ ":blankconcat",      '\0' },
+		{ ":buildbc",          '\0' },
 		{ ":crlf",             '\0' },
 		{ ":flexmap",          '\0' },
 		{ ":implicit",         '\0' },
@@ -468,6 +472,7 @@ static int process_argv (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_ar
 		{ ":striprecspc",      '\0' },
 		{ ":stripstrspc",      '\0' },
 		{ ":tolerant",         '\0' },
+		{ ":xcall",            '\0' },
 
 		{ ":call",             'c' },
 		{ ":file",             'f' },

bin/hawkgo.go

@@ -36,6 +36,11 @@ type Config struct {
 	data_out_files []string
 }
 
+type RtxEvent struct {
+	rtx *hawk.Rtx
+	added bool
+}
+
 func exit_with_error(msg string, err error) {
 	fmt.Fprintf(os.Stderr, "ERROR: %s - %s\n", msg, err.Error())
 	os.Exit(1)
@@ -144,7 +149,7 @@ wrong_usage:
 	return false
 }
 
-func run_script(h *hawk.Hawk, fs_idx int, data_idx int, cfg* Config, rtx_chan chan *hawk.Rtx, sig_chan chan os.Signal) error {
+func run_script(h *hawk.Hawk, fs_idx int, data_idx int, cfg* Config, rtx_chan chan RtxEvent, sig_chan chan os.Signal) error {
 	var rtx *hawk.Rtx
 	var err error
 
@@ -226,7 +231,7 @@ func run_script(h *hawk.Hawk, fs_idx int, data_idx int, cfg* Config, rtx_chan ch
 					signal.Notify(sig_chan, s)
 				}
 			})
-			rtx_chan <- rtx
+			rtx_chan <- RtxEvent{rtx: rtx, added: true}
 			retv, err = rtx.Call(cfg.call, args...)
 			for idx = 0; idx < count; idx++ {
 				// it's ok not to call Close() on args as rtx.Close() closes them automatically.
@@ -244,7 +249,7 @@ func run_script(h *hawk.Hawk, fs_idx int, data_idx int, cfg* Config, rtx_chan ch
 					signal.Notify(sig_chan, s)
 				}
 			})
-			rtx_chan <- rtx
+			rtx_chan <- RtxEvent{rtx: rtx, added: true}
 			//v, err = rtx.Loop()
 			retv, err = rtx.Exec(cfg.data_in_files)
 		}
@@ -272,17 +277,24 @@ func run_script(h *hawk.Hawk, fs_idx int, data_idx int, cfg* Config, rtx_chan ch
 
 	// let's not care about closing args or return values
 	// because rtx.Close() will close them automatically
-	if rtx != nil { rtx.Close() }
+	if rtx != nil {
+		rtx_chan <- RtxEvent{rtx: rtx, added: false}
+		rtx.Close()
+	}
 	return nil
 
 oops:
-	if rtx != nil { rtx.Close() }
+	if rtx != nil {
+		rtx_chan <- RtxEvent{rtx: rtx, added: false}
+		rtx.Close()
+	}
 	return err
 }
 
-func run_signal_handler(rtx_chan chan *hawk.Rtx, sig_chan chan os.Signal, wg *sync.WaitGroup) {
+func run_signal_handler(rtx_chan chan RtxEvent, sig_chan chan os.Signal, wg *sync.WaitGroup) {
 	var sig os.Signal
 	var rtx *hawk.Rtx
+	var ev RtxEvent
 	var rtx_bag map[*hawk.Rtx]struct{}
 
 	defer wg.Done()
@@ -293,14 +305,18 @@ func run_signal_handler(rtx_chan chan *hawk.Rtx, sig_chan chan os.Signal, wg *sy
 chan_loop:
 	for {
 		select {
-		case rtx = <-rtx_chan:
-			if rtx == nil {
+		case ev = <-rtx_chan:
+			if ev.rtx == nil {
 				// terminate the loop for the value of nil
 				break chan_loop
 			}
 
+			if ev.added {
 				// remember all the rtx object created for signal broadcasting
-			rtx_bag[rtx] = struct{}{}
+				rtx_bag[ev.rtx] = struct{}{}
+			} else {
+				delete(rtx_bag, ev.rtx)
+			}
 
 		case sig = <- sig_chan:
 			var signo syscall.Signal
@@ -320,7 +336,7 @@ func main() {
 	var h *hawk.Hawk
 	var cfg Config
 	var fs_idx int = -1
-	var rtx_chan chan *hawk.Rtx
+	var rtx_chan chan RtxEvent
 	var sig_chan chan os.Signal
 	var sig_wg sync.WaitGroup
 	var err error
@@ -390,7 +406,7 @@ func main() {
 		goto oops
 	}
 
-	rtx_chan = make(chan *hawk.Rtx, 10)
+	rtx_chan = make(chan RtxEvent, 10)
 	sig_chan = make(chan os.Signal, 5)
 	sig_wg.Add(1)
 	go run_signal_handler(rtx_chan, sig_chan, &sig_wg)
@@ -421,7 +437,7 @@ func main() {
 		}
 	}
 
-	rtx_chan <- nil // to terminate the signal handler
+	rtx_chan <- RtxEvent{ rtx: nil, added: false } // to terminate the signal handler
 	sig_wg.Wait()
 	h.Close()
 
@@ -434,7 +450,7 @@ func main() {
 oops:
 //	if rtx != nil { rtx.Close() }
 	if rtx_chan != nil {
-		rtx_chan <- nil
+		rtx_chan <- RtxEvent{rtx: nil, added: false}
 		sig_wg.Wait()
 	}
 	if h != nil { h.Close() }

hawk.go

@@ -706,9 +706,12 @@ func (rtx *Rtx) Loop() (*Val, error) {
 func (rtx *Rtx) Call(name string, args ...*Val) (*Val, error) {
 	var fun *C.hawk_fun_t
 	var val *C.hawk_val_t
+	var cv *C.hawk_bch_t
 	var nargs int
 
-	fun = C.hawk_rtx_findfunwithbcstr(rtx.c, C.CString(name))
+	cv = C.CString(name)
+	fun = C.hawk_rtx_findfunwithbcstr(rtx.c, cv)
+	C.free(unsafe.Pointer(cv))
 	if fun == nil { return nil, rtx.make_errinfo() }
 
 	nargs = len(args)
@@ -968,8 +971,8 @@ func (hawk *Hawk) get_errmsg() string {
 func (hawk *Hawk) set_errmsg(num C.hawk_errnum_t, msg string) {
 	var ptr *C.char
 	ptr = C.CString(msg)
-	defer C.free(unsafe.Pointer(ptr))
 	C.set_errmsg(hawk.c, num, ptr)
+	C.free(unsafe.Pointer(ptr))
 }
 
 func (rtx *Rtx) get_errmsg() string {
@@ -979,8 +982,8 @@ func (rtx *Rtx) get_errmsg() string {
 func (rtx *Rtx) set_errmsg(num C.hawk_errnum_t, msg string) {
 	var ptr *C.char
 	ptr = C.CString(msg)
-	defer C.free(unsafe.Pointer(ptr))
 	C.set_rtx_errmsg(rtx.c, num, ptr)
+	C.free(unsafe.Pointer(ptr))
 }
 
 // -----------------------------------------------------------
@@ -1213,12 +1216,13 @@ func (val *Val) SetArrayField(index int, v *Val) error {
 
 func (val *Val) SetArrayFieldWithInt(index int, v int) error {
 	var vv *C.hawk_val_t
+	var ww *C.hawk_val_t
 	vv = C.hawk_rtx_makeintval(val.rtx.c, C.hawk_int_t(v))
 	if vv == nil { return val.rtx.make_errinfo() }
 	C.hawk_rtx_refupval(val.rtx.c, vv)
-	vv = C.hawk_rtx_setarrvalfld(val.rtx.c, val.c, C.hawk_ooi_t(index), vv)
+	ww = C.hawk_rtx_setarrvalfld(val.rtx.c, val.c, C.hawk_ooi_t(index), vv)
 	C.hawk_rtx_refdownval(val.rtx.c, vv)
-	if vv == nil { return val.rtx.make_errinfo() }
+	if ww == nil { return val.rtx.make_errinfo() }
 	return nil
 }
 
@@ -1291,34 +1295,37 @@ func (val *Val) SetMapField(key string, v *Val) error {
 func (val *Val) SetMapFieldWithInt(key string, v int) error {
 	var kk []C.hawk_uch_t
 	var vv *C.hawk_val_t
+	var ww *C.hawk_val_t
 
 	kk = string_to_uchars(key)
 	vv = C.hawk_rtx_makeintval(val.rtx.c, C.hawk_int_t(v))
 	if vv == nil { return val.rtx.make_errinfo() }
 	C.hawk_rtx_refupval(val.rtx.c, vv)
-	vv = C.hawk_rtx_setmapvalfld(val.rtx.c, val.c, &kk[0], C.hawk_oow_t(len(kk)), vv)
+	ww = C.hawk_rtx_setmapvalfld(val.rtx.c, val.c, &kk[0], C.hawk_oow_t(len(kk)), vv)
 	C.hawk_rtx_refdownval(val.rtx.c, vv)
-	if vv == nil { return val.rtx.make_errinfo() }
+	if ww == nil { return val.rtx.make_errinfo() }
 	return nil
 }
 
 func (val *Val) SetMapFieldWithFlt(key string, v float64) error {
 	var kk []C.hawk_uch_t
 	var vv *C.hawk_val_t
+	var ww *C.hawk_val_t
 
 	kk = string_to_uchars(key)
 	vv = C.make_flt_val(val.rtx.c, C.double(v))
 	if vv == nil { return val.rtx.make_errinfo() }
 	C.hawk_rtx_refupval(val.rtx.c, vv)
-	vv = C.hawk_rtx_setmapvalfld(val.rtx.c, val.c, &kk[0], C.hawk_oow_t(len(kk)), vv)
+	ww = C.hawk_rtx_setmapvalfld(val.rtx.c, val.c, &kk[0], C.hawk_oow_t(len(kk)), vv)
 	C.hawk_rtx_refdownval(val.rtx.c, vv)
-	if vv == nil { return val.rtx.make_errinfo() }
+	if ww == nil { return val.rtx.make_errinfo() }
 	return nil
 }
 
 func (val *Val) SetMapFieldWithStr(key string, v string) error {
 	var kk []C.hawk_uch_t
 	var vv *C.hawk_val_t
+	var ww *C.hawk_val_t
 	var cv *C.hawk_bch_t
 
 	kk = string_to_uchars(key)
@@ -1327,9 +1334,9 @@ func (val *Val) SetMapFieldWithStr(key string, v string) error {
 	C.free(unsafe.Pointer(cv))
 	if vv == nil { return val.rtx.make_errinfo() }
 	C.hawk_rtx_refupval(val.rtx.c, vv)
-	vv = C.hawk_rtx_setmapvalfld(val.rtx.c, val.c, &kk[0], C.hawk_oow_t(len(kk)), vv)
+	ww = C.hawk_rtx_setmapvalfld(val.rtx.c, val.c, &kk[0], C.hawk_oow_t(len(kk)), vv)
 	C.hawk_rtx_refdownval(val.rtx.c, vv)
-	if vv == nil { return val.rtx.make_errinfo() }
+	if ww == nil { return val.rtx.make_errinfo() }
 	return nil
 }
 

lib/hawk-cmn.h

@@ -1314,9 +1314,21 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 	#if __has_builtin(__atomic_exchange_n)
 		#define HAWK_HAVE_ATOMIC_EXCHANGE_N
 	#endif
+	#if __has_builtin(__atomic_fetch_add)
+		#define HAWK_HAVE_ATOMIC_FETCH_ADD
+	#endif
+	#if __has_builtin(__atomic_fetch_and)
+		#define HAWK_HAVE_ATOMIC_FETCH_AND
+	#endif
 	#if __has_builtin(__atomic_fetch_or)
 		#define HAWK_HAVE_ATOMIC_FETCH_OR
 	#endif
+	#if __has_builtin(__atomic_fetch_sub)
+		#define HAWK_HAVE_ATOMIC_FETCH_SUB
+	#endif
+	#if __has_builtin(__atomic_fetch_xor)
+		#define HAWK_HAVE_ATOMIC_FETCH_XOR
+	#endif
 	#if __has_builtin(__atomic_load_n)
 		#define HAWK_HAVE_ATOMIC_LOAD_N
 	#endif
@@ -1366,9 +1378,21 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 		#define HAWK_HAVE_BUILTIN_EXPECT
 	#endif
 
+	#if __has_builtin(__sync_fetch_and_add)
+		#define HAWK_HAVE_SYNC_FETCH_AND_ADD
+	#endif
+	#if __has_builtin(__sync_fetch_and_and)
+		#define HAWK_HAVE_SYNC_FETCH_AND_AND
+	#endif
 	#if __has_builtin(__sync_fetch_and_or)
 		#define HAWK_HAVE_SYNC_FETCH_AND_OR
 	#endif
+	#if __has_builtin(__sync_fetch_and_sub)
+		#define HAWK_HAVE_SYNC_FETCH_AND_SUB
+	#endif
+	#if __has_builtin(__sync_fetch_and_xor)
+		#define HAWK_HAVE_SYNC_FETCH_AND_XOR
+	#endif
 	#if __has_builtin(__sync_lock_test_and_set)
 		#define HAWK_HAVE_SYNC_LOCK_TEST_AND_SET
 	#endif
@@ -1400,7 +1424,11 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 #elif defined(__GNUC__) && defined(__GNUC_MINOR__)
 
 	#if (__GNUC__ >= 4)
+		#define HAWK_HAVE_SYNC_FETCH_AND_ADD
+		#define HAWK_HAVE_SYNC_FETCH_AND_AND
 		#define HAWK_HAVE_SYNC_FETCH_AND_OR
+		#define HAWK_HAVE_SYNC_FETCH_AND_SUB
+		#define HAWK_HAVE_SYNC_FETCH_AND_XOR
 		#define HAWK_HAVE_SYNC_LOCK_TEST_AND_SET
 		#define HAWK_HAVE_SYNC_LOCK_RELEASE
 		#define HAWK_HAVE_SYNC_SYNCHRONIZE
@@ -1435,7 +1463,11 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 	#endif
 
 	#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
+		#define HAWK_HAVE_ATOMIC_FETCH_ADD
+		#define HAWK_HAVE_ATOMIC_FETCH_AND
 		#define HAWK_HAVE_ATOMIC_FETCH_OR
+		#define HAWK_HAVE_ATOMIC_FETCH_SUB
+		#define HAWK_HAVE_ATOMIC_FETCH_XOR
 	#endif
 
 	#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
@@ -1472,7 +1504,7 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 
 #if defined(HAWK_HAVE_ATOMIC_FETCH_ADD)
 #	define HAWK_ATOMIC_FETCH_ADD(ptr,val,mo) __atomic_fetch_add((ptr),(val),(mo))
-#elif defined(HAWK_HAVE_SYNC_FETCH_AND_AND)
+#elif defined(HAWK_HAVE_SYNC_FETCH_AND_ADD)
 #	define HAWK_ATOMIC_FETCH_ADD(ptr,val,mo) __sync_fetch_and_add((ptr),(val))
 #endif
 
@@ -1490,7 +1522,7 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 
 #if defined(HAWK_HAVE_ATOMIC_FETCH_SUB)
 #	define HAWK_ATOMIC_FETCH_SUB(ptr,val,mo) __atomic_fetch_sub((ptr),(val),(mo))
-#elif defined(HAWK_HAVE_SYNC_FETCH_AND_AND)
+#elif defined(HAWK_HAVE_SYNC_FETCH_AND_SUB)
 #	define HAWK_ATOMIC_FETCH_SUB(ptr,val,mo) __sync_fetch_and_sub((ptr),(val))
 #endif
 

lib/hawk-prv.h

@@ -192,6 +192,81 @@ typedef struct hawk_tree_t hawk_tree_t;
 
 #endif
 
+enum hawk_fbc_opcode_t
+{
+	HAWK_FBC_OP_NOP = 0,
+	HAWK_FBC_OP_LOAD_CONST_INT,
+	HAWK_FBC_OP_LOAD_CONST_NIL,
+	HAWK_FBC_OP_LOAD_CONST_TRUE,
+	HAWK_FBC_OP_LOAD_CONST_FALSE,
+	HAWK_FBC_OP_LOAD_GBL,
+	HAWK_FBC_OP_LOAD_LCL,
+	HAWK_FBC_OP_LOAD_ARG,
+	HAWK_FBC_OP_STORE_GBL,
+	HAWK_FBC_OP_STORE_LCL,
+	HAWK_FBC_OP_STORE_ARG,
+	HAWK_FBC_OP_STORE_POP_GBL,
+	HAWK_FBC_OP_STORE_POP_LCL,
+	HAWK_FBC_OP_STORE_POP_ARG,
+	HAWK_FBC_OP_ADD,
+	HAWK_FBC_OP_SUB,
+	HAWK_FBC_OP_MUL,
+	HAWK_FBC_OP_DIV,
+	HAWK_FBC_OP_IDIV,
+	HAWK_FBC_OP_MOD,
+	HAWK_FBC_OP_EXP,
+	HAWK_FBC_OP_CONCAT,
+	HAWK_FBC_OP_RSHIFT,
+	HAWK_FBC_OP_LSHIFT,
+	HAWK_FBC_OP_BAND,
+	HAWK_FBC_OP_BXOR,
+	HAWK_FBC_OP_BOR,
+
+	HAWK_FBC_OP_TEQ,
+	HAWK_FBC_OP_TNE,
+	HAWK_FBC_OP_EQ,
+	HAWK_FBC_OP_NE,
+	HAWK_FBC_OP_GT,
+	HAWK_FBC_OP_GE,
+	HAWK_FBC_OP_LT,
+	HAWK_FBC_OP_LE,
+
+	HAWK_FBC_OP_NEG,
+	HAWK_FBC_OP_SWAP,
+	HAWK_FBC_OP_DUP,
+	HAWK_FBC_OP_JMP,
+	HAWK_FBC_OP_JZ,
+	HAWK_FBC_OP_CALL,
+	HAWK_FBC_OP_RET,
+	HAWK_FBC_OP_POP,
+	HAWK_FBC_OP_RUN_AST_STMT,
+	HAWK_FBC_OP_RET_AST_EXPR,
+	HAWK_FBC_OP_RET_NIL
+};
+typedef enum hawk_fbc_opcode_t hawk_fbc_opcode_t;
+
+typedef struct hawk_fbc_ins_t hawk_fbc_ins_t;
+struct hawk_fbc_ins_t
+{
+	hawk_fbc_opcode_t opcode;
+	union
+	{
+		hawk_nde_t* nde;
+		hawk_int_t iv;
+		hawk_oow_t idx;
+	} u;
+};
+
+struct hawk_fbc_t
+{
+	hawk_fbc_ins_t* code;
+	hawk_oow_t len;
+	hawk_oow_t capa;
+
+	hawk_oow_t nargs;
+	hawk_oow_t nlocals;
+	hawk_oow_t stack_max;
+};
 
 struct hawk_tree_t
 {
@@ -425,6 +500,14 @@ struct hawk_var_xinfo_t
 	hawk_loc_t loc;
 };
 
+typedef struct hawk_fbc_eval_stack_t hawk_fbc_eval_stack_t;
+struct hawk_fbc_eval_stack_t
+{
+	hawk_val_t** ptr;
+	hawk_oow_t len;
+	hawk_oow_t capa;
+};
+
 struct hawk_rtx_t
 {
 	HAWK_RTX_HDR;
@@ -435,6 +518,9 @@ struct hawk_rtx_t
 	hawk_oow_t stack_top;
 	hawk_oow_t stack_base;
 	hawk_oow_t stack_limit;
+
+	hawk_fbc_eval_stack_t fbc_eval_stack;
+
 	int exit_level;
 	int init_called;
 

lib/hawk.c

@@ -24,6 +24,12 @@
 
 #include "hawk-prv.h"
 
+static void free_funbc (hawk_t* hawk, hawk_fbc_t* bc)
+{
+	if (bc->code) hawk_freemem(hawk, bc->code);
+	hawk_freemem(hawk, bc);
+}
+
 static void free_fun (hawk_htb_t* map, void* vptr, hawk_oow_t vlen)
 {
 	hawk_t* hawk = *(hawk_t**)hawk_htb_getxtn(map);
@@ -33,6 +39,7 @@ static void free_fun (hawk_htb_t* map, void* vptr, hawk_oow_t vlen)
 	/*hawk_freemem(hawk, f->name);*/
 
 	if (f->argspec) hawk_freemem(hawk, f->argspec);
+	if (f->bc) free_funbc(hawk, f->bc);
 	hawk_clrpt(hawk, f->body);
 	hawk_freemem(hawk, f);
 }
@@ -43,6 +50,7 @@ static void free_ifun (hawk_arr_t* arr, void* dptr, hawk_oow_t dlen)
 	hawk_fun_t* f = (hawk_fun_t*)dptr;
 
 	if (f->argspec) hawk_freemem(hawk, f->argspec);
+	if (f->bc) free_funbc(hawk, f->bc);
 	hawk_clrpt(hawk, f->body);
 	hawk_freemem(hawk, f);
 }
@@ -459,7 +467,15 @@ void hawk_clear (hawk_t* hawk)
 	hawk->parse.depth.loop = 0;
 	hawk->parse.depth.expr = 0;
 	hawk->parse.depth.incl = 0;
-	hawk->parse.pragma.trait = (hawk->opt.trait & (HAWK_IMPLICIT | HAWK_MULTILINESTR | HAWK_PEDANTIC | HAWK_RWPIPE | HAWK_PIPECLOEXEC | HAWK_STRIPRECSPC | HAWK_STRIPSTRSPC)); /* implicit on if you didn't mask it off in hawk->opt.trait with hawk_setopt */
+
+	/* hawk initializes hawk->opt.trait to HAWK_MODERN.
+	 * the options beloning to HAWK_MODERN are on if you don't
+	 * mask them off with hawk_setopt(). the listed options
+	 * here affected the compile-time pragma. */
+	hawk->parse.pragma.trait = hawk->opt.trait &
+		(HAWK_BUILDBC | HAWK_IMPLICIT | HAWK_MULTILINESTR | HAWK_PEDANTIC | HAWK_RWPIPE |
+		 HAWK_PIPECLOEXEC | HAWK_STRIPRECSPC | HAWK_STRIPSTRSPC | HAWK_XCALL);
+
 	hawk->parse.pragma.rtx_stack_limit = 0;
 	hawk->parse.pragma.entry[0] = '\0';
 

lib/hawk.h

@@ -524,6 +524,8 @@ struct hawk_nde_t
  * The hawk_fun_t type defines a structure to maintain functions
  * defined with the keyword 'function'.
  */
+typedef struct hawk_fbc_t hawk_fbc_t;
+
 struct hawk_fun_t
 {
 	hawk_oocs_t     name;
@@ -532,6 +534,7 @@ struct hawk_fun_t
 	hawk_oow_t      argspeclen; /* the length of argspec. it can be different from nargs if there are call-by-value parameters after the last call-by-reference parameter or variadic arguments are supported */
 	int             variadic;
 	hawk_nde_t*     body;
+	hawk_fbc_t*     bc; /* function bytecode */
 };
 typedef struct hawk_fun_t hawk_fun_t;
 
@@ -1443,6 +1446,12 @@ enum hawk_trait_t
 	 */
 	HAWK_XCALL = (1 << 21),
 
+	/**
+	 * enables experimental function-body bytecode build/run path
+	 * for selected functions.
+	 */
+	HAWK_BUILDBC = (1 << 22),
+
 
 	/**
 	 * makes #hawk_t to behave compatibly with classical AWK

lib/misc.c

@@ -178,7 +178,7 @@ int hawk_rtx_matchvalwithucs (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_ucs_t
 
 		x = ignorecase? hawk_rtx_buildrex(rtx, tmp.ptr, tmp.len, HAWK_NULL, &code):
 		                hawk_rtx_buildrex(rtx, tmp.ptr, tmp.len, &code, HAWK_NULL);
-		hawk_rtx_freevaloocstr (rtx, val, tmp.ptr);
+		hawk_rtx_freevaloocstr(rtx, val, tmp.ptr);
 		if (x <= -1) return -1;
 	}
 
@@ -224,7 +224,7 @@ int hawk_rtx_matchvalwithbcs (hawk_rtx_t* rtx, hawk_val_t* val, const hawk_bcs_t
 
 		x = ignorecase? hawk_rtx_buildrex(rtx, tmp.ptr, tmp.len, HAWK_NULL, &code):
 		                hawk_rtx_buildrex(rtx, tmp.ptr, tmp.len, &code, HAWK_NULL);
-		hawk_rtx_freevaloocstr (rtx, val, tmp.ptr);
+		hawk_rtx_freevaloocstr(rtx, val, tmp.ptr);
 		if (x <= -1) return -1;
 	}
 

lib/mod-hawk.c

@@ -57,7 +57,7 @@ static hawk_oow_t push_args_from_stack (hawk_rtx_t* rtx, hawk_nde_fncall_t* call
 
 	if (HAWK_RTX_STACK_AVAIL(rtx) < pasf->end_index - pasf->start_index + 1)
 	{
-		hawk_rtx_seterrnum (rtx, &call->loc, HAWK_ESTACK);
+		hawk_rtx_seterrnum(rtx, &call->loc, HAWK_ESTACK);
 		return (hawk_oow_t)-1;
 	}
 
@@ -86,13 +86,13 @@ static hawk_oow_t push_args_from_stack (hawk_rtx_t* rtx, hawk_nde_fncall_t* call
 		{
 			if (spec == 'r') /* 'R' allows a normal value. so only checking 'r' here */
 			{
-				hawk_rtx_seterrnum (rtx, &call->loc, HAWK_ENOTREF);
+				hawk_rtx_seterrnum(rtx, &call->loc, HAWK_ENOTREF);
 				return (hawk_oow_t)-1;
 			}
 		}
 
-		HAWK_RTX_STACK_PUSH (rtx, v);
-		hawk_rtx_refupval (rtx, v);
+		HAWK_RTX_STACK_PUSH(rtx, v);
+		hawk_rtx_refupval(rtx, v);
 	}
 
 	return pasf->end_index - pasf->start_index + 1;
@@ -116,7 +116,7 @@ static int fnc_call (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	{
 		if (f_nargs > fun->nargs)
 		{
-			hawk_rtx_seterrnum (rtx, HAWK_NULL, HAWK_EARGTM);
+			hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EARGTM);
 			return -1; /* hard failure */
 		}
 
@@ -149,7 +149,7 @@ static int fnc_call (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 
 		if (f_nargs < fnc.spec.arg.min  || f_nargs > fnc.spec.arg.max)
 		{
-			hawk_rtx_seterrnum (rtx, HAWK_NULL, HAWK_EARGTM);
+			hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EARGTM);
 			return -1;
 		}
 
@@ -341,12 +341,12 @@ static int fnc_gcrefs (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 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);
+	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);
+	return hawk_fnc_length(rtx, fi, 0);
 }
 /* -------------------------------------------------------------------------- */
 

lib/mod-math.c

@@ -103,10 +103,10 @@ static int fnc_math_1 (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, hawk_math1_t
 	n = hawk_rtx_valtoflt(rtx, a0, &rv);
 	if (n <= -1) return -1;
 
-	r = hawk_rtx_makefltval (rtx, f(hawk_rtx_gethawk(rtx), rv));
+	r = hawk_rtx_makefltval(rtx, f(hawk_rtx_gethawk(rtx), rv));
 	if (r == HAWK_NULL) return -1;
 
-	hawk_rtx_setretval (rtx, r);
+	hawk_rtx_setretval(rtx, r);
 	return 0;
 }
 
@@ -127,13 +127,13 @@ static int fnc_math_2 (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, hawk_math2_t
 	n = hawk_rtx_valtoflt(rtx, a0, &rv0);
 	if (n <= -1) return -1;
 
-	n = hawk_rtx_valtoflt (rtx, a1, &rv1);
+	n = hawk_rtx_valtoflt(rtx, a1, &rv1);
 	if (n <= -1) return -1;
 
-	r = hawk_rtx_makefltval (rtx, f(hawk_rtx_gethawk(rtx), rv0, rv1));
+	r = hawk_rtx_makefltval(rtx, f(hawk_rtx_gethawk(rtx), rv0, rv1));
 	if (r == HAWK_NULL) return -1;
 
-	hawk_rtx_setretval (rtx, r);
+	hawk_rtx_setretval(rtx, r);
 	return 0;
 }
 
@@ -453,42 +453,42 @@ static hawk_flt_t math_sqrt (hawk_t* hawk, hawk_flt_t x)
 
 static int fnc_ceil (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_ceil);
+	return fnc_math_1(rtx, fi, math_ceil);
 }
 
 static int fnc_floor (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_floor);
+	return fnc_math_1(rtx, fi, math_floor);
 }
 
 static int fnc_round (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_round);
+	return fnc_math_1(rtx, fi, math_round);
 }
 
 static int fnc_sinh (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_sinh);
+	return fnc_math_1(rtx, fi, math_sinh);
 }
 
 static int fnc_cosh (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_cosh);
+	return fnc_math_1(rtx, fi, math_cosh);
 }
 
 static int fnc_tanh (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_tanh);
+	return fnc_math_1(rtx, fi, math_tanh);
 }
 
 static int fnc_asin (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_asin);
+	return fnc_math_1(rtx, fi, math_asin);
 }
 
 static int fnc_acos (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_acos);
+	return fnc_math_1(rtx, fi, math_acos);
 }
 
 
@@ -496,52 +496,52 @@ static int fnc_acos (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 
 static int fnc_sin (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_sin);
+	return fnc_math_1(rtx, fi, math_sin);
 }
 
 static int fnc_cos (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_cos);
+	return fnc_math_1(rtx, fi, math_cos);
 }
 
 static int fnc_tan (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_tan);
+	return fnc_math_1(rtx, fi, math_tan);
 }
 
 static int fnc_atan (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_atan);
+	return fnc_math_1(rtx, fi, math_atan);
 }
 
 static int fnc_atan2 (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_2 (rtx, fi, math_atan2);
+	return fnc_math_2(rtx, fi, math_atan2);
 }
 
 static int fnc_log (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_log);
+	return fnc_math_1(rtx, fi, math_log);
 }
 
 static int fnc_log2 (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_log2);
+	return fnc_math_1(rtx, fi, math_log2);
 }
 
 static int fnc_log10 (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_log10);
+	return fnc_math_1(rtx, fi, math_log10);
 }
 
 static int fnc_exp (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_exp);
+	return fnc_math_1(rtx, fi, math_exp);
 }
 
 static int fnc_sqrt (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
-	return fnc_math_1 (rtx, fi, math_sqrt);
+	return fnc_math_1(rtx, fi, math_sqrt);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -566,7 +566,7 @@ static int fnc_rand (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	r = hawk_rtx_makefltval(rtx, (hawk_flt_t)randv / RANDV_MAX);
 	if (r == HAWK_NULL) return -1;
 
-	hawk_rtx_setretval (rtx, r);
+	hawk_rtx_setretval(rtx, r);
 	return 0;
 #undef RANDV_MAX
 }
@@ -614,10 +614,10 @@ static int fnc_srand (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	#endif
 	}
 
-	r = hawk_rtx_makeintval (rtx, prev);
+	r = hawk_rtx_makeintval(rtx, prev);
 	if (r == HAWK_NULL) return -1;
 
-	hawk_rtx_setretval (rtx, r);
+	hawk_rtx_setretval(rtx, r);
 	return 0;
 }
 

lib/mod-str.c

@@ -53,7 +53,7 @@ static int fnc_normspace (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			if (HAWK_UNLIKELY(!str0)) return -1;
 			len0 = hawk_compact_bchars(str0, len0);
 			retv = hawk_rtx_makembsvalwithbchars(rtx, str0, len0);
-			hawk_rtx_freemem (rtx, str0);
+			hawk_rtx_freemem(rtx, str0);
 			break;
 		}
 
@@ -66,7 +66,7 @@ static int fnc_normspace (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			if (HAWK_UNLIKELY(!str0)) return -1;
 			len0 = hawk_compact_oochars(str0, len0);
 			retv = hawk_rtx_makestrvalwithoochars(rtx, str0, len0);
-			hawk_rtx_freemem (rtx, str0);
+			hawk_rtx_freemem(rtx, str0);
 		}
 	}
 
@@ -180,7 +180,7 @@ static int is_class (hawk_rtx_t* rtx, hawk_ooch_prop_t ctype)
 				while (len0 > 0);
 			}
 
-			hawk_rtx_freevalbcstr (rtx, a0, str0);
+			hawk_rtx_freevalbcstr(rtx, a0, str0);
 			break;
 		}
 
@@ -207,12 +207,12 @@ static int is_class (hawk_rtx_t* rtx, hawk_ooch_prop_t ctype)
 				}
 				while (len0 > 0);
 			}
-			hawk_rtx_freevaloocstr (rtx, a0, str0);
+			hawk_rtx_freevaloocstr(rtx, a0, str0);
 			break;
 		}
 	}
 
-	a0 = hawk_rtx_makeintval (rtx, tmp);
+	a0 = hawk_rtx_makeintval(rtx, tmp);
 	if (HAWK_UNLIKELY(!a0)) return -1;
 
 	hawk_rtx_setretval(rtx, a0);
@@ -318,7 +318,7 @@ static int fnc_frombcharcode (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			a0 = hawk_rtx_getarg(rtx, i);
 			if (hawk_rtx_valtoint(rtx, a0, &cc) <= -1)
 			{
-				hawk_rtx_freeval (rtx, retv, 0);
+				hawk_rtx_freeval(rtx, retv, 0);
 				return -1;
 			}
 
@@ -369,7 +369,7 @@ static int fnc_fromcharcode (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			a0 = hawk_rtx_getarg(rtx, i);
 			if (hawk_rtx_valtoint(rtx, a0, &cc) <= -1)
 			{
-				hawk_rtx_freeval (rtx, retv, 0);
+				hawk_rtx_freeval(rtx, retv, 0);
 				return -1;
 			}
 
@@ -474,7 +474,7 @@ static int fnc_frommbs (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 		/* if encoding name is an empty string, hawk_findcmgr() returns the default cmgr.
 		 * i don't want that behavior. */
 		cmgr = (enc.len > 0 && enc.len == hawk_count_oocstr(enc.ptr))? hawk_get_cmgr_by_name(enc.ptr): HAWK_NULL;
-		hawk_rtx_freevaloocstr (rtx, a1, enc.ptr);
+		hawk_rtx_freevaloocstr(rtx, a1, enc.ptr);
 
 		if (!cmgr)
 		{
@@ -497,7 +497,7 @@ static int fnc_frommbs (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			str.ptr = hawk_rtx_getvaloocstrwithcmgr(rtx, a0, &str.len, cmgr);
 			if (!str.ptr) return -1;
 			r = hawk_rtx_makestrvalwithoocs(rtx, &str);
-			hawk_rtx_freevaloocstr (rtx, a0, str.ptr);
+			hawk_rtx_freevaloocstr(rtx, a0, str.ptr);
 			if (!r) return -1;
 			break;
 		}
@@ -530,7 +530,7 @@ static int fnc_tombs (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 		/* if encoding name is an empty string, hawk_findcmgr() returns the default cmgr.
 		 * i don't want that behavior. */
 		cmgr = (enc.len > 0 && enc.len == hawk_count_oocstr(enc.ptr))? hawk_get_cmgr_by_name(enc.ptr): HAWK_NULL;
-		hawk_rtx_freevaloocstr (rtx, a1, enc.ptr);
+		hawk_rtx_freevaloocstr(rtx, a1, enc.ptr);
 
 		if (!cmgr)
 		{
@@ -564,7 +564,7 @@ static int fnc_tombs (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			str.ptr = hawk_rtx_getvalbcstrwithcmgr(rtx, a0, &str.len, cmgr);
 			if (HAWK_UNLIKELY(!str.ptr)) return -1;
 			r = hawk_rtx_makembsvalwithbcs(rtx, &str);
-			hawk_rtx_freevalbcstr (rtx, a0, str.ptr);
+			hawk_rtx_freevalbcstr(rtx, a0, str.ptr);
 			if (HAWK_UNLIKELY(!r)) return -1;
 			break;
 		}
@@ -1101,7 +1101,7 @@ static int fnc_subchar (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			else
 				r = hawk_rtx_makenilval(rtx);
 
-			hawk_rtx_freevalbcstr (rtx, a0, str);
+			hawk_rtx_freevalbcstr(rtx, a0, str);
 			break;
 		}
 
@@ -1118,7 +1118,7 @@ static int fnc_subchar (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			else
 				r = hawk_rtx_makenilval(rtx);
 
-			hawk_rtx_freevaloocstr (rtx, a0, str);
+			hawk_rtx_freevaloocstr(rtx, a0, str);
 			break;
 		}
 	}

lib/rec.c

@@ -60,14 +60,14 @@ int hawk_rtx_setrec (hawk_rtx_t* rtx, hawk_oow_t idx, const hawk_oocs_t* str, in
 		if (HAWK_UNLIKELY(!v)) goto oops;
 	}
 
-	if (HAWK_RTX_GETVALTYPE(rtx, rtx->inrec.d0) != HAWK_VAL_NIL) hawk_rtx_refdownval (rtx, rtx->inrec.d0);
+	if (HAWK_RTX_GETVALTYPE(rtx, rtx->inrec.d0) != HAWK_VAL_NIL) hawk_rtx_refdownval(rtx, rtx->inrec.d0);
 	rtx->inrec.d0 = v;
-	hawk_rtx_refupval (rtx, v);
+	hawk_rtx_refupval(rtx, v);
 
 	return 0;
 
 oops:
-	hawk_rtx_clrrec (rtx, 0);
+	hawk_rtx_clrrec(rtx, 0);
 	return -1;
 }
 
@@ -92,7 +92,7 @@ static int merge_fields (hawk_rtx_t* rtx)
 		if (HAWK_UNLIKELY(!vp)) return -1;
 
 		vl = hawk_ooecs_ncat(&rtx->inrec.line, vp, vl);
-		hawk_rtx_freevaloocstr (rtx, rtx->inrec.flds[i].val, vp);
+		hawk_rtx_freevaloocstr(rtx, rtx->inrec.flds[i].val, vp);
 
 		if (HAWK_UNLIKELY(vl == (hawk_oow_t)-1)) return -1;
 	}
@@ -117,7 +117,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 
 	/* get FS */
 	fs = hawk_rtx_getgbl(rtx, HAWK_GBL_FS);
-	fsvtype = HAWK_RTX_GETVALTYPE (rtx, fs);
+	fsvtype = HAWK_RTX_GETVALTYPE(rtx, fs);
 	if (fsvtype == HAWK_VAL_NIL)
 	{
 		fs_ptr = HAWK_T(" ");
@@ -142,7 +142,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 	{
 		if (hawk_ooecs_ncpy(&rtx->inrec.linew, HAWK_OOECS_PTR(&rtx->inrec.line), HAWK_OOECS_LEN(&rtx->inrec.line)) == (hawk_oow_t)-1)
 		{
-			if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+			if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 			return -1;
 		}
 
@@ -165,7 +165,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 		switch (how)
 		{
 			case 0:
-				p = hawk_rtx_tokoocharswithoochars (rtx, p, len, fs_ptr, fs_len, &tok);
+				p = hawk_rtx_tokoocharswithoochars(rtx, p, len, fs_ptr, fs_len, &tok);
 				break;
 
 			case 1:
@@ -181,7 +181,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 				);
 				if (p == HAWK_NULL && hawk_rtx_geterrnum(rtx) != HAWK_ENOERR)
 				{
-					if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+					if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 					return -1;
 				}
 		}
@@ -190,7 +190,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 		{
 			/* there are no fields. it can just return here
 			 * as hawk_rtx_clrrec has been called before this */
-			if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+			if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 			return 0;
 		}
 
@@ -206,11 +206,11 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 		void* tmp = hawk_rtx_allocmem(rtx, HAWK_SIZEOF(*rtx->inrec.flds) * nflds);
 		if (HAWK_UNLIKELY(!tmp))
 		{
-			if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+			if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 			return -1;
 		}
 
-		if (rtx->inrec.flds) hawk_rtx_freemem (rtx, rtx->inrec.flds);
+		if (rtx->inrec.flds) hawk_rtx_freemem(rtx, rtx->inrec.flds);
 		rtx->inrec.flds = tmp;
 		rtx->inrec.maxflds = nflds;
 	}
@@ -220,7 +220,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 	{
 		if (hawk_ooecs_ncpy(&rtx->inrec.linew, HAWK_OOECS_PTR(&rtx->inrec.line), HAWK_OOECS_LEN(&rtx->inrec.line)) == (hawk_oow_t)-1)
 		{
-			if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+			if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 			return -1;
 		}
 		px = HAWK_OOECS_PTR(&rtx->inrec.linew):
@@ -259,7 +259,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 				);
 				if (p == HAWK_NULL && hawk_rtx_geterrnum(rtx) != HAWK_ENOERR)
 				{
-					if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+					if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 					return -1;
 				}
 		}
@@ -268,7 +268,7 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 		{
 			/* there are no fields. it can just return here
 			 * as hawk_rtx_clrrec has been called before this */
-			if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+			if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 			return 0;
 		}
 #endif
@@ -286,14 +286,14 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 			tmp = hawk_rtx_allocmem(rtx, HAWK_SIZEOF(*rtx->inrec.flds) * nflds);
 			if (tmp == HAWK_NULL)
 			{
-				if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+				if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 				return -1;
 			}
 
 			if (rtx->inrec.flds != HAWK_NULL)
 			{
 				HAWK_MEMCPY (tmp, rtx->inrec.flds, HAWK_SIZEOF(*rtx->inrec.flds) * rtx->inrec.nflds);
-				hawk_rtx_freemem (rtx, rtx->inrec.flds);
+				hawk_rtx_freemem(rtx, rtx->inrec.flds);
 			}
 
 			rtx->inrec.flds = tmp;
@@ -309,29 +309,29 @@ static int split_record (hawk_rtx_t* rtx, int prefer_number)
 			               hawk_rtx_makestrvalwithoochars(rtx, tok.ptr, tok.len);
 		if (HAWK_UNLIKELY(!rtx->inrec.flds[rtx->inrec.nflds].val))
 		{
-			if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+			if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 			return -1;
 		}
 
-		hawk_rtx_refupval (rtx, rtx->inrec.flds[rtx->inrec.nflds].val);
+		hawk_rtx_refupval(rtx, rtx->inrec.flds[rtx->inrec.nflds].val);
 		rtx->inrec.nflds++;
 
 		len = HAWK_OOECS_LEN(&rtx->inrec.line) - (p - px);
 	}
 
-	if (fs_free) hawk_rtx_freemem (rtx, fs_free);
+	if (fs_free) hawk_rtx_freemem(rtx, fs_free);
 
 	/* set the number of fields */
 	v = hawk_rtx_makeintval(rtx, (hawk_int_t)rtx->inrec.nflds);
 	if (v == HAWK_NULL) return -1;
 
-	hawk_rtx_refupval (rtx, v);
+	hawk_rtx_refupval(rtx, v);
 	if (hawk_rtx_setgbl(rtx, HAWK_GBL_NF, v) <= -1)
 	{
-		hawk_rtx_refdownval (rtx, v);
+		hawk_rtx_refdownval(rtx, v);
 		return -1;
 	}
-	hawk_rtx_refdownval (rtx, v);
+	hawk_rtx_refdownval(rtx, v);
 	return 0;
 }
 
@@ -342,7 +342,7 @@ int hawk_rtx_clrrec (hawk_rtx_t* rtx, int skip_inrec_line)
 
 	if (HAWK_RTX_GETVALTYPE(rtx, rtx->inrec.d0) != HAWK_VAL_NIL)
 	{
-		hawk_rtx_refdownval (rtx, rtx->inrec.d0);
+		hawk_rtx_refdownval(rtx, rtx->inrec.d0);
 		rtx->inrec.d0 = hawk_val_nil;
 	}
 
@@ -353,7 +353,7 @@ int hawk_rtx_clrrec (hawk_rtx_t* rtx, int skip_inrec_line)
 		for (i = 0; i < rtx->inrec.nflds; i++)
 		{
 			HAWK_ASSERT(rtx->inrec.flds[i].val != HAWK_NULL);
-			hawk_rtx_refdownval (rtx, rtx->inrec.flds[i].val);
+			hawk_rtx_refdownval(rtx, rtx->inrec.flds[i].val);
 		}
 		rtx->inrec.nflds = 0;
 
@@ -430,11 +430,11 @@ static int recomp_record_fields (hawk_rtx_t* rtx, hawk_oow_t lv, const hawk_oocs
 			                     hawk_rtx_makestrvalwithoochars(rtx, str->ptr, str->len);
 			if (HAWK_UNLIKELY(!tmp)) return -1;
 
-			if (i < nflds) hawk_rtx_refdownval (rtx, rtx->inrec.flds[i].val);
+			if (i < nflds) hawk_rtx_refdownval(rtx, rtx->inrec.flds[i].val);
 			else rtx->inrec.nflds++;
 
 			rtx->inrec.flds[i].val = tmp;
-			hawk_rtx_refupval (rtx, tmp);
+			hawk_rtx_refupval(rtx, tmp);
 		}
 		else if (i >= nflds)
 		{
@@ -446,9 +446,9 @@ static int recomp_record_fields (hawk_rtx_t* rtx, hawk_oow_t lv, const hawk_oocs
 			/* hawk_rtx_refdownval should not be called over
 			 * rtx->inrec.flds[i].val as it is not initialized
 			 * to any valid values */
-			/*hawk_rtx_refdownval (rtx, rtx->inrec.flds[i].val);*/
+			/*hawk_rtx_refdownval(rtx, rtx->inrec.flds[i].val);*/
 			rtx->inrec.flds[i].val = hawk_val_zls;
-			hawk_rtx_refupval (rtx, hawk_val_zls);
+			hawk_rtx_refupval(rtx, hawk_val_zls);
 			rtx->inrec.nflds++;
 		}
 		else
@@ -460,7 +460,7 @@ static int recomp_record_fields (hawk_rtx_t* rtx, hawk_oow_t lv, const hawk_oocs
 			if (HAWK_UNLIKELY(!vp)) return -1;
 
 			vl = hawk_ooecs_ncat(&rtx->inrec.line, vp, vl);
-			hawk_rtx_freevaloocstr (rtx, rtx->inrec.flds[i].val, vp);
+			hawk_rtx_freevaloocstr(rtx, rtx->inrec.flds[i].val, vp);
 
 			if (HAWK_UNLIKELY(vl == (hawk_oow_t)-1)) return -1;
 		}
@@ -471,16 +471,16 @@ static int recomp_record_fields (hawk_rtx_t* rtx, hawk_oow_t lv, const hawk_oocs
 
 	if (HAWK_RTX_GETINTFROMVAL(rtx, v) != max)
 	{
-		v = hawk_rtx_makeintval (rtx, (hawk_int_t)max);
+		v = hawk_rtx_makeintval(rtx, (hawk_int_t)max);
 		if (v == HAWK_NULL) return -1;
 
-		hawk_rtx_refupval (rtx, v);
+		hawk_rtx_refupval(rtx, v);
 		if (hawk_rtx_setgbl(rtx, HAWK_GBL_NF, v) <= -1)
 		{
-			hawk_rtx_refdownval (rtx, v);
+			hawk_rtx_refdownval(rtx, v);
 			return -1;
 		}
-		hawk_rtx_refdownval (rtx, v);
+		hawk_rtx_refdownval(rtx, v);
 	}
 
 	return 0;
@@ -505,7 +505,7 @@ int hawk_rtx_truncrec (hawk_rtx_t* rtx, hawk_oow_t nflds)
 		if (nflds > 1)
 		{
 			v = HAWK_RTX_STACK_GBL(rtx, HAWK_GBL_OFS);
-			hawk_rtx_refupval (rtx, v);
+			hawk_rtx_refupval(rtx, v);
 			vtype = HAWK_RTX_GETVALTYPE(rtx, v);
 
 			if (vtype == HAWK_VAL_NIL)
@@ -531,7 +531,7 @@ int hawk_rtx_truncrec (hawk_rtx_t* rtx, hawk_oow_t nflds)
 
 		if (v)
 		{
-			if (ofs_free) hawk_rtx_freevaloocstr (rtx, v, ofs_free);
+			if (ofs_free) hawk_rtx_freevaloocstr(rtx, v, ofs_free);
 			hawk_rtx_refdownval(rtx, v);
 			v = HAWK_NULL;
 		}
@@ -540,9 +540,9 @@ int hawk_rtx_truncrec (hawk_rtx_t* rtx, hawk_oow_t nflds)
 	w = (hawk_val_t*)hawk_rtx_makestrvalwithoocs(rtx, HAWK_OOECS_OOCS(&tmp));
 	if (HAWK_UNLIKELY(!w)) goto oops;
 
-	hawk_rtx_refdownval (rtx, rtx->inrec.d0);
+	hawk_rtx_refdownval(rtx, rtx->inrec.d0);
 	rtx->inrec.d0 = w;
-	hawk_rtx_refupval (rtx, rtx->inrec.d0);
+	hawk_rtx_refupval(rtx, rtx->inrec.d0);
 
 	hawk_ooecs_swap (&tmp, &rtx->inrec.line);
 	hawk_ooecs_fini (&tmp);
@@ -550,7 +550,7 @@ int hawk_rtx_truncrec (hawk_rtx_t* rtx, hawk_oow_t nflds)
 
 	for (i = nflds; i < rtx->inrec.nflds; i++)
 	{
-		hawk_rtx_refdownval (rtx, rtx->inrec.flds[i].val);
+		hawk_rtx_refdownval(rtx, rtx->inrec.flds[i].val);
 	}
 
 	rtx->inrec.nflds = nflds;
@@ -560,7 +560,7 @@ oops:
 	if (fini_tmp) hawk_ooecs_fini (&tmp);
 	if (v)
 	{
-		if (ofs_free) hawk_rtx_freevaloocstr (rtx, v, ofs_free);
+		if (ofs_free) hawk_rtx_freevaloocstr(rtx, v, ofs_free);
 		hawk_rtx_refdownval(rtx, v);
 	}
 	return -1;

lib/rio.c

@@ -1141,7 +1141,7 @@ int hawk_rtx_readiobytes (hawk_rtx_t* rtx, hawk_in_type_t in_type, const hawk_oo
 int hawk_rtx_writeioval (hawk_rtx_t* rtx, hawk_out_type_t out_type, const hawk_ooch_t* name, hawk_val_t* v)
 {
 	hawk_val_type_t vtype;
-	vtype = HAWK_RTX_GETVALTYPE (rtx, v);
+	vtype = HAWK_RTX_GETVALTYPE(rtx, v);
 
 	switch (vtype)
 	{
@@ -1545,7 +1545,7 @@ int hawk_rtx_closio_read (hawk_rtx_t* rtx, hawk_in_type_t in_type, const hawk_oo
 			handler = rtx->rio.handler[p->type & IO_MASK_CLEAR];
 			if (handler)
 			{
-				if (handler (rtx, HAWK_RIO_CMD_CLOSE, p, HAWK_NULL, 0) <= -1)
+				if (handler(rtx, HAWK_RIO_CMD_CLOSE, p, HAWK_NULL, 0) <= -1)
 				{
 					/* this is not a rtx-time error.*/
 					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EIOIMPL);
@@ -1717,7 +1717,7 @@ void hawk_rtx_flushallios (hawk_rtx_t* rtx)
 		handler = rtx->rio.handler[rio->type & IO_MASK_CLEAR];
 		if (handler)
 		{
-			handler (rtx, HAWK_RIO_CMD_FLUSH, rio, HAWK_NULL, 0);
+			handler(rtx, HAWK_RIO_CMD_FLUSH, rio, HAWK_NULL, 0);
 		}
 	}
 }

lib/run.c

@@ -79,6 +79,8 @@ static void fini_rtx (hawk_rtx_t* rtx, int fini_globals);
 static int init_globals (hawk_rtx_t* rtx);
 static void refdown_globals (hawk_rtx_t* rtx, int pop);
 
+static void fbc_eval_stack_fini (hawk_rtx_t* rtx, hawk_fbc_eval_stack_t* stack);
+
 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);
@@ -99,6 +101,7 @@ static int run_delete (hawk_rtx_t* rtx, hawk_nde_delete_t* nde);
 static int run_reset (hawk_rtx_t* rtx, hawk_nde_reset_t* nde);
 static int run_print (hawk_rtx_t* rtx, hawk_nde_print_t* nde);
 static int run_printf (hawk_rtx_t* rtx, hawk_nde_print_t* nde);
+static int run_funbc (hawk_rtx_t* rtx, hawk_fun_t* fun);
 
 static int output_formatted (hawk_rtx_t* rtx, hawk_out_type_t out_type, const hawk_ooch_t* dst, const hawk_ooch_t* fmt, hawk_oow_t fmt_len, hawk_nde_t* args);
 static int output_formatted_bytes (hawk_rtx_t* rtx, hawk_out_type_t out_type, const hawk_ooch_t* dst, const hawk_bch_t* fmt, hawk_oow_t fmt_len, hawk_nde_t* args);
@@ -1340,8 +1343,10 @@ static void fini_rtx (hawk_rtx_t* rtx, int fini_globals)
 		rtx->stack_limit = 0;
 	}
 
+	fbc_eval_stack_fini(rtx, &rtx->fbc_eval_stack);
+
 	/* destroy named variables */
-	hawk_htb_close (rtx->named);
+	hawk_htb_close(rtx->named);
 
 #if defined(HAWK_ENABLE_GC)
 	/* collect garbage after having released global variables and named global variables */
@@ -7484,6 +7489,472 @@ static hawk_val_t* eval_fncall_var (hawk_rtx_t* rtx, hawk_nde_t* nde)
 	return rv;
 }
 
+static void fbc_eval_stack_unwind (hawk_rtx_t* rtx, hawk_fbc_eval_stack_t* stack, hawk_oow_t base)
+{
+	while (stack->len > base)
+	{
+		hawk_rtx_refdownval(rtx, stack->ptr[--stack->len]);
+	}
+}
+
+static void fbc_eval_stack_fini (hawk_rtx_t* rtx, hawk_fbc_eval_stack_t* stack)
+{
+	while (stack->len > 0)
+	{
+		hawk_rtx_refdownval(rtx, stack->ptr[--stack->len]);
+	}
+
+	if (stack->ptr) hawk_rtx_freemem(rtx, stack->ptr);
+	stack->ptr = HAWK_NULL;
+	stack->len = 0;
+	stack->capa = 0;
+}
+
+static int fbc_eval_stack_reserve (hawk_rtx_t* rtx, hawk_fbc_eval_stack_t* stack, hawk_oow_t n)
+{
+	hawk_val_t** tmp;
+	hawk_oow_t req, capa;
+
+	req = stack->len + n;
+	if (req <= stack->len) goto oops_eoverflow;
+	if (req <= stack->capa) return 0;
+
+	capa = HAWK_ALIGN_POW2(req, 16);
+	if (capa < req) goto oops_eoverflow;
+	if (capa > HAWK_TYPE_MAX(hawk_oow_t) / HAWK_SIZEOF(*tmp)) goto oops_eoverflow;
+
+	tmp = (hawk_val_t**)hawk_rtx_reallocmem(rtx, stack->ptr, capa * HAWK_SIZEOF(*tmp));
+	if (HAWK_UNLIKELY(!tmp)) return -1;
+
+	stack->ptr = tmp;
+	stack->capa = capa;
+	return 0;
+
+oops_eoverflow:
+	hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_ENOMEM);
+	return -1;
+}
+
+static int fbc_eval_stack_push (hawk_rtx_t* rtx, hawk_fbc_eval_stack_t* stack, hawk_val_t* val)
+{
+	if (fbc_eval_stack_reserve(rtx, stack, 1) <= -1) return -1;
+	stack->ptr[stack->len++] = val;
+	hawk_rtx_refupval(rtx, val);
+	return 0;
+}
+
+static hawk_val_t* fbc_eval_stack_pop (hawk_fbc_eval_stack_t* stack)
+{
+	return (stack->len <= 0)? HAWK_NULL: stack->ptr[--stack->len];
+}
+
+static int fbc_eval_binop (
+	hawk_rtx_t* rtx,
+	hawk_fbc_eval_stack_t* stack,
+	hawk_val_t* (*evalfn)(hawk_rtx_t*,hawk_val_t*,hawk_val_t*))
+{
+	hawk_val_t* right;
+	hawk_val_t* left;
+	hawk_val_t* res;
+
+	if (stack->len < 2)
+	{
+		hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+		return -1;
+	}
+
+	right = fbc_eval_stack_pop(stack);
+	left = fbc_eval_stack_pop(stack);
+	HAWK_ASSERT(right != HAWK_NULL && left != HAWK_NULL);
+
+	res = evalfn(rtx, left, right);
+	hawk_rtx_refdownval(rtx, right);
+	hawk_rtx_refdownval(rtx, left);
+	if (HAWK_UNLIKELY(!res)) return -1;
+
+	if (fbc_eval_stack_push(rtx, stack, res) <= -1) return -1;
+	return 0;
+}
+
+static int run_funbc (hawk_rtx_t* rtx, hawk_fun_t* fun)
+{
+	hawk_fbc_t* bc;
+	hawk_nde_blk_t* blk;
+	hawk_oow_t pc;
+	hawk_fbc_eval_stack_t* evstk;
+	hawk_oow_t evstk_base;
+	int n = 0;
+
+	/* the caller must not call this function if the function doesn't
+	 * have the associated bytecode emitted */
+	HAWK_ASSERT(fun != HAWK_NULL);
+	HAWK_ASSERT(fun->bc != HAWK_NULL);
+	HAWK_ASSERT(fun->bc->len > 0);
+	HAWK_ASSERT(fun->body != HAWK_NULL);
+	HAWK_ASSERT(fun->body->type == HAWK_NDE_BLK);
+
+	evstk_base = rtx->fbc_eval_stack.len;
+	evstk = &rtx->fbc_eval_stack;
+
+	bc = fun->bc;
+	blk = (hawk_nde_blk_t*)fun->body;
+
+	if (blk->nlcls > 0)
+	{
+		hawk_oow_t tmp = blk->nlcls;
+
+		if (HAWK_UNLIKELY(HAWK_RTX_STACK_AVAIL(rtx) < tmp))
+		{
+			hawk_rtx_seterrbfmt(rtx, &blk->loc, HAWK_ESTACK,
+				"stack full(avail=%zu, limit=%zu) for %zu local variables",
+				HAWK_RTX_STACK_AVAIL(rtx), rtx->stack_limit, tmp);
+			goto oops;
+		}
+
+		do
+		{
+			--tmp;
+			HAWK_RTX_STACK_PUSH(rtx, hawk_val_nil);
+		}
+		while (tmp > 0);
+	}
+
+	for (pc = 0; pc < bc->len && rtx->exit_level == EXIT_NONE; )
+	{
+		hawk_fbc_ins_t* ins = &bc->code[pc];
+		hawk_val_t* val;
+
+/*hawk_logbfmt(rtx->hawk, HAWK_LOG_STDERR, "opcode = 0x%x [%d]\n", ins->opcode, ins->opcode);*/
+		switch (ins->opcode)
+		{
+			case HAWK_FBC_OP_NOP:
+				break;
+
+			case HAWK_FBC_OP_LOAD_CONST_INT:
+				val = hawk_rtx_makeintval(rtx, ins->u.iv);
+				if (HAWK_UNLIKELY(!val)) goto oops;
+				if (fbc_eval_stack_push(rtx, evstk, val) <= -1) goto oops;
+				break;
+
+			case HAWK_FBC_OP_LOAD_CONST_NIL:
+				if (fbc_eval_stack_push(rtx, evstk, hawk_val_nil) <= -1) goto oops;
+				break;
+
+			case HAWK_FBC_OP_LOAD_CONST_TRUE:
+				if (fbc_eval_stack_push(rtx, evstk, hawk_val_true) <= -1) goto oops;
+				break;
+
+			case HAWK_FBC_OP_LOAD_CONST_FALSE:
+				if (fbc_eval_stack_push(rtx, evstk, hawk_val_false) <= -1) goto oops;
+				break;
+
+			case HAWK_FBC_OP_LOAD_GBL:
+			case HAWK_FBC_OP_LOAD_LCL:
+			case HAWK_FBC_OP_LOAD_ARG:
+			{
+				hawk_nde_var_t* var = (hawk_nde_var_t*)ins->u.nde;
+
+				if (!var)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+
+				switch (ins->opcode)
+				{
+					case HAWK_FBC_OP_LOAD_GBL: val = HAWK_RTX_STACK_GBL(rtx, var->id.idxa); break;
+					case HAWK_FBC_OP_LOAD_LCL: val = HAWK_RTX_STACK_LCL(rtx, var->id.idxa); break;
+					default: val = HAWK_RTX_STACK_ARG(rtx, var->id.idxa); break;
+				}
+
+				if (fbc_eval_stack_push(rtx, evstk, val) <= -1) goto oops;
+				break;
+			}
+
+			case HAWK_FBC_OP_STORE_GBL:
+			case HAWK_FBC_OP_STORE_LCL:
+			case HAWK_FBC_OP_STORE_ARG:
+			case HAWK_FBC_OP_STORE_POP_GBL:
+			case HAWK_FBC_OP_STORE_POP_LCL:
+			case HAWK_FBC_OP_STORE_POP_ARG:
+			{
+				hawk_nde_var_t* var = (hawk_nde_var_t*)ins->u.nde;
+				hawk_val_t* res;
+				int keep_result;
+
+				val = fbc_eval_stack_pop(evstk);
+				if (!val)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+
+				if (!var)
+				{
+					hawk_rtx_refdownval(rtx, val);
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+
+				keep_result =
+					(ins->opcode == HAWK_FBC_OP_STORE_GBL ||
+					 ins->opcode == HAWK_FBC_OP_STORE_LCL ||
+					 ins->opcode == HAWK_FBC_OP_STORE_ARG);
+
+				res = do_assignment(rtx, (hawk_nde_t*)var, val, 0);
+				if (HAWK_UNLIKELY(!res))
+				{
+					hawk_rtx_refdownval(rtx, val);
+					goto oops;
+				}
+
+				if (keep_result && fbc_eval_stack_push(rtx, evstk, res) <= -1)
+				{
+					hawk_rtx_refdownval(rtx, val);
+					goto oops;
+				}
+
+				hawk_rtx_refdownval(rtx, val);
+				break;
+			}
+
+			case HAWK_FBC_OP_ADD:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_plus) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_SUB:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_minus) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_MUL:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_mul) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_DIV:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_div) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_IDIV:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_idiv) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_MOD:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_mod) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_EXP:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_exp) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_CONCAT:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_concat) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_RSHIFT:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_rshift) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_LSHIFT:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_lshift) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_BAND:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_band) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_BXOR:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_bxor) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_BOR:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_bor) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_TEQ:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_teq) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_TNE:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_tne) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_EQ:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_eq) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_NE:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_ne) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_GT:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_gt) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_GE:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_ge) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_LT:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_lt) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_LE:
+				if (HAWK_UNLIKELY(fbc_eval_binop(rtx, evstk, eval_binop_le) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_NEG:
+			{
+				int n;
+				hawk_int_t l;
+				hawk_flt_t r;
+				hawk_val_t* res;
+
+				val = fbc_eval_stack_pop(evstk);
+				if (!val)
+				{
+					hawk_rtx_seterrbfmt(rtx, HAWK_NULL, HAWK_EINTERN, "eval stack underflow");
+					goto oops;
+				}
+
+				n = hawk_rtx_valtonum(rtx, val, &l, &r);
+				if (HAWK_UNLIKELY(n <= -1))
+				{
+					hawk_rtx_refdownval(rtx, val);
+					goto oops;
+				}
+
+				res = (n == 0)? hawk_rtx_makeintval(rtx, -l): hawk_rtx_makefltval(rtx, -r);
+				hawk_rtx_refdownval(rtx, val);
+				if (HAWK_UNLIKELY(!res)) goto oops;
+				if (fbc_eval_stack_push(rtx, evstk, res) <= -1) goto oops;
+				break;
+			}
+
+			case HAWK_FBC_OP_SWAP:
+				if (evstk->len < 2)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+				{
+					hawk_val_t* tmp = evstk->ptr[evstk->len - 1];
+					evstk->ptr[evstk->len - 1] = evstk->ptr[evstk->len - 2];
+					evstk->ptr[evstk->len - 2] = tmp;
+				}
+				break;
+
+			case HAWK_FBC_OP_DUP:
+				if (evstk->len <= 0)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+				if (fbc_eval_stack_push(rtx, evstk, evstk->ptr[evstk->len - 1]) <= -1) goto oops;
+				break;
+
+			case HAWK_FBC_OP_JMP:
+				if (ins->u.idx > bc->len)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+				pc = ins->u.idx;
+				continue;
+
+			case HAWK_FBC_OP_JZ:
+				val = fbc_eval_stack_pop(evstk);
+				if (!val)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+
+				if (!hawk_rtx_valtobool(rtx, val))
+				{
+					hawk_rtx_refdownval(rtx, val);
+					if (ins->u.idx > bc->len)
+					{
+						hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+						goto oops;
+					}
+					pc = ins->u.idx;
+					continue;
+				}
+
+				hawk_rtx_refdownval(rtx, val);
+				break;
+
+			case HAWK_FBC_OP_RET:
+				val = fbc_eval_stack_pop(evstk);
+				if (!val)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+				hawk_rtx_refdownval(rtx, HAWK_RTX_STACK_RETVAL(rtx));
+				HAWK_RTX_STACK_RETVAL(rtx) = val;
+				hawk_rtx_refupval(rtx, val);
+				hawk_rtx_refdownval(rtx, val);
+				rtx->exit_level = EXIT_FUNCTION;
+				goto done;
+
+			case HAWK_FBC_OP_POP:
+				val = fbc_eval_stack_pop(evstk);
+				if (!val)
+				{
+					hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_EINTERN);
+					goto oops;
+				}
+				hawk_rtx_refdownval(rtx, val);
+				break;
+
+			case HAWK_FBC_OP_RUN_AST_STMT:
+				if (HAWK_UNLIKELY(run_statement(rtx, ins->u.nde) <= -1)) goto oops;
+				break;
+
+			case HAWK_FBC_OP_RET_AST_EXPR:
+				val = eval_expression(rtx, ins->u.nde);
+				if (HAWK_UNLIKELY(!val)) goto oops;
+
+				hawk_rtx_refdownval(rtx, HAWK_RTX_STACK_RETVAL(rtx));
+				HAWK_RTX_STACK_RETVAL(rtx) = val;
+				hawk_rtx_refupval(rtx, val);
+
+				rtx->exit_level = EXIT_FUNCTION;
+				goto done;
+
+			case HAWK_FBC_OP_RET_NIL:
+				rtx->exit_level = EXIT_FUNCTION;
+				goto done;
+
+			default:
+				hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_ENOIMPL);
+				goto oops;
+		}
+
+		pc++;
+	}
+
+done:
+	if (blk->nlcls > 0)
+	{
+		hawk_oow_t tmp = blk->nlcls;
+		do
+		{
+			--tmp;
+			hawk_rtx_refdownval(rtx, HAWK_RTX_STACK_LCL(rtx, tmp));
+			HAWK_RTX_STACK_POP(rtx);
+		}
+		while (tmp > 0);
+	}
+	fbc_eval_stack_unwind(rtx, evstk, evstk_base);
+	return n;
+
+oops:
+	n = -1;
+	goto done;
+}
+
 hawk_val_t* hawk_rtx_evalcall (
 	hawk_rtx_t* rtx, hawk_nde_fncall_t* call, hawk_fun_t* fun,
 	hawk_oow_t(*argpusher)(hawk_rtx_t*,hawk_nde_fncall_t*,void*), void* apdata,
@@ -7540,7 +8011,7 @@ hawk_val_t* hawk_rtx_evalcall (
 	saved_stack_top = rtx->stack_top;
 
 #if defined(DEBUG_RUN)
-	hawk_logbfmt(hawk_rtx_gethawk(rtx), "setting up function stack frame top=%zd base=%zd\n", (hawk_oow_t)rtx->stack_top, (hawk_oow_t)rtx->stack_base);
+	hawk_logbfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_DEBUG, "setting up function stack frame top=%zd base=%zd\n", (hawk_oow_t)rtx->stack_top, (hawk_oow_t)rtx->stack_base);
 #endif
 
 	/* make a new stack frame */
@@ -7592,15 +8063,22 @@ hawk_val_t* hawk_rtx_evalcall (
 	HAWK_RTX_STACK_NARGS(rtx) = (void*)nargs;
 
 #if defined(DEBUG_RUN)
-	hawk_logbfmt(hawk_rtx_gethawk(rtx), "running function body\n");
+	hawk_logbfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_DEBUG, "running function body\n");
 #endif
 
 	if (fun)
 	{
 		/* normal hawk function */
+		if ((rtx->hawk->opt.trait & HAWK_BUILDBC) && fun->bc && fun->bc->len > 0)
+		{
+			n = run_funbc(rtx, fun);
+		}
+		else
+		{
 			HAWK_ASSERT(fun->body->type == HAWK_NDE_BLK);
 			n = run_block(rtx, (hawk_nde_blk_t*)fun->body);
 		}
+	}
 	else
 	{
 		n = 0;
@@ -7618,7 +8096,7 @@ hawk_val_t* hawk_rtx_evalcall (
 	/* refdown args in the rtx.stack */
 	nargs = (hawk_oow_t)HAWK_RTX_STACK_NARGS(rtx);
 #if defined(DEBUG_RUN)
-	hawk_logbfmt(hawk_rtx_gethawk(rtx), "block rtx complete nargs = %d\n", (int)nargs);
+	hawk_logbfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_DEBUG, "block rtx complete nargs = %d\n", (int)nargs);
 #endif
 
 	i = 0;
@@ -7745,7 +8223,7 @@ hawk_val_t* hawk_rtx_evalcall (
 	}
 
 #if defined(DEBUG_RUN)
-	hawk_logbfmt(hawk_rtx_gethawk(rtx), "got return value\n");
+	hawk_logbfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_DEBUG, "got return value\n");
 #endif
 
 	v = HAWK_RTX_STACK_RETVAL(rtx);
@@ -7800,7 +8278,7 @@ hawk_val_t* hawk_rtx_evalcall (
 	if (rtx->exit_level == EXIT_FUNCTION) rtx->exit_level = EXIT_NONE;
 
 #if defined(DEBUG_RUN)
-	hawk_logbfmt(hawk_rtx_gethawk(rtx), "returning from function top=%zd, base=%zd\n", (hawk_oow_t)rtx->stack_top, (hawk_oow_t)rtx->stack_base);
+	hawk_logbfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_DEBUG, "returning from function top=%zd, base=%zd\n", (hawk_oow_t)rtx->stack_top, (hawk_oow_t)rtx->stack_base);
 #endif
 	return (n <= -1)? HAWK_NULL: v;
 

lib/tree.c

@@ -635,7 +635,7 @@ static int print_expr (hawk_t* hawk, hawk_nde_t* nde, int depth)
 					if (fun->argspec && i < fun->argspeclen && fun->argspec[i] == 'r') PUT_SRCSTR(hawk, HAWK_T("&"));
 					n = hawk_int_to_oocstr(i++, 10, HAWK_T("__p"), tmp, HAWK_COUNTOF(tmp));
 					HAWK_ASSERT(n != (hawk_oow_t)-1);
-					PUT_SRCSTRN (hawk, tmp, n);
+					PUT_SRCSTRN(hawk, tmp, n);
 
 					if (i >= fun->nargs) break;
 					PUT_SRCSTR(hawk, HAWK_T(", "));

lib/val.c

@@ -185,7 +185,7 @@ static HAWK_INLINE void gc_chain_gch (hawk_gch_t* list, hawk_gch_t* gch)
 
 static HAWK_INLINE void gc_chain_val (hawk_gch_t* list, hawk_val_t* v)
 {
-	gc_chain_gch (list, hawk_val_to_gch(v));
+	gc_chain_gch(list, hawk_val_to_gch(v));
 }
 
 static HAWK_INLINE void gc_move_all_gchs (hawk_gch_t* src, hawk_gch_t* dst)
@@ -213,7 +213,7 @@ static HAWK_INLINE void gc_unchain_gch (hawk_gch_t* gch)
 
 static HAWK_INLINE void gc_unchain_val (hawk_val_t* v)
 {
-	gc_unchain_gch (hawk_val_to_gch(v));
+	gc_unchain_gch(hawk_val_to_gch(v));
 }
 
 static void gc_trace_refs (hawk_gch_t* list)
@@ -307,8 +307,8 @@ static void gc_move_reachables (hawk_gch_t* list, hawk_gch_t* reachable_list)
 		tmp = gch->gc_next;
 		if (gch->gc_refs > 0)
 		{
-			gc_unchain_gch (gch);
-			gc_chain_gch (reachable_list, gch);
+			gc_unchain_gch(gch);
+			gc_chain_gch(reachable_list, gch);
 			gch->gc_refs = GCH_MOVED;
 		}
 		gch = tmp;
@@ -336,8 +336,8 @@ static void gc_move_reachables (hawk_gch_t* list, hawk_gch_t* reachable_list)
 					tmp = hawk_val_to_gch(iv);
 					if (tmp->gc_refs != GCH_MOVED)
 					{
-						gc_unchain_gch (tmp);
-						gc_chain_gch (reachable_list, tmp);
+						gc_unchain_gch(tmp);
+						gc_chain_gch(reachable_list, tmp);
 						tmp->gc_refs = GCH_MOVED;
 					}
 				}
@@ -363,8 +363,8 @@ static void gc_move_reachables (hawk_gch_t* list, hawk_gch_t* reachable_list)
 						tmp = hawk_val_to_gch(iv);
 						if (tmp->gc_refs != GCH_MOVED)
 						{
-							gc_unchain_gch (tmp);
-							gc_chain_gch (reachable_list, tmp);
+							gc_unchain_gch(tmp);
+							gc_chain_gch(reachable_list, tmp);
 							tmp->gc_refs = GCH_MOVED;
 						}
 					}
@@ -403,7 +403,7 @@ static void gc_free_unreachables (hawk_rtx_t* rtx, hawk_gch_t* list)
 	gch = list->gc_next;
 	while (gch != list)
 	{
-		hawk_rtx_freeval (rtx, hawk_gch_to_val(gch), HAWK_RTX_FREEVAL_GC_PRESERVE);
+		hawk_rtx_freeval(rtx, hawk_gch_to_val(gch), HAWK_RTX_FREEVAL_GC_PRESERVE);
 		gch = gch->gc_next;
 	}
 
@@ -416,8 +416,8 @@ static void gc_free_unreachables (hawk_rtx_t* rtx, hawk_gch_t* list)
 		hawk_logbfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_STDERR, "[GC] FREEING UNREACHABLE GCH %p gc_refs %zu v_refs %zu\n", gch, gch->gc_refs, hawk_gch_to_val(gch)->v_refs);
 	#endif
 		/* do what hawk_rtx_freeval() would do without HAWK_RTX_FREEVAL_GC_PRESERVE */
-		gc_unchain_gch (gch);
-		gc_free_val (rtx, hawk_gch_to_val(gch));
+		gc_unchain_gch(gch);
+		gc_free_val(rtx, hawk_gch_to_val(gch));
 	}
 }
 
@@ -447,9 +447,9 @@ static HAWK_INLINE void gc_collect_garbage_in_generation (hawk_rtx_t* rtx, int g
 
 		/* only unreachables are left in rtx->gc.g[0] */
 	#if defined(DEBUG_GC)
-	/*gc_dump_refs (rtx, &rtx->gc.g[0]);*/
+	/*gc_dump_refs(rtx, &rtx->gc.g[0]);*/
 	#endif
-		gc_free_unreachables (rtx, &rtx->gc.g[gen]);
+		gc_free_unreachables(rtx, &rtx->gc.g[gen]);
 		HAWK_ASSERT(rtx->gc.g[gen].gc_next == &rtx->gc.g[gen]);
 
 		/* move all reachables back to the main list */
@@ -478,12 +478,12 @@ static HAWK_INLINE int gc_collect_garbage_auto (hawk_rtx_t* rtx)
 		--i;
 		if (rtx->gc.pressure[i] >= rtx->gc.threshold[i])
 		{
-			gc_collect_garbage_in_generation (rtx, i);
+			gc_collect_garbage_in_generation(rtx, i);
 			return i;
 		}
 	}
 
-	gc_collect_garbage_in_generation (rtx, 0);
+	gc_collect_garbage_in_generation(rtx, 0);
 	return 0;
 }
 
@@ -496,7 +496,7 @@ int hawk_rtx_gc (hawk_rtx_t* rtx, int gen)
 	else
 	{
 		if (gen >= HAWK_COUNTOF(rtx->gc.g)) gen = HAWK_COUNTOF(rtx->gc.g) - 1;
-		gc_collect_garbage_in_generation (rtx, gen);
+		gc_collect_garbage_in_generation(rtx, gen);
 		return gen;
 	}
 }
@@ -519,7 +519,7 @@ static HAWK_INLINE hawk_val_t* gc_calloc_val (hawk_rtx_t* rtx, hawk_oow_t size)
 		if (gc_gen < HAWK_COUNTOF(rtx->gc.g) - 1)
 		{
 			/* perform full gc if full gc has not been triggerred at the beginning of this function */
-			hawk_rtx_gc (rtx, HAWK_COUNTOF(rtx->gc.g) - 1);
+			hawk_rtx_gc(rtx, HAWK_COUNTOF(rtx->gc.g) - 1);
 		}
 		gch = (hawk_gch_t*)hawk_rtx_callocmem(rtx, HAWK_SIZEOF(*gch) + size);
 		if (HAWK_UNLIKELY(!gch)) return HAWK_NULL;
@@ -1132,7 +1132,7 @@ static void same_arrval (hawk_arr_t* map, void* dptr, hawk_oow_t dlen)
 #if defined(DEBUG_VAL)
 	hawk_logfmt (hawk_rtx_gethawk(rtx), HAWK_LOG_STDERR, HAWK_T("refdown nofree in arr free - [%O]\n"), dptr);
 #endif
-	hawk_rtx_refdownval_nofree (rtx, dptr);
+	hawk_rtx_refdownval_nofree(rtx, dptr);
 }
 
 
@@ -1155,6 +1155,7 @@ hawk_val_t* hawk_rtx_makearrval (hawk_rtx_t* rtx, hawk_ooi_t init_capa)
 	int retried = 0;
 #endif
 	hawk_val_arr_t* val;
+	int x;
 
 #if defined(HAWK_ENABLE_GC)
 retry:
@@ -1172,15 +1173,16 @@ retry:
 	val->arr = (hawk_arr_t*)(val + 1);
 
 	if (init_capa < 0) init_capa = 64; /* TODO: what is the best initial value? */
-	if (HAWK_UNLIKELY(hawk_arr_init(val->arr, hawk_rtx_getgem(rtx), init_capa) <= -1))
+	x = hawk_arr_init(val->arr, hawk_rtx_getgem(rtx), init_capa);
+	if (HAWK_UNLIKELY(x <= -1))
 	{
 #if defined(HAWK_ENABLE_GC)
-		gc_free_val (rtx, (hawk_val_t*)val);
+		gc_free_val(rtx, (hawk_val_t*)val);
 		if (HAWK_LIKELY(!retried))
 		{
 			/* this arr involves non-gc allocatinon, which happens outside gc_calloc_val().
 			 * reattempt to allocate after full gc like gc_calloc_val() */
-			hawk_rtx_gc (rtx, HAWK_COUNTOF(rtx->gc.g) - 1);
+			hawk_rtx_gc(rtx, HAWK_COUNTOF(rtx->gc.g) - 1);
 			retried = 1;
 			goto retry;
 		}
@@ -1233,7 +1235,7 @@ static void same_mapval (hawk_map_t* map, void* dptr, hawk_oow_t dlen)
 #if defined(DEBUG_VAL)
 	hawk_logfmt (hawk_rtx_gethawk(rtx), HAWK_LOG_STDERR, HAWK_T("refdown nofree in map free - [%O]\n"), dptr);
 #endif
-	hawk_rtx_refdownval_nofree (rtx, dptr);
+	hawk_rtx_refdownval_nofree(rtx, dptr);
 }
 
 hawk_val_t* hawk_rtx_makemapval (hawk_rtx_t* rtx)
@@ -1263,6 +1265,7 @@ hawk_val_t* hawk_rtx_makemapval (hawk_rtx_t* rtx)
 	int retried = 0;
 #endif
 	hawk_val_map_t* val;
+	int x;
 
 #if defined(HAWK_ENABLE_GC)
 retry:
@@ -1279,15 +1282,16 @@ retry:
 	val->v_gc = 0;
 	val->map = (hawk_map_t*)(val + 1);
 
-	if (HAWK_UNLIKELY(hawk_map_init(val->map, hawk_rtx_getgem(rtx), 256, 70, HAWK_SIZEOF(hawk_ooch_t), 1) <= -1))
+	x = hawk_map_init(val->map, hawk_rtx_getgem(rtx), 256, 70, HAWK_SIZEOF(hawk_ooch_t), 1);
+	if (HAWK_UNLIKELY(x <= -1))
 	{
 #if defined(HAWK_ENABLE_GC)
-		gc_free_val (rtx, (hawk_val_t*)val);
+		gc_free_val(rtx, (hawk_val_t*)val);
 		if (HAWK_LIKELY(!retried))
 		{
 			/* this map involves non-gc allocatinon, which happens outside gc_calloc_val().
 			 * reattempt to allocate after full gc like gc_calloc_val() */
-			hawk_rtx_gc (rtx, HAWK_COUNTOF(rtx->gc.g) - 1);
+			hawk_rtx_gc(rtx, HAWK_COUNTOF(rtx->gc.g) - 1);
 			retried = 1;
 			goto retry;
 		}
@@ -1297,10 +1301,10 @@ retry:
 		return HAWK_NULL;
 	}
 	*(hawk_rtx_t**)hawk_map_getxtn(val->map) = rtx;
-	hawk_map_setstyle (val->map, &style);
+	hawk_map_setstyle(val->map, &style);
 
 #if defined(HAWK_ENABLE_GC)
-	gc_chain_val (&rtx->gc.g[0], (hawk_val_t*)val);
+	gc_chain_val(&rtx->gc.g[0], (hawk_val_t*)val);
 	val->v_gc = 1; /* only array and map are to be garbaged collected as of now */
 	#if defined(DEBUG_GC)
 	hawk_logbfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_STDERR, "[GC] MADE GCH %p VAL(MAP) %p\n", hawk_val_to_gch(val), val);
@@ -1385,14 +1389,14 @@ hawk_val_t* hawk_rtx_makemapvalwithdata (hawk_rtx_t* rtx, hawk_val_map_data_t da
 
 		if (tmp == HAWK_NULL || hawk_rtx_setmapvalfld(rtx, map, p->key.ptr, p->key.len, tmp) == HAWK_NULL)
 		{
-			if (tmp) hawk_rtx_freeval (rtx, tmp, HAWK_RTX_FREEVAL_CACHE);
+			if (tmp) hawk_rtx_freeval(rtx, tmp, HAWK_RTX_FREEVAL_CACHE);
 			hawk_rtx_refdownval(rtx, map);
 			return HAWK_NULL;
 		}
 	}
 
 
-	hawk_rtx_refdownval_nofree (rtx, map);
+	hawk_rtx_refdownval_nofree(rtx, map);
 	return map;
 }
 
@@ -1595,7 +1599,7 @@ void hawk_rtx_freeval (hawk_rtx_t* rtx, hawk_val_t* val, int flags)
 		hawk_logfmt(hawk_rtx_gethawk(rtx), HAWK_LOG_STDERR, HAWK_T("freeing [cache=%d] - [%O]\n"), cache, val);
 	#endif
 
-		vtype = HAWK_RTX_GETVALTYPE (rtx, val);
+		vtype = HAWK_RTX_GETVALTYPE(rtx, val);
 		switch (vtype)
 		{
 			case HAWK_VAL_NIL:
@@ -1705,7 +1709,7 @@ void hawk_rtx_freeval (hawk_rtx_t* rtx, hawk_val_t* val, int flags)
 				if (!(flags & HAWK_RTX_FREEVAL_GC_PRESERVE))
 				{
 					gc_unchain_val (val);
-					gc_free_val (rtx, val);
+					gc_free_val(rtx, val);
 				}
 			#else
 				hawk_map_fini(((hawk_val_map_t*)val)->map);
@@ -1724,7 +1728,7 @@ void hawk_rtx_freeval (hawk_rtx_t* rtx, hawk_val_t* val, int flags)
 				if (!(flags & HAWK_RTX_FREEVAL_GC_PRESERVE))
 				{
 					gc_unchain_val (val);
-					gc_free_val (rtx, val);
+					gc_free_val(rtx, val);
 				}
 			#else
 				hawk_arr_fini(((hawk_val_arr_t*)val)->arr);
@@ -1781,13 +1785,13 @@ void hawk_rtx_refdownval(hawk_rtx_t* rtx, hawk_val_t* val)
 	#if defined(USE_ATOMIC_REFCNT) && defined(HAWK_ATOMIC_FETCH_SUB)
 		if (HAWK_ATOMIC_FETCH_SUB(&val->v_refs, 1, HAWK_ATOMIC_RELAXED) == 1)
 		{
-			hawk_rtx_freeval (rtx, val, HAWK_RTX_FREEVAL_CACHE);
+			hawk_rtx_freeval(rtx, val, HAWK_RTX_FREEVAL_CACHE);
 		}
 	#else
 		val->v_refs--;
 		if (val->v_refs <= 0)
 		{
-			hawk_rtx_freeval (rtx, val, HAWK_RTX_FREEVAL_CACHE);
+			hawk_rtx_freeval(rtx, val, HAWK_RTX_FREEVAL_CACHE);
 		}
 	#endif
 	}
@@ -1855,7 +1859,7 @@ static int val_ref_to_bool (hawk_rtx_t* rtx, const hawk_val_ref_t* ref)
 			/* A reference value is not able to point to another
 			 * refernce value for the way values are represented
 			 * in HAWK */
-			HAWK_ASSERT(HAWK_RTX_GETVALTYPE (rtx, *xref)!= HAWK_VAL_REF);
+			HAWK_ASSERT(HAWK_RTX_GETVALTYPE(rtx, *xref)!= HAWK_VAL_REF);
 
 			/* make a recursive call back to the caller */
 			return hawk_rtx_valtobool(rtx, *xref);
@@ -2037,7 +2041,7 @@ static int val_int_to_str (hawk_rtx_t* rtx, const hawk_val_int_t* v, hawk_rtx_va
 	hawk_ooch_t* tmp;
 	hawk_oow_t rlen = 0;
 	int type = out->type & ~HAWK_RTX_VALTOSTR_PRINT;
-	hawk_int_t orgval = HAWK_RTX_GETINTFROMVAL (rtx, v);
+	hawk_int_t orgval = HAWK_RTX_GETINTFROMVAL(rtx, v);
 	hawk_uint_t t;
 
 	if (orgval == 0) rlen++;
@@ -2286,7 +2290,7 @@ static int val_ref_to_str (hawk_rtx_t* rtx, const hawk_val_ref_t* ref, hawk_rtx_
 			/* A reference value is not able to point to another
 			 * refernce value for the way values are represented
 			 * in HAWK */
-			HAWK_ASSERT(HAWK_RTX_GETVALTYPE (rtx, *xref) != HAWK_VAL_REF);
+			HAWK_ASSERT(HAWK_RTX_GETVALTYPE(rtx, *xref) != HAWK_VAL_REF);
 
 			/* make a recursive call back to the caller */
 			return hawk_rtx_valtostr(rtx, *xref, out);
@@ -2965,11 +2969,11 @@ hawk_fun_t* hawk_rtx_valtofun (hawk_rtx_t* rtx, hawk_val_t* v)
 			if (HAWK_UNLIKELY(!x.ptr)) return HAWK_NULL;
 			if (hawk_count_bcstr(x.ptr) != x.len)
 			{
-				hawk_rtx_freevalbcstr (rtx, v, x.ptr);
+				hawk_rtx_freevalbcstr(rtx, v, x.ptr);
 				goto error_inval;
 			}
 			fun = hawk_rtx_findfunwithbcstr(rtx, x.ptr);
-			hawk_rtx_freevalbcstr (rtx, v, x.ptr);
+			hawk_rtx_freevalbcstr(rtx, v, x.ptr);
 			if (!fun) return HAWK_NULL;
 			break;
 		}

t/Makefile.am

@@ -17,7 +17,7 @@ check_SCRIPTS =
 if ENABLE_WIDE_CHAR
 check_SCRIPTS += h-001.hawk h-002.hawk
 endif
-check_SCRIPTS += h-003.hawk h-004.hawk h-009.hawk h-010.hawk h-011.hawk h-012.hawk h-013.hawk h-014.hawk h-015.hawk h-016.hawk h-017.hawk h-018.hawk
+check_SCRIPTS += h-003.hawk h-004.hawk h-009.hawk h-010.hawk h-011.hawk h-012.hawk h-013.hawk h-014.hawk h-015.hawk h-016.hawk h-017.hawk h-018.hawk h-019.hawk
 
 check_SCRIPTS += regress-filename.sh
 
@@ -103,13 +103,14 @@ TEST_EXTENSIONS = .hawk .err .sh
 
 # override these from environment when needed.
 # e.g.
-#   make check HAWK_TEST_COMPILER=../samples/hawk51 HAWK_TEST_MODLIBDIRS_OPT=
+#   make check HAWK_TEST_COMPILER=../samples/hawk51 HAWK_TEST_OPTS=
 HAWK_TEST_COMPILER ?= ../bin/hawk
 HAWK_TEST_MODLIBDIRS_OPT ?= --modlibdirs=../lib/.libs:../mod/.libs
+HAWK_TEST_OPTS ?=
 
 HAWK_LOG_DRIVER = $(LOG_DRIVER)
 HAWK_LOG_COMPILER = $(HAWK_TEST_COMPILER)
-AM_HAWK_LOG_FLAGS = -vTDIR=${abs_srcdir} $(HAWK_TEST_MODLIBDIRS_OPT) -f
+AM_HAWK_LOG_FLAGS = -vTDIR=${abs_srcdir} $(HAWK_TEST_MODLIBDIRS_OPT) $(HAWK_TEST_OPTS) -f
 
 ERR_LOG_DRIVER = $(SHELL) $(top_srcdir)/ac/test-driver
 ERR_LOG_COMPILER = $(SHELL) $(abs_srcdir)/err.sh ../bin/hawk -vTDIR=${abs_srcdir} --modlibdirs=../lib/.libs:../mod/.libs -f

t/Makefile.in

@@ -649,7 +649,7 @@ LDFLAGS_COMMON = -L$(abs_builddir)/../lib  -L$(libdir)
 LIBADD_COMMON = ../lib/libhawk.la $(LIBM)
 check_SCRIPTS = $(am__append_1) h-003.hawk h-004.hawk h-009.hawk \
 	h-010.hawk h-011.hawk h-012.hawk h-013.hawk h-014.hawk \
-	h-015.hawk h-016.hawk h-017.hawk h-018.hawk \
+	h-015.hawk h-016.hawk h-017.hawk h-018.hawk h-019.hawk \
 	regress-filename.sh
 check_ERRORS = e-001.err
 EXTRA_DIST = $(check_SCRIPTS) $(check_ERRORS) tap.inc err.sh \
@@ -711,9 +711,10 @@ TESTS = $(check_PROGRAMS) $(check_SCRIPTS) $(check_ERRORS)
 TEST_EXTENSIONS = .hawk .err .sh
 HAWK_TEST_COMPILER ?= ../bin/hawk
 HAWK_TEST_MODLIBDIRS_OPT ?= --modlibdirs=../lib/.libs:../mod/.libs
+HAWK_TEST_OPTS ?= --modlibdirs=../lib/.libs:../mod/.libs
 HAWK_LOG_DRIVER = $(LOG_DRIVER)
 HAWK_LOG_COMPILER = $(HAWK_TEST_COMPILER)
-AM_HAWK_LOG_FLAGS = -vTDIR=${abs_srcdir} $(HAWK_TEST_MODLIBDIRS_OPT) -f
+AM_HAWK_LOG_FLAGS = -vTDIR=${abs_srcdir} $(HAWK_TEST_MODLIBDIRS_OPT) $(HAWK_TEST_OPTS) -f
 ERR_LOG_DRIVER = $(SHELL) $(top_srcdir)/ac/test-driver
 ERR_LOG_COMPILER = $(SHELL) $(abs_srcdir)/err.sh ../bin/hawk -vTDIR=${abs_srcdir} --modlibdirs=../lib/.libs:../mod/.libs -f
 AM_ERR_LOG_FLAGS = 

t/h-014.hawk

@@ -11,7 +11,7 @@ function dummy()
 
 function main()
 {
-	@local m, a;
+	@local m, a, tmp;
 
 	m = hawk::map();
 	a = hawk::array();
@@ -39,6 +39,11 @@ function main()
 	tap_ensure(@false === 0, 0, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(@true !== 1, 1, @SCRIPTNAME, @SCRIPTLINE);
 
+	tmp = (@false === 0)
+	tap_ensure(tmp, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tmp = (@true === 1)
+	tap_ensure(tmp, 0, @SCRIPTNAME, @SCRIPTLINE);
+
 	tap_ensure(@true == 1.0, 1, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(@false == 0.0, 1, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(@true < 2.5, 1, @SCRIPTNAME, @SCRIPTLINE);
@@ -133,7 +138,6 @@ function main()
 	tap_ensure(sprintf("%v", a), "<ARRAY>", @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(sprintf("%v", dummy), "<FUN:dummy>", @SCRIPTNAME, @SCRIPTLINE);
 
-print "AAAAAAA";
 	tap_ensure(@true - 20, -19, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(@false - 20, -20, @SCRIPTNAME, @SCRIPTLINE);
 	tap_ensure(@true + 20, 21, @SCRIPTNAME, @SCRIPTLINE);

t/h-019.hawk

@@ -0,0 +1,46 @@
+@pragma implicit off
+@pragma pedantic on
+@pragma entry main
+
+@include "tap.inc";
+
+@global i;
+
+function t(v)
+{
+	i += 1;
+	return v;
+}
+
+func main() {
+	@local a, b, c, d, e, f, g, h, j, k, l;
+
+	i = 0;
+
+	a = (0 || t(0));
+	b = i;
+	c = (1 || t(1));
+	d = i;
+	e = (1 && t(0));
+	f = i;
+	g = (0 && t(1));
+	h = i;
+	j = (1? t(10): t(20));
+	k = (0? t(30): t(40));
+	l = i;
+
+	tap_ensure(a, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(b, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(c, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(d, 1, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(e, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(f, 2, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(g, 0, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(h, 2, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(j, 10, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(k, 40, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(l, 4, @SCRIPTNAME, @SCRIPTLINE);
+	tap_ensure(i, 4, @SCRIPTNAME, @SCRIPTLINE);
+
+	tap_end();
+}