touched up signal handling code

initial support for signal handling. some race condition issues yet to be resolved

bin/hawk.c

@@ -46,7 +46,7 @@
 #include <stdlib.h>
 #include <locale.h>
 
-/* #define ENABLE_CALLBACK  TODO: enable this back */
+/* #define ENABLE_STATEMENT_CALLBACK  TODO: enable this back */
 #define ABORT(label) goto label
 
 #if defined(_WIN32)
@@ -125,6 +125,7 @@ static void stop_run (int signo)
 #if !defined(_WIN32) && !defined(__OS2__) && !defined(__DOS__)
 	int e = errno;
 #endif
+	/* signal handler not registered */
 	/*hawk_haltall(hawk_rtx_gethawk(app_rtx));*/
 	hawk_rtx_halt(app_rtx);
 #if !defined(_WIN32) && !defined(__OS2__) && !defined(__DOS__)
@@ -132,6 +133,11 @@ static void stop_run (int signo)
 #endif
 }
 
+static void relay_signal (int signo)
+{
+	hawk_rtx_raisesig(app_rtx, signo);
+}
+
 static void set_intr_pipe (void)
 {
 #if !defined(_WIN32) && !defined(__OS2__) && !defined(__DOS__) && defined(SIGPIPE)
@@ -319,13 +325,36 @@ static void dprint_return (hawk_rtx_t* rtx, hawk_val_t* ret)
 	hawk_logfmt(hawk, HAWK_LOG_STDERR, HAWK_T("[END OF NAMED VARIABLES]\n"));
 }
 
-#if defined(ENABLE_CALLBACK)
+#if defined(ENABLE_STATEMENT_CALLBACK)
 static void on_statement (hawk_rtx_t* rtx, hawk_nde_t* nde)
 {
 	hawk_logfmt (hawk_rtx_gethawk(rtx), HAWK_LOG_STDERR, HAWK_T("running %d at line %zu\n"), (int)nde->type, (hawk_oow_t)nde->loc.line);
 }
 #endif
 
+static void on_sigset (hawk_rtx_t* rtx, int sig, hawk_fun_t* fun)
+{
+	if (fun)
+	{
+		hawk_main_set_signal_handler(sig, relay_signal, 0);
+	}
+	else
+	{
+		int back_to_stop_run = 0;
+		hawk_main_unset_signal_handler(sig);
+	#if defined(SIGTERM)
+		if (sig == SIGTERM) back_to_stop_run = 1;
+	#endif
+	#if defined(SIGHUP)
+		if (sig == SIGHUP) back_to_stop_run = 1;
+	#endif
+	#if defined(SIGINT)
+		if (sig == SIGINT) back_to_stop_run = 1;
+	#endif
+		if (back_to_stop_run) hawk_main_set_signal_handler(sig, stop_run, 0);
+	}
+}
+
 struct opttab_t
 {
 	const hawk_bch_t* name;
@@ -781,15 +810,18 @@ int main_hawk(int argc, hawk_bch_t* argv[], const hawk_bch_t* real_argv0)
 	struct arg_t arg;
 	int ret = -1;
 
-#if defined(ENABLE_CALLBACK)
 	static hawk_rtx_ecb_t rtx_ecb =
 	{
-		HAWK_FV(.close,  HAWK_NULL),
+		HAWK_SFN(close)  HAWK_NULL,
-		HAWK_FV(.stmt,   on_statement),
+	#if defined(ENABLE_STATEMENT_CALLBACK)
-		HAWK_FV(.gblset, HAWK_NULL)
+		HAWK_SFN(stmt)   on_statement,
-		HAWK_FV(.ctx,    HAWK_NULL)
+	#else
+		HAWK_SFN(stmt)   HAWK_NULL,
+	#endif
+		HAWK_SFN(gblset) HAWK_NULL,
+		HAWK_SFN(sigset) on_sigset,
+		HAWK_SFN(ctx)    HAWK_NULL
 	};
-#endif
 
 	/* TODO: change it to support multiple source files */
 	hawk_parsestd_t psout;
@@ -928,9 +960,7 @@ int main_hawk(int argc, hawk_bch_t* argv[], const hawk_bch_t* real_argv0)
 	}
 
 	app_rtx = rtx;
-#if defined(ENABLE_CALLBACK)
 	hawk_rtx_pushecb(rtx, &rtx_ecb);
-#endif
 
 	set_intr_run();
 
@@ -982,4 +1012,3 @@ oops:
 
 	return ret;
 }
-

bin/main.c

@@ -175,7 +175,7 @@ int hawk_main_unset_signal_handler (int sig)
 
 	if (sigaction(sig, &sa, HAWK_NULL) == -1) return -1;
 #else
-	signal (sig, (hawk_main_sig_handler_t)g_sig_state[sig].old_handler);
+	signal(sig, (hawk_main_sig_handler_t)g_sig_state[sig].old_handler);
 #endif
 
 	g_sig_state[sig].handler = 0;

lib/Hawk.cpp

@@ -1886,7 +1886,7 @@ int Hawk::open ()
 #endif
 
 	// push the call back after everything else is ok.
-	hawk_pushecb (this->hawk, &xtn->ecb);
+	hawk_pushecb(this->hawk, &xtn->ecb);
 	return 0;
 }
 

lib/Std-Sed.cpp

@@ -385,7 +385,7 @@ int SedStd::StringStream::open (Data& io)
 			// only if it's not already pushed
 			this->out.sed_ecb.close = this->on_sed_close;
 			this->out.sed_ecb.ctx = this;
-			hawk_sed_pushecb ((hawk_sed_t*)io, &this->out.sed_ecb);
+			hawk_sed_pushecb((hawk_sed_t*)io, &this->out.sed_ecb);
 		}
 
 		io.setHandle (this);

lib/cut.c

@@ -108,17 +108,17 @@ static int hawk_cut_init (hawk_cut_t* cut, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr)
 {
 	HAWK_MEMSET (cut, 0, HAWK_SIZEOF(*cut));
 
-	cut->_instsize = HAWK_SIZEOF(*cut);
+	cut->instsize_ = HAWK_SIZEOF(*cut);
-	cut->_gem.mmgr = mmgr;
+	cut->gem_.mmgr = mmgr;
-	cut->_gem.cmgr = cmgr;
+	cut->gem_.cmgr = cmgr;
 
 	/* initialize error handling fields */
-	cut->_gem.errnum = HAWK_ENOERR;
+	cut->gem_.errnum = HAWK_ENOERR;
-	cut->_gem.errmsg[0] = '\0';
+	cut->gem_.errmsg[0] = '\0';
-	cut->_gem.errloc.line = 0;
+	cut->gem_.errloc.line = 0;
-	cut->_gem.errloc.colm = 0;
+	cut->gem_.errloc.colm = 0;
-	cut->_gem.errloc.file = HAWK_NULL;
+	cut->gem_.errloc.file = HAWK_NULL;
-	cut->_gem.errstr = hawk_dfl_errstr;
+	cut->gem_.errstr = hawk_dfl_errstr;
 
 
 	/* on init, the last points to the first */
@@ -143,7 +143,7 @@ static void hawk_cut_fini (hawk_cut_t* cut)
 
 hawk_errstr_t hawk_cut_geterrstr (hawk_cut_t* cut)
 {
-	return cut->_gem.errstr;
+	return cut->gem_.errstr;
 }
 
 void hawk_cut_seterrbfmt (hawk_cut_t* cut, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* fmt, ...)

lib/err.c

@@ -227,7 +227,7 @@ const hawk_ooch_t* hawk_dfl_errstr (hawk_errnum_t errnum)
 
 hawk_errstr_t hawk_geterrstr (hawk_t* hawk)
 {
-	return hawk->_gem.errstr;
+	return hawk->gem_.errstr;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -298,9 +298,9 @@ void hawk_rtx_seterruvfmt (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnu
 void hawk_rtx_errortohawk (hawk_rtx_t* rtx, hawk_t* hawk)
 {
 	/* copy error information in 'rtx' to the 'hawk' object */
-	hawk->_gem.errnum = rtx->_gem.errnum;
+	hawk->gem_.errnum = rtx->gem_.errnum;
-	hawk->_gem.errloc = rtx->_gem.errloc;
+	hawk->gem_.errloc = rtx->gem_.errloc;
-	hawk_copy_oocstr(hawk->_gem.errmsg, HAWK_COUNTOF(hawk->_gem.errmsg), rtx->_gem.errmsg);
+	hawk_copy_oocstr(hawk->gem_.errmsg, HAWK_COUNTOF(hawk->gem_.errmsg), rtx->gem_.errmsg);
 }
 
 /* ------------------------------------------------------------------------- */

lib/hawk-cmn.h

@@ -1310,6 +1310,19 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 		#define HAWK_HAVE_BUILTIN_CLZLL
 	#endif
 
+	#if __has_builtin(__atomic_exchange_n)
+		#define HAWK_HAVE_ATOMIC_EXCHANGE_N
+	#endif
+	#if __has_builtin(__atomic_fetch_or)
+		#define HAWK_HAVE_ATOMIC_FETCH_OR
+	#endif
+	#if __has_builtin(__atomic_load_n)
+		#define HAWK_HAVE_ATOMIC_LOAD_N
+	#endif
+	#if __has_builtin(__atomic_store_n)
+		#define HAWK_HAVE_ATOMIC_STORE_N
+	#endif
+
 	#if __has_builtin(__builtin_uadd_overflow)
 		#define HAWK_HAVE_BUILTIN_UADD_OVERFLOW
 	#endif
@@ -1352,14 +1365,15 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 		#define HAWK_HAVE_BUILTIN_EXPECT
 	#endif
 
-
+	#if __has_builtin(__sync_fetch_and_or)
+		#define HAWK_HAVE_SYNC_FETCH_AND_OR
+	#endif
 	#if __has_builtin(__sync_lock_test_and_set)
 		#define HAWK_HAVE_SYNC_LOCK_TEST_AND_SET
 	#endif
 	#if __has_builtin(__sync_lock_release)
 		#define HAWK_HAVE_SYNC_LOCK_RELEASE
 	#endif
-
 	#if __has_builtin(__sync_synchronize)
 		#define HAWK_HAVE_SYNC_SYNCHRONIZE
 	#endif
@@ -1370,7 +1384,6 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 		#define HAWK_HAVE_SYNC_VAL_COMPARE_AND_SWAP
 	#endif
 
-
 	#if __has_builtin(__builtin_bswap16)
 		#define HAWK_HAVE_BUILTIN_BSWAP16
 	#endif
@@ -1386,9 +1399,9 @@ 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_OR
 		#define HAWK_HAVE_SYNC_LOCK_TEST_AND_SET
 		#define HAWK_HAVE_SYNC_LOCK_RELEASE
-
 		#define HAWK_HAVE_SYNC_SYNCHRONIZE
 		#define HAWK_HAVE_SYNC_BOOL_COMPARE_AND_SWAP
 		#define HAWK_HAVE_SYNC_VAL_COMPARE_AND_SWAP
@@ -1420,6 +1433,10 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 		#define HAWK_HAVE_BUILTIN_SMULLL_OVERFLOW
 	#endif
 
+	#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)
+		#define HAWK_HAVE_ATOMIC_FETCH_OR
+	#endif
+
 	#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 		/* 4.8.0 or later */
 		#define HAWK_HAVE_BUILTIN_BSWAP16
@@ -1440,6 +1457,42 @@ typedef enum hawk_log_mask_t hawk_log_mask_t;
 #	define HAWK_UNLIKELY(x) (x)
 #endif
 
+#if defined(HAWK_HAVE_ATOMIC_EXCHANGE_N)
+#	define HAWK_ATOMIC_EXCHANGE(ptr,val,mo) __atomic_exchange_n((ptr),(val),(mo))
+#elif defined(HAWK_HAVE_SYNC_LOCK_TEST_AND_SET)
+#	define HAWK_ATOMIC_EXCHANGE(ptr,val,mo) __sync_lock_test_and_set((ptr),(val))
+#endif
+
+#if defined(HAWK_HAVE_ATOMIC_FETCH_OR)
+#	define HAWK_ATOMIC_FETCH_OR(ptr,val,mo) __atomic_fetch_or((ptr),(val),(mo))
+#elif defined(HAWK_HAVE_SYNC_FETCH_AND_OR)
+#	define HAWK_ATOMIC_FETCH_OR(ptr,val,mo) __sync_fetch_and_or((ptr),(val))
+#endif
+
+#if defined(HAWK_HAVE_ATOMIC_LOAD_N)
+#	define HAWK_ATOMIC_LOAD(ptr,mo) __atomic_load_n((ptr),(mo))
+#elif defined(HAWK_HAVE_SYNC_FETCH_AND_OR)
+#	define HAWK_ATOMIC_LOAD(ptr,mo) __sync_fetch_and_or((ptr),0)
+#endif
+
+#if defined(HAWK_HAVE_ATOMIC_STORE_N)
+#	define HAWK_ATOMIC_STORE(ptr,val,mo) __atomic_store_n((ptr),(val),(mo))
+#elif defined(HAWK_HAVE_SYNC_LOCK_TEST_AND_SET) && defined(HAWK_HAVE_SYNC_SYNCHRONIZE)
+#	define HAWK_ATOMIC_STORE(ptr,val,mo) do { __sync_lock_test_and_set((ptr),(val)); __sync_synchronize(); } while(0)
+#endif
+
+#if defined(__ATOMIC_RELAXED)
+#	define HAWK_ATOMIC_RELAXED __ATOMIC_RELAXED
+#else
+#	define HAWK_ATOMIC_RELAXED 0
+#endif
+
+#if defined(__ATOMIC_ACQ_REL)
+#	define HAWK_ATOMIC_ACQ_REL __ATOMIC_ACQ_REL
+#else
+#	define HAWK_ATOMIC_ACQ_REL 4
+#endif
+
 #if defined(__GNUC__)
 #	define HAWK_PACKED __attribute__((__packed__))
 #else

lib/hawk-cut.h

@@ -42,8 +42,8 @@
 typedef struct hawk_cut_t hawk_cut_t;
 
 #define HAWK_CUT_HDR \
-	hawk_oow_t _instsize; \
+	hawk_oow_t instsize_; \
-	hawk_gem_t _gem
+	hawk_gem_t gem_
 
 typedef struct hawk_cut_alt_t hawk_cut_alt_t;
 struct hawk_cut_alt_t
@@ -220,27 +220,27 @@ HAWK_EXPORT void hawk_cut_close (
  * The hawk_cut_getxtn() function returns the pointer to the extension area
  * placed behind the actual cut object.
  */
-static HAWK_INLINE void* hawk_cut_getxtn (hawk_cut_t* cut) { return (void*)((hawk_uint8_t*)cut + ((hawk_cut_alt_t*)cut)->_instsize); }
+static HAWK_INLINE void* hawk_cut_getxtn (hawk_cut_t* cut) { return (void*)((hawk_uint8_t*)cut + ((hawk_cut_alt_t*)cut)->instsize_); }
 
 /**
  * The hawk_cut_getgem() function gets the pointer to the gem structure of the
  * cut object.
  */
-static HAWK_INLINE hawk_gem_t* hawk_cut_getgem (hawk_cut_t* cut) { return &((hawk_cut_alt_t*)cut)->_gem; }
+static HAWK_INLINE hawk_gem_t* hawk_cut_getgem (hawk_cut_t* cut) { return &((hawk_cut_alt_t*)cut)->gem_; }
 
 /**
  * The hawk_cut_getmmgr() function gets the memory manager ucut in
  * hawk_cut_open().
  */
-static HAWK_INLINE hawk_mmgr_t* hawk_cut_getmmgr (hawk_cut_t* cut) { return ((hawk_cut_alt_t*)cut)->_gem.mmgr; }
+static HAWK_INLINE hawk_mmgr_t* hawk_cut_getmmgr (hawk_cut_t* cut) { return ((hawk_cut_alt_t*)cut)->gem_.mmgr; }
-static HAWK_INLINE hawk_cmgr_t* hawk_cut_getcmgr (hawk_cut_t* cut) { return ((hawk_cut_alt_t*)cut)->_gem.cmgr; }
+static HAWK_INLINE hawk_cmgr_t* hawk_cut_getcmgr (hawk_cut_t* cut) { return ((hawk_cut_alt_t*)cut)->gem_.cmgr; }
-static HAWK_INLINE void hawk_cut_setcmgr (hawk_cut_t* cut, hawk_cmgr_t* cmgr) { ((hawk_cut_alt_t*)cut)->_gem.cmgr = cmgr; }
+static HAWK_INLINE void hawk_cut_setcmgr (hawk_cut_t* cut, hawk_cmgr_t* cmgr) { ((hawk_cut_alt_t*)cut)->gem_.cmgr = cmgr; }
 #else
-#define hawk_cut_getxtn(cut) ((void*)((hawk_uint8_t*)cut + ((hawk_cut_alt_t*)cut)->_instsize))
+#define hawk_cut_getxtn(cut) ((void*)((hawk_uint8_t*)cut + ((hawk_cut_alt_t*)cut)->instsize_))
-#define hawk_cut_getgem(cut) (&((hawk_cut_alt_t*)(cut))->_gem)
+#define hawk_cut_getgem(cut) (&((hawk_cut_alt_t*)(cut))->gem_)
-#define hawk_cut_getmmgr(cut) (((hawk_cut_alt_t*)(cut))->_gem.mmgr)
+#define hawk_cut_getmmgr(cut) (((hawk_cut_alt_t*)(cut))->gem_.mmgr)
-#define hawk_cut_getcmgr(cut) (((hawk_cut_alt_t*)(cut))->_gem.cmgr)
+#define hawk_cut_getcmgr(cut) (((hawk_cut_alt_t*)(cut))->gem_.cmgr)
-#define hawk_cut_setcmgr(cut,_cmgr) (((hawk_cut_alt_t*)(cut))->_gem.cmgr = (_cmgr))
+#define hawk_cut_setcmgr(cut,_cmgr) (((hawk_cut_alt_t*)(cut))->gem_.cmgr = (_cmgr))
 #endif /* HAWK_HAVE_INLINE */
 
 /**

lib/hawk-json.h

@@ -34,8 +34,8 @@
 typedef struct hawk_json_t hawk_json_t;
 
 #define HAWK_JSON_HDR \
-	hawk_oow_t _instsize; \
+	hawk_oow_t instsize_; \
-	hawk_gem_t _gem
+	hawk_gem_t gem_
 
 typedef struct hawk_json_alt_t hawk_json_alt_t;
 struct hawk_json_alt_t
@@ -169,27 +169,27 @@ HAWK_EXPORT int hawk_json_getoption (
  * The hawk_json_getxtn() function returns the pointer to the extension area
  * placed behind the actual json object.
  */
-static HAWK_INLINE void* hawk_json_getxtn (hawk_json_t* json) { return (void*)((hawk_uint8_t*)json + ((hawk_json_alt_t*)json)->_instsize); }
+static HAWK_INLINE void* hawk_json_getxtn (hawk_json_t* json) { return (void*)((hawk_uint8_t*)json + ((hawk_json_alt_t*)json)->instsize_); }
 
 /**
  * The hawk_json_getgem() function gets the pointer to the gem structure of the
  * json object.
  */
-static HAWK_INLINE hawk_gem_t* hawk_json_getgem (hawk_json_t* json) { return &((hawk_json_alt_t*)json)->_gem; }
+static HAWK_INLINE hawk_gem_t* hawk_json_getgem (hawk_json_t* json) { return &((hawk_json_alt_t*)json)->gem_; }
 
 /**
  * The hawk_json_getmmgr() function gets the memory manager ujson in
  * hawk_json_open().
  */
-static HAWK_INLINE hawk_mmgr_t* hawk_json_getmmgr (hawk_json_t* json) { return ((hawk_json_alt_t*)json)->_gem.mmgr; }
+static HAWK_INLINE hawk_mmgr_t* hawk_json_getmmgr (hawk_json_t* json) { return ((hawk_json_alt_t*)json)->gem_.mmgr; }
-static HAWK_INLINE hawk_cmgr_t* hawk_json_getcmgr (hawk_json_t* json) { return ((hawk_json_alt_t*)json)->_gem.cmgr; }
+static HAWK_INLINE hawk_cmgr_t* hawk_json_getcmgr (hawk_json_t* json) { return ((hawk_json_alt_t*)json)->gem_.cmgr; }
-static HAWK_INLINE void hawk_json_setcmgr (hawk_json_t* json, hawk_cmgr_t* cmgr) { ((hawk_json_alt_t*)json)->_gem.cmgr = cmgr; }
+static HAWK_INLINE void hawk_json_setcmgr (hawk_json_t* json, hawk_cmgr_t* cmgr) { ((hawk_json_alt_t*)json)->gem_.cmgr = cmgr; }
 #else
-#define hawk_json_getxtn(json) ((void*)((hawk_uint8_t*)json + ((hawk_json_alt_t*)json)->_instsize))
+#define hawk_json_getxtn(json) ((void*)((hawk_uint8_t*)json + ((hawk_json_alt_t*)json)->instsize_))
-#define hawk_json_getgem(json) (&((hawk_json_alt_t*)(json))->_gem)
+#define hawk_json_getgem(json) (&((hawk_json_alt_t*)(json))->gem_)
-#define hawk_json_getmmgr(json) (((hawk_json_alt_t*)(json))->_gem.mmgr)
+#define hawk_json_getmmgr(json) (((hawk_json_alt_t*)(json))->gem_.mmgr)
-#define hawk_json_getcmgr(json) (((hawk_json_alt_t*)(json))->_gem.cmgr)
+#define hawk_json_getcmgr(json) (((hawk_json_alt_t*)(json))->gem_.cmgr)
-#define hawk_json_setcmgr(json,_cmgr) (((hawk_json_alt_t*)(json))->_gem.cmgr = (_cmgr))
+#define hawk_json_setcmgr(json,_cmgr) (((hawk_json_alt_t*)(json))->gem_.cmgr = (_cmgr))
 #endif /* HAWK_HAVE_INLINE */
 
 /**

lib/hawk-prv.h

@@ -30,6 +30,7 @@
 #include <hawk-ecs.h>
 #include <hawk-fmt.h>
 #include <hawk-htb.h>
+#include <hawk-mtx.h>
 #include <hawk-rbt.h>
 #include <hawk-utl.h>
 
@@ -65,6 +66,13 @@ typedef struct hawk_tree_t hawk_tree_t;
  */
 #define HAWK_ENABLE_FUN_AS_VALUE
 
+#if defined(HAWK_ATOMIC_EXCHANGE) && \
+    defined(HAWK_ATOMIC_FETCH_OR) && \
+    defined(HAWK_ATOMIC_LOAD) && \
+    defined(HAWK_ATOMIC_STORE)
+#define HAWK_ENABLE_ATOMIC_SIG
+#endif
+
 /* ------------------------------------------------------------------------ */
 
 /* gc configuration */
@@ -569,6 +577,26 @@ struct hawk_rtx_t
 		hawk_oow_t capa;
 	} forin; /* keys for for (x in y) ... */
 
+#define HAWK_SIG_WORD_BITS (HAWK_SIZEOF_UINTPTR_T * 8)
+#define HAWK_SIG_WORD_COUNT ((HAWK_NSIG + HAWK_SIG_WORD_BITS - 1) / HAWK_SIG_WORD_BITS)
+
+	hawk_fun_t* sig_handler[HAWK_NSIG];
+	int sig_handling;
+#if defined(HAWK_ENABLE_ATOMIC_SIG)
+	hawk_uintptr_t sig_pending[HAWK_SIG_WORD_COUNT];
+	hawk_uintptr_t sig_pending_any;
+#else
+	hawk_mtx_t sig_mtx;
+	int sig_mtx_inited;
+	int sig_pending_any;
+	struct
+	{
+		int count;
+		int tab[HAWK_NSIG];
+		int pos[HAWK_NSIG];
+	} sig_raise[2];
+#endif
+
 	hawk_ooch_t errmsg_backup[HAWK_ERRMSG_CAPA];
 	hawk_rtx_ecb_t* ecb;
 };
@@ -645,7 +673,6 @@ static HAWK_INLINE void HAWK_RTX_STACK_POP (hawk_rtx_t* rtx)
 #endif
 
 
-
 #if defined(__cplusplus)
 extern "C" {
 #endif

lib/hawk-sed.h

@@ -62,8 +62,8 @@
 typedef struct hawk_sed_t hawk_sed_t;
 
 #define HAWK_SED_HDR \
-	hawk_oow_t _instsize; \
+	hawk_oow_t instsize_; \
-	hawk_gem_t _gem
+	hawk_gem_t gem_
 
 typedef struct hawk_sed_alt_t hawk_sed_alt_t;
 struct hawk_sed_alt_t
@@ -318,14 +318,11 @@ typedef void (*hawk_sed_ecb_close_t) (
 typedef struct hawk_sed_ecb_t hawk_sed_ecb_t;
 struct hawk_sed_ecb_t
 {
-	/**
+	hawk_sed_ecb_close_t close; /* called by hawk_sed_close() */
-	 * called by hawk_sed_close().
-	 */
-	hawk_sed_ecb_close_t close;
-	void* ctx;
 
-	/* internal use only. don't touch this field */
+	void* ctx; /* user context */
-	hawk_sed_ecb_t* next;
+
+	hawk_sed_ecb_t* next_; /* internal use only. don't touch this field */
 };
 
 enum hawk_sed_tracer_op_t
@@ -477,27 +474,27 @@ HAWK_EXPORT void hawk_sed_close (
  * The hawk_sed_getxtn() function returns the pointer to the extension area
  * placed behind the actual sed object.
  */
-static HAWK_INLINE void* hawk_sed_getxtn (hawk_sed_t* sed) { return (void*)((hawk_uint8_t*)sed + ((hawk_sed_alt_t*)sed)->_instsize); }
+static HAWK_INLINE void* hawk_sed_getxtn (hawk_sed_t* sed) { return (void*)((hawk_uint8_t*)sed + ((hawk_sed_alt_t*)sed)->instsize_); }
 
 /**
  * The hawk_sed_getgem() function gets the pointer to the gem structure of the
  * sed object.
  */
-static HAWK_INLINE hawk_gem_t* hawk_sed_getgem (hawk_sed_t* sed) { return &((hawk_sed_alt_t*)sed)->_gem; }
+static HAWK_INLINE hawk_gem_t* hawk_sed_getgem (hawk_sed_t* sed) { return &((hawk_sed_alt_t*)sed)->gem_; }
 
 /**
  * The hawk_sed_getmmgr() function gets the memory manager used in
  * hawk_sed_open().
  */
-static HAWK_INLINE hawk_mmgr_t* hawk_sed_getmmgr (hawk_sed_t* sed) { return ((hawk_sed_alt_t*)sed)->_gem.mmgr; }
+static HAWK_INLINE hawk_mmgr_t* hawk_sed_getmmgr (hawk_sed_t* sed) { return ((hawk_sed_alt_t*)sed)->gem_.mmgr; }
-static HAWK_INLINE hawk_cmgr_t* hawk_sed_getcmgr (hawk_sed_t* sed) { return ((hawk_sed_alt_t*)sed)->_gem.cmgr; }
+static HAWK_INLINE hawk_cmgr_t* hawk_sed_getcmgr (hawk_sed_t* sed) { return ((hawk_sed_alt_t*)sed)->gem_.cmgr; }
-static HAWK_INLINE void hawk_sed_setcmgr (hawk_sed_t* sed, hawk_cmgr_t* cmgr) { ((hawk_sed_alt_t*)sed)->_gem.cmgr = cmgr; }
+static HAWK_INLINE void hawk_sed_setcmgr (hawk_sed_t* sed, hawk_cmgr_t* cmgr) { ((hawk_sed_alt_t*)sed)->gem_.cmgr = cmgr; }
 #else
-#define hawk_sed_getxtn(sed) ((void*)((hawk_uint8_t*)sed + ((hawk_sed_alt_t*)sed)->_instsize))
+#define hawk_sed_getxtn(sed) ((void*)((hawk_uint8_t*)sed + ((hawk_sed_alt_t*)sed)->instsize_))
-#define hawk_sed_getgem(sed) (&((hawk_sed_alt_t*)(sed))->_gem)
+#define hawk_sed_getgem(sed) (&((hawk_sed_alt_t*)(sed))->gem_)
-#define hawk_sed_getmmgr(sed) (((hawk_sed_alt_t*)(sed))->_gem.mmgr)
+#define hawk_sed_getmmgr(sed) (((hawk_sed_alt_t*)(sed))->gem_.mmgr)
-#define hawk_sed_getcmgr(sed) (((hawk_sed_alt_t*)(sed))->_gem.cmgr)
+#define hawk_sed_getcmgr(sed) (((hawk_sed_alt_t*)(sed))->gem_.cmgr)
-#define hawk_sed_setcmgr(sed,_cmgr) (((hawk_sed_alt_t*)(sed))->_gem.cmgr = (_cmgr))
+#define hawk_sed_setcmgr(sed,_cmgr) (((hawk_sed_alt_t*)(sed))->gem_.cmgr = (_cmgr))
 #endif /* HAWK_HAVE_INLINE */
 
 

lib/hawk.c

@@ -159,17 +159,17 @@ int hawk_init (hawk_t* hawk, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr, const hawk_pr
 	HAWK_MEMSET(hawk, 0, HAWK_SIZEOF(*hawk));
 
 	/* remember the memory manager */
-	hawk->_instsize = HAWK_SIZEOF(*hawk);
+	hawk->instsize_ = HAWK_SIZEOF(*hawk);
-	hawk->_gem.mmgr = mmgr;
+	hawk->gem_.mmgr = mmgr;
-	hawk->_gem.cmgr = cmgr;
+	hawk->gem_.cmgr = cmgr;
 
 	/* initialize error handling fields */
-	hawk->_gem.errnum = HAWK_ENOERR;
+	hawk->gem_.errnum = HAWK_ENOERR;
-	hawk->_gem.errmsg[0] = '\0';
+	hawk->gem_.errmsg[0] = '\0';
-	hawk->_gem.errloc.line = 0;
+	hawk->gem_.errloc.line = 0;
-	hawk->_gem.errloc.colm = 0;
+	hawk->gem_.errloc.colm = 0;
-	hawk->_gem.errloc.file = HAWK_NULL;
+	hawk->gem_.errloc.file = HAWK_NULL;
-	hawk->_gem.errstr = hawk_dfl_errstr;
+	hawk->gem_.errstr = hawk_dfl_errstr;
 	hawk->haltall = 0;
 	hawk->ecb = (hawk_ecb_t*)hawk; /* use this as a sentinel node instead of HAWK_NULL */
 
@@ -309,7 +309,7 @@ void hawk_fini (hawk_t* hawk)
 
 	for (ecb = hawk->ecb; ecb != (hawk_ecb_t*)hawk; ecb = ecb_next)
 	{
-		ecb_next = ecb->next;
+		ecb_next = ecb->next_;
 		if (ecb->close) ecb->close(hawk, ecb->ctx);
 	}
 
@@ -392,7 +392,7 @@ void hawk_clear (hawk_t* hawk)
 
 	for (ecb = hawk->ecb; ecb != (hawk_ecb_t*)hawk; ecb = ecb_next)
 	{
-		ecb_next = ecb->next;
+		ecb_next = ecb->next_;
 		if (ecb->clear) ecb->clear(hawk, ecb->ctx);
 	}
 	/* hawk_clear() this doesn't pop event callbacks */
@@ -613,14 +613,15 @@ void hawk_haltall (hawk_t* hawk)
 
 void hawk_killecb (hawk_t* hawk, hawk_ecb_t* ecb)
 {
+	/* TODO: make it faster with doubly-linked list? */
 	hawk_ecb_t* prev, * cur;
-	for (cur = hawk->ecb, prev = HAWK_NULL; cur != (hawk_ecb_t*)hawk; cur = cur->next)
+	for (cur = hawk->ecb, prev = HAWK_NULL; cur != (hawk_ecb_t*)hawk; prev = cur, cur = cur->next_)
 	{
 		if (cur == ecb)
 		{
-			if (prev) prev->next = cur->next;
+			if (prev) prev->next_ = cur->next_;
-			else hawk->ecb = cur->next;
+			else hawk->ecb = cur->next_;
-			cur->next = HAWK_NULL;
+			cur->next_ = HAWK_NULL;
 			break;
 		}
 	}
@@ -630,14 +631,14 @@ hawk_ecb_t* hawk_popecb (hawk_t* hawk)
 {
 	hawk_ecb_t* top = hawk->ecb;
 	if (top == (hawk_ecb_t*)hawk) return HAWK_NULL;
-	hawk->ecb = top->next;
+	hawk->ecb = top->next_;
-	top->next = HAWK_NULL;
+	top->next_ = HAWK_NULL;
 	return top;
 }
 
 void hawk_pushecb (hawk_t* hawk, hawk_ecb_t* ecb)
 {
-	ecb->next = hawk->ecb;
+	ecb->next_ = hawk->ecb;
 	hawk->ecb = ecb;
 }
 

lib/hawk.h

@@ -75,8 +75,8 @@
  * \sa hawk_rtx_t hawk_open hawk_close
  */
 #define HAWK_HDR \
-	hawk_oow_t _instsize; \
+	hawk_oow_t instsize_; \
-	hawk_gem_t _gem
+	hawk_gem_t gem_
 
 typedef struct hawk_alt_t hawk_alt_t;
 struct hawk_alt_t
@@ -113,8 +113,8 @@ struct hawk_alt_t
 typedef struct hawk_rtx_t hawk_rtx_t;
 
 #define HAWK_RTX_HDR \
-	hawk_oow_t _instsize; \
+	hawk_oow_t instsize_; \
-	hawk_gem_t _gem; \
+	hawk_gem_t gem_; \
 	int id; \
 	hawk_t* hawk
 
@@ -133,7 +133,7 @@ struct hawk_gch_t
 {
 	hawk_gch_t* gc_prev;
 	hawk_gch_t* gc_next;
-	hawk_uintptr_t  gc_refs;
+	hawk_uintptr_t gc_refs;
 };
 
 #if defined(HAWK_HAVE_INLINE)
@@ -1171,11 +1171,11 @@ struct hawk_ecb_t
 	 */
 	hawk_ecb_clear_t clear;
 
-
+	/* user context */
 	void* ctx;
 
-	/* internal use only. don't touch this field */
+	 /* internal use only. don't touch this field */
-	hawk_ecb_t* next;
+	hawk_ecb_t* next_;
 };
 
 /* ------------------------------------------------------------------------ */
@@ -1213,6 +1213,18 @@ typedef void (*hawk_rtx_ecb_gblset_t) (
 	void*           ctx
 );
 
+/**
+ * The hawk_rtx_ecb_sigset_t type defines the callback function
+ * executed when the sys::signal() function attempts to set or unset
+ * the signal handler for the given signal number. If the \a fun
+ * is #HAWK_NULL, it unsets the signal handler.
+ */
+typedef void (*hawk_rtx_ecb_sigset_t) (
+	hawk_rtx_t*     rtx,
+	int             sig,
+	hawk_fun_t*     fun
+);
+
 /**
  * The hawk_rtx_ecb_t type defines an event callback set for a
  * runtime context. You can register a callback function set with
@@ -1238,10 +1250,20 @@ struct hawk_rtx_ecb_t
 	 */
 	hawk_rtx_ecb_gblset_t gblset;
 
+	/**
+	 * called when a signal handler is set/unset with sys::signal().
+	 * you should implement this callback to support OS signal handling.
+	 * because the core hawk library provides the virtual interface
+	 * to signal handling but doesn't deal with the OS signals.
+	 * however, it's still modeled after the unix-style signal handling.
+	 */
+	hawk_rtx_ecb_sigset_t sigset;
+
+	/* user context */
 	void* ctx;
 
 	/* internal use only. don't touch this field */
-	hawk_rtx_ecb_t* next;
+	hawk_rtx_ecb_t* next_;
 };
 
 /* ------------------------------------------------------------------------ */
@@ -1710,17 +1732,17 @@ HAWK_EXPORT void hawk_close (
 );
 
 #if defined(HAWK_HAVE_INLINE)
-static HAWK_INLINE void* hawk_getxtn (hawk_t* hawk) { return (void*)((hawk_uint8_t*)hawk + ((hawk_alt_t*)hawk)->_instsize); }
+static HAWK_INLINE void* hawk_getxtn (hawk_t* hawk) { return (void*)((hawk_uint8_t*)hawk + ((hawk_alt_t*)hawk)->instsize_); }
-static HAWK_INLINE hawk_gem_t* hawk_getgem (hawk_t* hawk) { return &((hawk_alt_t*)hawk)->_gem; }
+static HAWK_INLINE hawk_gem_t* hawk_getgem (hawk_t* hawk) { return &((hawk_alt_t*)hawk)->gem_; }
-static HAWK_INLINE hawk_mmgr_t* hawk_getmmgr (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->_gem.mmgr; }
+static HAWK_INLINE hawk_mmgr_t* hawk_getmmgr (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->gem_.mmgr; }
-static HAWK_INLINE hawk_cmgr_t* hawk_getcmgr (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->_gem.cmgr; }
+static HAWK_INLINE hawk_cmgr_t* hawk_getcmgr (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->gem_.cmgr; }
-static HAWK_INLINE void hawk_setcmgr (hawk_t* hawk, hawk_cmgr_t* cmgr) { ((hawk_alt_t*)hawk)->_gem.cmgr = cmgr; }
+static HAWK_INLINE void hawk_setcmgr (hawk_t* hawk, hawk_cmgr_t* cmgr) { ((hawk_alt_t*)hawk)->gem_.cmgr = cmgr; }
 #else
-#define hawk_getxtn(hawk) ((void*)((hawk_uint8_t*)hawk + ((hawk_alt_t*)hawk)->_instsize))
+#define hawk_getxtn(hawk) ((void*)((hawk_uint8_t*)hawk + ((hawk_alt_t*)hawk)->instsize_))
 #define hawk_getgem(hawk) (&((hawk_alt_t*)(hawk))->_gem)
-#define hawk_getmmgr(hawk) (((hawk_alt_t*)(hawk))->_gem.mmgr)
+#define hawk_getmmgr(hawk) (((hawk_alt_t*)(hawk))->gem_.mmgr)
-#define hawk_getcmgr(hawk) (((hawk_alt_t*)(hawk))->_gem.cmgr)
+#define hawk_getcmgr(hawk) (((hawk_alt_t*)(hawk))->gem_.cmgr)
-#define hawk_setcmgr(hawk,_cmgr) (((hawk_alt_t*)(hawk))->_gem.cmgr = (_cmgr))
+#define hawk_setcmgr(hawk,_cmgr) (((hawk_alt_t*)(hawk))->gem_.cmgr = (_cmgr))
 #endif /* HAWK_HAVE_INLINE */
 
 /**
@@ -1791,14 +1813,14 @@ HAWK_EXPORT hawk_errstr_t hawk_geterrstr (
  */
 
 #if defined(HAWK_HAVE_INLINE)
-static HAWK_INLINE hawk_errnum_t hawk_geterrnum (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->_gem.errnum; }
+static HAWK_INLINE hawk_errnum_t hawk_geterrnum (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->gem_.errnum; }
 static HAWK_INLINE const hawk_loc_t* hawk_geterrloc (hawk_t* hawk) { return hawk_gem_geterrloc(hawk_getgem(hawk)); }
 static HAWK_INLINE const hawk_bch_t* hawk_geterrbmsg (hawk_t* hawk) { return hawk_gem_geterrbmsg(hawk_getgem(hawk)); }
 static HAWK_INLINE const hawk_uch_t* hawk_geterrumsg (hawk_t* hawk) { return hawk_gem_geterrumsg(hawk_getgem(hawk)); }
 static HAWK_INLINE void hawk_geterrbinf (hawk_t* hawk, hawk_errbinf_t* errinf) { return hawk_gem_geterrbinf(hawk_getgem(hawk), errinf); }
 static HAWK_INLINE void hawk_geterruinf (hawk_t* hawk, hawk_erruinf_t* errinf) { return hawk_gem_geterruinf(hawk_getgem(hawk), errinf); }
 #else
-#define hawk_geterrnum(hawk) (((hawk_alt_t*)(hawk))->_gem.errnum)
+#define hawk_geterrnum(hawk) (((hawk_alt_t*)(hawk))->gem_.errnum)
 #define hawk_geterrloc(hawk) (hawk_gem_geterrloc(hawk_getgem(hawk)))
 #define hawk_geterrbmsg(hawk) (hawk_gem_geterrbmsg(hawk_getgem(hawk)))
 #define hawk_geterrumsg(hawk) (hawk_gem_geterrumsg(hawk_getgem(hawk)))
@@ -2493,18 +2515,18 @@ HAWK_EXPORT void hawk_rtx_close (
 
 #if defined(HAWK_HAVE_INLINE)
 static HAWK_INLINE hawk_t* hawk_rtx_gethawk (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->hawk; }
-static HAWK_INLINE void* hawk_rtx_getxtn (hawk_rtx_t* rtx) { return (void*)((hawk_uint8_t*)rtx + ((hawk_rtx_alt_t*)rtx)->_instsize); }
+static HAWK_INLINE void* hawk_rtx_getxtn (hawk_rtx_t* rtx) { return (void*)((hawk_uint8_t*)rtx + ((hawk_rtx_alt_t*)rtx)->instsize_); }
-static HAWK_INLINE hawk_gem_t* hawk_rtx_getgem (hawk_rtx_t* rtx) { return &((hawk_rtx_alt_t*)rtx)->_gem; }
+static HAWK_INLINE hawk_gem_t* hawk_rtx_getgem (hawk_rtx_t* rtx) { return &((hawk_rtx_alt_t*)rtx)->gem_; }
-static HAWK_INLINE hawk_mmgr_t* hawk_rtx_getmmgr (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->_gem.mmgr; }
+static HAWK_INLINE hawk_mmgr_t* hawk_rtx_getmmgr (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->gem_.mmgr; }
-static HAWK_INLINE hawk_cmgr_t* hawk_rtx_getcmgr (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->_gem.cmgr; }
+static HAWK_INLINE hawk_cmgr_t* hawk_rtx_getcmgr (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->gem_.cmgr; }
-static HAWK_INLINE void hawk_rtx_setcmgr (hawk_rtx_t* rtx, hawk_cmgr_t* cmgr) { ((hawk_rtx_alt_t*)rtx)->_gem.cmgr = cmgr; }
+static HAWK_INLINE void hawk_rtx_setcmgr (hawk_rtx_t* rtx, hawk_cmgr_t* cmgr) { ((hawk_rtx_alt_t*)rtx)->gem_.cmgr = cmgr; }
 #else
 #define hawk_rtx_gethawk(rtx) (((hawk_rtx_alt_t*)(rtx))->hawk)
-#define hawk_rtx_getxtn(rtx) ((void*)((hawk_uint8_t*)rtx + ((hawk_rtx_alt_t*)rtx)->_instsize))
+#define hawk_rtx_getxtn(rtx) ((void*)((hawk_uint8_t*)rtx + ((hawk_rtx_alt_t*)rtx)->instsize_))
 #define hawk_rtx_getgem(rtx) (&((hawk_rtx_alt_t*)(rtx))->_gem)
-#define hawk_rtx_getmmgr(rtx) (((hawk_rtx_alt_t*)(rtx))->_gem.mmgr)
+#define hawk_rtx_getmmgr(rtx) (((hawk_rtx_alt_t*)(rtx))->gem_.mmgr)
-#define hawk_rtx_getcmgr(rtx) (((hawk_rtx_alt_t*)(rtx))->_gem.cmgr)
+#define hawk_rtx_getcmgr(rtx) (((hawk_rtx_alt_t*)(rtx))->gem_.cmgr)
-#define hawk_rtx_setcmgr(rtx,_cmgr) (((hawk_rtx_alt_t*)(rtx))->_gem.cmgr = (_cmgr))
+#define hawk_rtx_setcmgr(rtx,_cmgr) (((hawk_rtx_alt_t*)(rtx))->gem_.cmgr = (_cmgr))
 #endif /* HAWK_HAVE_INLINE */
 
 /**
@@ -2716,6 +2738,14 @@ HAWK_EXPORT void hawk_rtx_halt (
 	hawk_rtx_t* rtx /**< runtime context */
 );
 
+/**
+ * The hawk_rtx_raisesig() function raises a signal to an active runtime context.
+ */
+HAWK_EXPORT int hawk_rtx_raisesig (
+	hawk_rtx_t* rtx,
+	int         sig
+);
+
 /**
  * The hawk_rtx_getrio() function copies runtime I/O handlers
  * to the memory buffer pointed to by \a rio.
@@ -2921,14 +2951,14 @@ HAWK_EXPORT hawk_htb_t* hawk_rtx_getnvmap (
  */
 
 #if defined(HAWK_HAVE_INLINE)
-static HAWK_INLINE hawk_errnum_t hawk_rtx_geterrnum (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->_gem.errnum; }
+static HAWK_INLINE hawk_errnum_t hawk_rtx_geterrnum (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->gem_.errnum; }
 static HAWK_INLINE const hawk_loc_t* hawk_rtx_geterrloc (hawk_rtx_t* rtx) { return hawk_gem_geterrloc(hawk_rtx_getgem(rtx)); }
 static HAWK_INLINE const hawk_bch_t* hawk_rtx_geterrbmsg (hawk_rtx_t* rtx) { return hawk_gem_geterrbmsg(hawk_rtx_getgem(rtx)); }
 static HAWK_INLINE const hawk_uch_t* hawk_rtx_geterrumsg (hawk_rtx_t* rtx) { return hawk_gem_geterrumsg(hawk_rtx_getgem(rtx)); }
 static HAWK_INLINE void hawk_rtx_geterrinf (hawk_rtx_t* rtx, hawk_errinf_t* errinf) { return hawk_gem_geterrinf(hawk_rtx_getgem(rtx), errinf); }
 static HAWK_INLINE void hawk_rtx_geterror (hawk_rtx_t* rtx, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) { return hawk_gem_geterror(hawk_rtx_getgem(rtx), errnum, errmsg, errloc); }
 #else
-#define hawk_rtx_geterrnum(rtx) (((hawk_rtx_alt_t*)(rtx))->_gem.errnum)
+#define hawk_rtx_geterrnum(rtx) (((hawk_rtx_alt_t*)(rtx))->gem_.errnum)
 #define hawk_rtx_geterrloc(rtx) (hawk_gem_geterrloc(hawk_rtx_getgem(rtx)))
 #define hawk_rtx_geterrbmsg(rtx) (hawk_gem_geterrbmsg(hawk_rtx_getgem(rtx)))
 #define hawk_rtx_geterrumsg(rtx) (hawk_gem_geterrumsg(hawk_rtx_getgem(rtx)))

lib/json.c

@@ -204,7 +204,7 @@ static int handle_string_value_char (hawk_json_t* json, hawk_ooci_t c)
 				hawk_bch_t bcsbuf[HAWK_MBLEN_MAX];
 				hawk_oow_t n;
 
-				n = json->_gem.cmgr->uctobc(json->state_stack->u.sv.acc, bcsbuf, HAWK_COUNTOF(bcsbuf));
+				n = json->gem_.cmgr->uctobc(json->state_stack->u.sv.acc, bcsbuf, HAWK_COUNTOF(bcsbuf));
 				if (n == 0 || n > HAWK_COUNTOF(bcsbuf))
 				{
 					/* illegal character or buffer to small */
@@ -714,7 +714,7 @@ static int feed_json_data_b (hawk_json_t* json, const hawk_bch_t* data, hawk_oow
 		hawk_oow_t n;
 
 		bcslen = end - ptr;
-		n = json->_gem.cmgr->bctouc(ptr, bcslen, &uc);
+		n = json->gem_.cmgr->bctouc(ptr, bcslen, &uc);
 		if (n == 0)
 		{
 			/* invalid sequence */
@@ -770,7 +770,7 @@ static int feed_json_data_u (hawk_json_t* json, const hawk_uch_t* data, hawk_oow
 		hawk_oow_t mlen = 0;
 		hawk_oow_t n, i;
 
-		n = json->_gem.cmgr->uctobc(*ptr++, bcsbuf, HAWK_COUNTOF(bcsbuf));
+		n = json->gem_.cmgr->uctobc(*ptr++, bcsbuf, HAWK_COUNTOF(bcsbuf));
 		if (n == 0) goto oops; // illegal character
 
 		for (i = 0; i < n; i++)
@@ -809,17 +809,17 @@ hawk_json_t* hawk_json_open (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t*
 	}
 
 	HAWK_MEMSET(json, 0, HAWK_SIZEOF(*json) + xtnsize);
-	json->_instsize = HAWK_SIZEOF(*json);
+	json->instsize_ = HAWK_SIZEOF(*json);
-	json->_gem.mmgr = mmgr;
+	json->gem_.mmgr = mmgr;
-	json->_gem.cmgr = cmgr;
+	json->gem_.cmgr = cmgr;
 
 	/* initialize error handling fields */
-	json->_gem.errnum = HAWK_ENOERR;
+	json->gem_.errnum = HAWK_ENOERR;
-	json->_gem.errmsg[0] = '\0';
+	json->gem_.errmsg[0] = '\0';
-	json->_gem.errloc.line = 0;
+	json->gem_.errloc.line = 0;
-	json->_gem.errloc.colm = 0;
+	json->gem_.errloc.colm = 0;
-	json->_gem.errloc.file = HAWK_NULL;
+	json->gem_.errloc.file = HAWK_NULL;
-	json->_gem.errstr = hawk_dfl_errstr;
+	json->gem_.errstr = hawk_dfl_errstr;
 
 	json->prim = *prim;
 	json->state_top.state = HAWK_JSON_STATE_START;
@@ -866,7 +866,7 @@ int hawk_json_getoption (hawk_json_t* json, hawk_json_option_t id, void* value)
 
 hawk_errstr_t hawk_json_geterrstr (hawk_json_t* json)
 {
-	return json->_gem.errstr;
+	return json->gem_.errstr;
 }
 
 void hawk_json_seterrbfmt (hawk_json_t* json, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* fmt, ...)

lib/mod-hawk.c

@@ -26,7 +26,6 @@
 #include "hawk-prv.h"
 #include <hawk-mtx.h>
 
-
 struct mod_data_t
 {
 	hawk_mtx_t mq_mtx;

lib/mod-sys.c

@@ -129,6 +129,8 @@ enum syslog_type_t
 	SYSLOG_REMOTE,
 };
 
+typedef struct rtx_data_t rtx_data_t;
+
 struct mod_ctx_t
 {
 	hawk_rbt_t* rtxtab;
@@ -137,6 +139,18 @@ typedef struct mod_ctx_t mod_ctx_t;
 
 /* ------------------------------------------------------------------------ */
 
+#if defined(HAWK_NSIG)
+#	define SYS_NSIG HAWK_NSIG
+#elif defined(NSIG)
+#	define SYS_NSIG NSIG
+#elif defined(SIGRTMAX)
+#	define SYS_NSIG (SIGRTMAX + 1)
+#else
+#	define SYS_NSIG 64
+#endif
+
+typedef void (*hawk_sig_handler_t)(int);
+
 enum sys_node_data_type_t
 {
 	SYS_NODE_DATA_TYPE_FILE = (1 << 0),
@@ -212,6 +226,7 @@ typedef struct sys_list_data_t sys_list_data_t;
 struct rtx_data_t
 {
 	sys_list_t sys_list;
+	mod_ctx_t* mctx;
 
 	struct
 	{
@@ -221,7 +236,6 @@ struct rtx_data_t
 		hawk_oow_t len;
 	} pack;
 
-
 	/* syslog data */
 	struct
 	{
@@ -235,8 +249,6 @@ struct rtx_data_t
 		hawk_becs_t* dmsgbuf;
 	} log;
 };
-typedef struct rtx_data_t rtx_data_t;
-
 enum mux_ctl_cmd_t
 {
 #if defined(USE_EPOLL)
@@ -2048,8 +2060,85 @@ static int fnc_kill (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	}
 
 	retv = hawk_rtx_makeintval(rtx, rx);
-	if (retv == HAWK_NULL) return -1;
+	if (HAWK_UNLIKELY(!retv)) return -1;
+	hawk_rtx_setretval(rtx, retv);
+	return 0;
+}
 
+static int fnc_signal (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	hawk_int_t sig;
+	hawk_val_t* retv;
+	hawk_val_t* a1;
+	hawk_int_t rx = -1;
+	sys_list_t* sys_list = rtx_to_sys_list(rtx, fi);
+	hawk_fun_t* fun = HAWK_NULL;
+
+	if (hawk_rtx_valtoint(rtx, hawk_rtx_getarg(rtx, 0), &sig) <= -1)
+	{
+		rx = copy_error_to_sys_list(rtx, sys_list);
+		goto done;
+	}
+
+	if (sig < 0)
+	{
+		rx = set_error_on_sys_list(rtx, sys_list, HAWK_EINVAL, HAWK_T("invalid signal"));
+		goto done;
+	}
+
+	a1 = hawk_rtx_getarg(rtx, 1);
+	if (HAWK_RTX_GETVALTYPE(rtx, a1) == HAWK_VAL_NIL)
+	{
+		fun = HAWK_NULL;
+	}
+	else
+	{
+		fun = hawk_rtx_valtofun(rtx, a1);
+		if (!fun)
+		{
+			rx = copy_error_to_sys_list(rtx, sys_list);
+			goto done;
+		}
+	}
+
+	if (hawk_rtx_setsighandler(rtx, sig, fun) <= -1)
+	{
+		rx = copy_error_to_sys_list(rtx, sys_list);
+		goto done;
+	}
+
+	rx = 0;
+
+done:
+	retv = hawk_rtx_makeintval(rtx, rx);
+	if (HAWK_UNLIKELY(!retv)) return -1;
+	hawk_rtx_setretval(rtx, retv);
+	return 0;
+}
+
+static int fnc_raise (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	hawk_int_t sig;
+	hawk_val_t* retv;
+	hawk_int_t rx = -1;
+	sys_list_t* sys_list = rtx_to_sys_list(rtx, fi);
+
+	if (hawk_rtx_valtoint(rtx, hawk_rtx_getarg(rtx, 0), &sig) <= -1)
+	{
+		rx = copy_error_to_sys_list(rtx, sys_list);
+		goto done;
+	}
+
+	if (hawk_rtx_raisesig(rtx, sig) <= -1)
+	{
+		rx = copy_error_to_sys_list(rtx, sys_list);
+		goto done;
+	}
+	rx = 0;
+
+done:
+	retv = hawk_rtx_makeintval(rtx, rx);
+	if (HAWK_UNLIKELY(!retv)) return -1;
 	hawk_rtx_setretval(rtx, retv);
 	return 0;
 }
@@ -2901,7 +2990,6 @@ static int fnc_getifcfg (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	if (hawk_rtx_valtostr(rtx, hawk_rtx_getarg(rtx, 0), &out) >= 0)
 	{
 		hawk_int_t type;
-		hawk_int_t index, mtu;
 		hawk_ooch_t ethw[32];
 		hawk_val_map_data_t md[6];
 		hawk_oow_t md_count;
@@ -3941,7 +4029,7 @@ static int fnc_getmuxevt (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	{
 		sys_node_data_mux_t* mux_data = &sys_node->ctx.u.mux;
 		sys_node_t* file_node;
-		hawk_int_t index, id, evts;
+		hawk_int_t index;
 		int x;
 
 		if (hawk_rtx_valtoint(rtx, hawk_rtx_getarg(rtx, 1), &index) <= -1)
@@ -4368,7 +4456,11 @@ static int fnc_accept (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 		hawk_skad_t skad;
 		socklen_t addrlen;
 		sys_node_t* new_node;
+	#if defined(HAVE_ACCEPT4)
+		int fd;
+	#else
 		int fd, fd_flags;
+	#endif
 		hawk_int_t flags = 0;
 
 		if (hawk_rtx_getnargs(rtx) >= 2 && (hawk_rtx_valtoint(rtx, hawk_rtx_getarg(rtx, 1), &flags) <= -1 || flags < 0)) flags = 0;
@@ -5971,6 +6063,7 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("openmux"),     { { 0, 0, HAWK_NULL       }, fnc_openmux,     0  } },
 	{ HAWK_T("pack"),        { { 2, A_MAX, HAWK_T("rv")}, fnc_pack,        0 } },
 	{ HAWK_T("pipe"),        { { 2, 3, HAWK_T("rrv")   }, fnc_pipe,        0  } },
+	{ HAWK_T("raise"),       { { 1, 1, HAWK_NULL       }, fnc_raise,       0  } },
 	{ HAWK_T("read"),        { { 2, 4, HAWK_T("vrvv")  }, fnc_read,        0  } },
 	{ HAWK_T("readdir"),     { { 2, 2, HAWK_T("vr")    }, fnc_readdir,     0  } },
 	{ HAWK_T("recvfrom"),    { { 2, 4, HAWK_T("vrvr")  }, fnc_recvfrom,    0  } },
@@ -5981,6 +6074,7 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("setsockopt"),  { { 4, 4, HAWK_NULL       }, fnc_setsockopt,  0  } },
 	{ HAWK_T("settime"),     { { 1, 1, HAWK_NULL       }, fnc_settime,     0  } },
 	{ HAWK_T("shutdown"),    { { 2, 2, HAWK_NULL       }, fnc_shutdown,    0  } },
+	{ HAWK_T("signal"),      { { 2, 2, HAWK_NULL       }, fnc_signal,      0  } },
 	{ HAWK_T("sleep"),       { { 1, 1, HAWK_NULL       }, fnc_sleep,       0  } },
 	{ HAWK_T("sockaddrdom"), { { 1, 1, HAWK_NULL       }, fnc_sockaddrdom, 0  } },
 	{ HAWK_T("socket"),      { { 3, 3, HAWK_NULL       }, fnc_socket,      0  } },
@@ -6351,6 +6445,7 @@ static int init (hawk_mod_t* mod, hawk_rtx_t* rtx)
 
 	rdp = (rtx_data_t*)HAWK_RBT_VPTR(pair);
 	__init_sys_list(rtx, &rdp->sys_list);
+	rdp->mctx = mctx;
 
 	rdp->pack.ptr = rdp->pack.__static_buf;
 	rdp->pack.capa = HAWK_COUNTOF(rdp->pack.__static_buf);
@@ -6441,6 +6536,7 @@ static void unload (hawk_mod_t* mod, hawk_t* hawk)
 	mod_ctx_t* mctx = (mod_ctx_t*)mod->ctx;
 
 	HAWK_ASSERT(HAWK_RBT_SIZE(mctx->rtxtab) == 0);
+	HAWK_ASSERT(mctx->sig_rtx_head == HAWK_NULL);
 	hawk_rbt_close(mctx->rtxtab);
 
 	hawk_freemem(hawk, mctx);
@@ -6449,6 +6545,7 @@ static void unload (hawk_mod_t* mod, hawk_t* hawk)
 int hawk_mod_sys (hawk_mod_t* mod, hawk_t* hawk)
 {
 	hawk_rbt_t* rbt;
+	mod_ctx_t* mctx;
 
 	mod->query = query;
 	mod->unload = unload;
@@ -6456,17 +6553,20 @@ int hawk_mod_sys (hawk_mod_t* mod, hawk_t* hawk)
 	mod->init = init;
 	mod->fini = fini;
 
-	mod->ctx = hawk_callocmem(hawk, HAWK_SIZEOF(mod_ctx_t));
+	mctx = (mod_ctx_t*)hawk_callocmem(hawk, HAWK_SIZEOF(mod_ctx_t));
-	if (HAWK_UNLIKELY(!mod->ctx)) return -1;
+	if (HAWK_UNLIKELY(!mctx)) return -1;
 
 	rbt = hawk_rbt_open(hawk_getgem(hawk), 0, 1, 1);
 	if (HAWK_UNLIKELY(!rbt))
 	{
-		hawk_freemem(hawk, mod->ctx);
+		hawk_freemem(hawk, mctx);
 		return -1;
 	}
 	hawk_rbt_setstyle(rbt, hawk_get_rbt_style(HAWK_RBT_STYLE_INLINE_COPIERS));
 
-	((mod_ctx_t*)mod->ctx)->rtxtab = rbt;
+	mctx->rtxtab = rbt;
+
+	/* attach the context to the module */
+	mod->ctx = mctx;
 	return 0;
 }

lib/parse.c

@@ -447,7 +447,7 @@ static global_t gtab[] =
 #define MATCH_TERMINATOR(hawk) \
 	(MATCH_TERMINATOR_NORMAL(hawk) || MATCH_TERMINATOR_RBRACE(hawk))
 
-#define ADJERR_LOC(hawk,l) do { if (l) (hawk)->_gem.errloc = *(l); } while (0)
+#define ADJERR_LOC(hawk,l) do { if (l) (hawk)->gem_.errloc = *(l); } while (0)
 
 #if defined(HAWK_OOCH_IS_BCH)
 static HAWK_INLINE hawk_oow_t uc_to_utf8 (hawk_uch_t uc, hawk_bch_t* buf, hawk_oow_t bsz)

lib/run-prv.h

@@ -149,6 +149,12 @@ hawk_val_t* hawk_rtx_evalcall (
 	void* eharg
 );
 
+int hawk_rtx_setsighandler (
+	hawk_rtx_t* rtx,
+	int         sig,
+	hawk_fun_t* fun
+);
+
 #if defined(__cplusplus)
 }
 #endif

lib/run.c

@@ -24,11 +24,10 @@
 
 #include "hawk-prv.h"
 
-#define PRINT_IOERR -99
+#define PRINT_IOERR (-99)
-
+#define CMP_ERROR (-99)
-#define CMP_ERROR -99
+#define DEF_BUF_CAPA (256)
-#define DEF_BUF_CAPA 256
+#define HAWK_RTX_STACK_INCREMENT (512)
-#define HAWK_RTX_STACK_INCREMENT 512
 
 enum exit_level_t
 {
@@ -69,7 +68,7 @@ struct pafv_t
 	 (idx) <= HAWK_TYPE_MAX(hawk_oow_t))
 
 #define CLRERR(rtx) hawk_rtx_seterrnum(rtx, HAWK_NULL, HAWK_ENOERR)
-#define ADJERR_LOC(rtx,l) do { (rtx)->_gem.errloc = *(l); } while (0)
+#define ADJERR_LOC(rtx,l) do { (rtx)->gem_.errloc = *(l); } while (0)
 
 static hawk_oow_t push_arg_from_vals (hawk_rtx_t* rtx, hawk_nde_fncall_t* call, void* data);
 static hawk_oow_t push_arg_from_nde (hawk_rtx_t* rtx, hawk_nde_fncall_t* call, void* data);
@@ -634,7 +633,7 @@ static int set_global (hawk_rtx_t* rtx, int idx, hawk_nde_var_t* var, hawk_val_t
 
 	for (ecb = rtx->ecb; ecb != (hawk_rtx_ecb_t*)rtx; ecb = ecb_next)
 	{
-		ecb_next = ecb->next;
+		ecb_next = ecb->next_;
 		if (ecb->gblset) ecb->gblset(rtx, idx, val, ecb->ctx);
 	}
 
@@ -870,7 +869,7 @@ hawk_rtx_t* hawk_rtx_open (hawk_t* hawk, hawk_oow_t xtnsize, hawk_rio_cbs_t* rio
 
 	/* initialize the rtx object */
 	HAWK_MEMSET(rtx, 0, HAWK_SIZEOF(hawk_rtx_t) + xtnsize);
-	rtx->_instsize = HAWK_SIZEOF(hawk_rtx_t);
+	rtx->instsize_ = HAWK_SIZEOF(hawk_rtx_t);
 	if (HAWK_UNLIKELY(init_rtx(rtx, hawk, rio) <= -1))
 	{
 		/* because the error information is in the gem part,
@@ -883,6 +882,25 @@ hawk_rtx_t* hawk_rtx_open (hawk_t* hawk, hawk_oow_t xtnsize, hawk_rio_cbs_t* rio
 
 	rtx->ecb = (hawk_rtx_ecb_t*)rtx; /* use this as a special sentinel node */
 
+	/* initialize signal handling fields */
+	rtx->sig_handling = 0; /* indicate call_signal_handlers() is not in progress */
+	rtx->sig_pending_any = 0;
+#if defined(HAWK_ENABLE_ATOMIC_SIG)
+	for (i = 0; i < HAWK_SIG_WORD_COUNT; i++) rtx->sig_pending[i] = 0;
+#else
+	if (HAWK_UNLIKELY(hawk_mtx_init(&rtx->sig_mtx, hawk_rtx_getgem(rtx)) <= -1))
+	{
+		hawk_rtx_errortohawk(rtx, hawk);
+		fini_rtx(rtx, 0);
+		hawk_freemem(hawk, rtx);
+		return HAWK_NULL;
+	}
+	rtx->sig_mtx_inited = 1;
+	rtx->sig_raise[0].count = 0;
+	for (i = 0; i < HAWK_COUNTOF(rtx->sig_raise[0].pos); i++) rtx->sig_raise[0].pos[i] = -1;
+#endif
+
+	/* global variables */
 	if (HAWK_UNLIKELY(init_globals(rtx) <= -1))
 	{
 		hawk_rtx_errortohawk(rtx, hawk);
@@ -944,7 +962,7 @@ void hawk_rtx_close (hawk_rtx_t* rtx)
 
 	for (ecb = rtx->ecb; ecb != (hawk_rtx_ecb_t*)rtx; ecb = ecb_next)
 	{
-		ecb_next = ecb->next;
+		ecb_next = ecb->next_;
 		if (ecb->close) ecb->close(rtx, ecb->ctx);
 	}
 
@@ -988,14 +1006,15 @@ void hawk_rtx_setrio (hawk_rtx_t* rtx, const hawk_rio_cbs_t* rio)
 
 void hawk_rtx_killecb (hawk_rtx_t* rtx, hawk_rtx_ecb_t* ecb)
 {
+	/* TODO: make it faster with doubly-linked list? */
 	hawk_rtx_ecb_t* prev, * cur;
-	for (cur = rtx->ecb, prev = HAWK_NULL; cur != (hawk_rtx_ecb_t*)rtx; cur = cur->next)
+	for (cur = rtx->ecb, prev = HAWK_NULL; cur != (hawk_rtx_ecb_t*)rtx; prev = cur, cur = cur->next_)
 	{
 		if (cur == ecb)
 		{
-			if (prev) prev->next = cur->next;
+			if (prev) prev->next_ = cur->next_;
-			else rtx->ecb = cur->next;
+			else rtx->ecb = cur->next_;
-			cur->next = HAWK_NULL;
+			cur->next_ = HAWK_NULL;
 			break;
 		}
 	}
@@ -1005,14 +1024,14 @@ hawk_rtx_ecb_t* hawk_rtx_popecb (hawk_rtx_t* rtx)
 {
 	hawk_rtx_ecb_t* top = rtx->ecb;
 	if (top == (hawk_rtx_ecb_t*)rtx) return HAWK_NULL;
-	rtx->ecb = top->next;
+	rtx->ecb = top->next_;
-	top->next = HAWK_NULL;
+	top->next_ = HAWK_NULL;
 	return top;
 }
 
 void hawk_rtx_pushecb (hawk_rtx_t* rtx, hawk_rtx_ecb_t* ecb)
 {
-	ecb->next = rtx->ecb;
+	ecb->next_ = rtx->ecb;
 	rtx->ecb = ecb;
 }
 
@@ -1045,7 +1064,7 @@ static int init_rtx (hawk_rtx_t* rtx, hawk_t* hawk, hawk_rio_cbs_t* rio)
 	};
 	hawk_oow_t stack_limit, i;
 
-	rtx->_gem = hawk->_gem;
+	rtx->gem_ = hawk->gem_;
 	rtx->hawk = hawk;
 
 	CLRERR(rtx);
@@ -1176,6 +1195,14 @@ oops_0:
 
 static void fini_rtx (hawk_rtx_t* rtx, int fini_globals)
 {
+#if !defined(HAWK_ENABLE_ATOMIC_SIG)
+	if (rtx->sig_mtx_inited)
+	{
+		hawk_mtx_fini(&rtx->sig_mtx);
+		rtx->sig_mtx_inited = 0;
+	}
+#endif
+
 	if (rtx->forin.ptr)
 	{
 		while (rtx->forin.size > 0)
@@ -2249,11 +2276,205 @@ static int run_block (hawk_rtx_t* rtx, hawk_nde_blk_t* nde)
 	return n;
 }
 
+/* ========================================================================= */
+
+int hawk_rtx_raisesig(hawk_rtx_t* rtx, int sig)
+{
+	if (sig < 0 || sig >= HAWK_COUNTOF(rtx->sig_handler))
+	{
+		hawk_rtx_seterrbfmt(rtx, HAWK_NULL, HAWK_EINVAL, "invalid signal number %d", sig);
+		return -1;
+	}
+
+	/* i assume the sys::signal() is called from the same thread as
+	 * the main runtime context. so i don't use atomic or mutex on
+	 * rtx->sig_handler. */
+	if (!rtx->sig_handler[sig]) return -1; /* no handler installed */
+
+#if defined(HAWK_ENABLE_ATOMIC_SIG)
+	{
+		hawk_uintptr_t bit;
+		hawk_uintptr_t* word;
+		int widx;
+
+		widx = sig / HAWK_SIG_WORD_BITS;
+		bit = ((hawk_uintptr_t)1) << (sig % HAWK_SIG_WORD_BITS);
+		word = &rtx->sig_pending[widx];
+		(void)HAWK_ATOMIC_FETCH_OR(word, bit, HAWK_ATOMIC_RELAXED);
+		HAWK_ATOMIC_STORE(&rtx->sig_pending_any, 1, HAWK_ATOMIC_RELAXED);
+	}
+#else
+	{
+		int pos;
+		hawk_mtx_lock(&rtx->sig_mtx, HAWK_NULL);
+		if (rtx->sig_raise[0].pos[sig] >= 0)
+		{
+			/* already raised */
+			hawk_mtx_unlock(&rtx->sig_mtx);
+			return 0;
+		}
+		pos = rtx->sig_raise[0].count;
+		rtx->sig_raise[0].pos[sig] = pos;
+		rtx->sig_raise[0].tab[pos] = sig;
+		rtx->sig_raise[0].count++;
+	#if defined(HAWK_ATOMIC_STORE)
+		HAWK_ATOMIC_STORE(&rtx->sig_pending_any, 1, HAWK_ATOMIC_RELAXED);
+	#else
+		rtx->sig_pending_any = 1;
+	#endif
+		hawk_mtx_unlock(&rtx->sig_mtx);
+	}
+#endif
+
+	return 0;
+}
+
+int hawk_rtx_setsighandler (hawk_rtx_t* rtx, int sig, hawk_fun_t* fun)
+{
+	hawk_rtx_ecb_t* ecb, * ecb_next;
+
+	if (sig < 0 || sig >= HAWK_COUNTOF(rtx->sig_handler))
+	{
+		hawk_rtx_seterrbfmt(rtx, HAWK_NULL, HAWK_EINVAL, "invalid signal number %d", sig);
+		return -1;
+	}
+
+/* TODO: anything to do for old handler */
+
+	/* i assume the sys::signal() is called from the same thread as
+	 * the runtime context. so i don't use atomic or mutex on
+	 * rtx->sig_handler. */
+	rtx->sig_handler[sig] = fun;
+
+	for (ecb = rtx->ecb; ecb != (hawk_rtx_ecb_t*)(rtx); ecb = ecb_next)
+	{
+		ecb_next = ecb->next_;
+		if (ecb->sigset) ecb->sigset(rtx, sig, fun);
+	}
+
+	return 0;
+}
+
+#if defined(HAWK_ENABLE_ATOMIC_SIG)
+static HAWK_INLINE int ctz_uintptr (hawk_uintptr_t v)
+{
+	/* precondition - v != 0 */
+#if defined(HAWK_HAVE_BUILTIN_CTZL) && (HAWK_SIZEOF_UINTPTR_T <= HAWK_SIZEOF_LONG)
+	return (int)__builtin_ctzl((unsigned long)v);
+#elif defined(HAWK_HAVE_BUILTIN_CTZLL) && (HAWK_SIZEOF_UINTPTR_T <= HAWK_SIZEOF_LONG_LONG)
+	return (int)__builtin_ctzll((unsigned long long)v);
+#else
+	int c = 0;
+	while ((v & 1) == 0) { v >>= 1; c++; }
+	return c;
+#endif
+}
+#endif
+
+static int call_signal_handlers (hawk_rtx_t* rtx)
+{
+	int i;
+
+	rtx->sig_handling = 1;
+
+#if defined(HAWK_ENABLE_ATOMIC_SIG)
+	HAWK_ATOMIC_STORE(&rtx->sig_pending_any, 0, HAWK_ATOMIC_RELAXED);
+
+	for (i = 0; i < HAWK_SIG_WORD_COUNT; i++)
+	{
+		hawk_uintptr_t bits;
+
+		bits = HAWK_ATOMIC_EXCHANGE(&rtx->sig_pending[i], 0, HAWK_ATOMIC_ACQ_REL);
+		while (bits)
+		{
+			int sig;
+			hawk_fun_t* fun;
+			hawk_val_t* arg;
+			hawk_val_t* rv;
+			int bitpos;
+
+			bitpos = ctz_uintptr(bits);
+			sig = (i * HAWK_SIG_WORD_BITS) + bitpos;
+			if (sig < 0 || sig >= HAWK_NSIG)
+			{
+				bits &= (bits - 1);
+				continue;
+			}
+
+			fun = rtx->sig_handler[sig];
+			if (fun)
+			{
+				arg = hawk_rtx_makeintval(rtx, sig);
+				if (HAWK_UNLIKELY(!arg)) return -1;
+
+				rv = hawk_rtx_callfun(rtx, fun, &arg, 1);
+				if (HAWK_UNLIKELY(!rv)) return -1;
+
+				hawk_rtx_refdownval(rtx, rv);
+			}
+
+			bits &= (bits - 1);
+		}
+	}
+#else
+	hawk_mtx_lock(&rtx->sig_mtx, HAWK_NULL);
+	#if defined(HAWK_ATOMIC_LOAD)
+	if (HAWK_ATOMIC_LOAD(&rtx->sig_pending_any, HAWK_ATOMIC_RELAXED) != 0)
+	#else
+	if (rtx->sig_pending_any)
+	#endif
+	{
+		/* copy the signal raising state */
+		rtx->sig_raise[1] = rtx->sig_raise[0];
+	#if defined(HAWK_ATOMIC_STORE)
+		HAWK_ATOMIC_STORE(&rtx->sig_pending_any, 0, HAWK_ATOMIC_RELAXED);
+	#else
+		rtx->sig_pending_any = 0;
+	#endif
+
+		/* reset the signal raising state modified by hawk_rtx_raisesig() */
+		rtx->sig_raise[0].count = 0;
+		for (i = 0; i < HAWK_COUNTOF(rtx->sig_raise[0].pos); i++) rtx->sig_raise[0].pos[i] = -1;
+
+		hawk_mtx_unlock(&rtx->sig_mtx);
+
+		for (i = 0; i < rtx->sig_raise[1].count; i++)
+		{
+			int sig;
+			hawk_fun_t* fun;
+
+			sig = rtx->sig_raise[1].tab[i];
+			fun = rtx->sig_handler[sig];
+			if (fun)
+			{
+				hawk_val_t* arg;
+				hawk_val_t* rv;
+
+				arg = hawk_rtx_makeintval(rtx, sig);
+				if (HAWK_UNLIKELY(!arg)) return -1;
+
+				/* hawk_rtx_callfun() can invoke run_statement() again. if the signal
+				 * handler is in progress, this function must not be invoked again. */
+				rv = hawk_rtx_callfun(rtx, fun, &arg, 1);
+				if (HAWK_UNLIKELY(!rv)) return -1;
+
+				hawk_rtx_refdownval(rtx, rv);
+			}
+		}
+	}
+#endif
+
+	rtx->sig_handling = 0;
+	return 0;
+}
+
+/* ========================================================================= */
+
 #define ON_STATEMENT(rtx,nde) do { \
 	hawk_rtx_ecb_t* ecb, * ecb_next; \
 	if ((rtx)->hawk->haltall) (rtx)->exit_level = EXIT_ABORT; \
 	for (ecb = (rtx)->ecb; ecb != (hawk_rtx_ecb_t*)(rtx); ecb = ecb_next) { \
-		ecb_next = ecb->next; \
+		ecb_next = ecb->next_; \
 		if (ecb->stmt) ecb->stmt(rtx, nde, ecb->ctx);  \
 	} \
 } while(0)
@@ -2265,6 +2486,23 @@ static int run_statement (hawk_rtx_t* rtx, hawk_nde_t* nde)
 
 	ON_STATEMENT(rtx, nde);
 
+	if (!rtx->sig_handling)
+	{
+		/* run singal handlers if there are raised signals */
+	#if defined(HAWK_ATOMIC_LOAD)
+		if (HAWK_ATOMIC_LOAD(&rtx->sig_pending_any, HAWK_ATOMIC_RELAXED) != 0 &&
+		    call_signal_handlers(rtx) <= -1) return -1;
+	#else
+		/* NOTE:
+		 *   rtx->sig_pending_any accessed non-atomically without mutex concurrently
+		 *   from multiple threads(e.g. hawk_rtx_raisesig() called from a different
+		 *   thread) is undefined behavior. but ignore this path as i believe most
+		 *   modern compilers should support the atomic primitives. */
+		if (rtx->sig_pending_any && call_signal_handlers(rtx) <= -1) return -1;
+	#endif
+	}
+
+	/* run the actual statement */
 	switch (nde->type)
 	{
 		case HAWK_NDE_NULL:
@@ -8895,8 +9133,6 @@ oops:
 	if (str_free) hawk_rtx_freemem(rtx, str_free);
 	return -1;
 }
-/* ========================================================================= */
-
 hawk_ooch_t* hawk_rtx_format (
 	hawk_rtx_t* rtx, hawk_ooecs_t* out, hawk_ooecs_t* fbu,
 	const hawk_ooch_t* fmt, hawk_oow_t fmt_len,

lib/sed.c

@@ -35,7 +35,7 @@ static int emit_output (hawk_sed_t* sed, int skipline);
 
 #define EMPTY_REX ((void*)1)
 
-#define ADJERR_LOC(sed,l) do { (sed)->_gem.errloc = *(l); } while (0)
+#define ADJERR_LOC(sed,l) do { (sed)->gem_.errloc = *(l); } while (0)
 
 #define SETERR1(sed,num,argp,argl,loc) \
 do { \
@@ -77,7 +77,7 @@ void hawk_sed_close (hawk_sed_t* sed)
 
 	for (ecb = sed->ecb; ecb != (hawk_sed_ecb_t*)sed; ecb = ecb_next)
 	{
-		ecb_next = ecb->next; /* in case the callback deregisters itself */
+		ecb_next = ecb->next_; /* in case the callback deregisters itself */
 		if (ecb->close) ecb->close (sed, ecb->ctx);
 	}
 
@@ -92,17 +92,17 @@ int hawk_sed_init (hawk_sed_t* sed, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr)
 {
 	HAWK_MEMSET(sed, 0, HAWK_SIZEOF(*sed));
 
-	sed->_instsize = HAWK_SIZEOF(*sed);
+	sed->instsize_ = HAWK_SIZEOF(*sed);
-	sed->_gem.mmgr = mmgr;
+	sed->gem_.mmgr = mmgr;
-	sed->_gem.cmgr = cmgr;
+	sed->gem_.cmgr = cmgr;
 
 	/* initialize error handling fields */
-	sed->_gem.errnum = HAWK_ENOERR;
+	sed->gem_.errnum = HAWK_ENOERR;
-	sed->_gem.errmsg[0] = '\0';
+	sed->gem_.errmsg[0] = '\0';
-	sed->_gem.errloc.line = 0;
+	sed->gem_.errloc.line = 0;
-	sed->_gem.errloc.colm = 0;
+	sed->gem_.errloc.colm = 0;
-	sed->_gem.errloc.file = HAWK_NULL;
+	sed->gem_.errloc.file = HAWK_NULL;
-	sed->_gem.errstr = hawk_dfl_errstr;
+	sed->gem_.errstr = hawk_dfl_errstr;
 
 	sed->ecb = (hawk_sed_ecb_t*)sed; /* use this as a special sentinel node */
 
@@ -158,7 +158,7 @@ void hawk_sed_fini(hawk_sed_t* sed)
 
 hawk_errstr_t hawk_sed_geterrstr (hawk_sed_t* sed)
 {
-	return sed->_gem.errstr;
+	return sed->gem_.errstr;
 }
 
 void hawk_sed_seterrbfmt (hawk_sed_t* sed, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* fmt, ...)
@@ -3902,13 +3902,13 @@ void hawk_sed_setlinenum (hawk_sed_t* sed, hawk_oow_t num)
 void hawk_sed_killecb (hawk_sed_t* sed, hawk_sed_ecb_t* ecb)
 {
 	hawk_sed_ecb_t* prev, * cur;
-	for (cur = sed->ecb, prev = HAWK_NULL; cur != (hawk_sed_ecb_t*)sed; cur = cur->next)
+	for (cur = sed->ecb, prev = HAWK_NULL; cur != (hawk_sed_ecb_t*)sed; prev = cur, cur = cur->next_)
 	{
 		if (cur == ecb)
 		{
-			if (prev) prev->next = cur->next;
+			if (prev) prev->next_ = cur->next_;
-			else sed->ecb = cur->next;
+			else sed->ecb = cur->next_;
-			cur->next = HAWK_NULL;
+			cur->next_ = HAWK_NULL;
 			break;
 		}
 	}
@@ -3918,14 +3918,14 @@ hawk_sed_ecb_t* hawk_sed_popecb (hawk_sed_t* sed)
 {
 	hawk_sed_ecb_t* top = sed->ecb;
 	if (top == (hawk_sed_ecb_t*)sed) return HAWK_NULL;
-	sed->ecb = top->next;
+	sed->ecb = top->next_;
-	top->next = HAWK_NULL;
+	top->next_ = HAWK_NULL;
 	return top;
 }
 
 void hawk_sed_pushecb (hawk_sed_t* sed, hawk_sed_ecb_t* ecb)
 {
-	ecb->next = sed->ecb;
+	ecb->next_ = sed->ecb;
 	sed->ecb = ecb;
 }
 

lib/sio.c

@@ -62,7 +62,7 @@ hawk_sio_t* hawk_sio_open (hawk_gem_t* gem, hawk_oow_t xtnsize, const hawk_ooch_
 	{
 		if (hawk_sio_init(sio, gem, file, flags) <= -1)
 		{
-			hawk_gem_freemem (gem, sio);
+			hawk_gem_freemem(gem, sio);
 			return HAWK_NULL;
 		}
 		else HAWK_MEMSET (sio + 1, 0, xtnsize);
@@ -105,7 +105,7 @@ hawk_sio_t* hawk_sio_openstd (hawk_gem_t* gem, hawk_oow_t xtnsize, hawk_sio_std_
 void hawk_sio_close (hawk_sio_t* sio)
 {
 	hawk_sio_fini (sio);
-	hawk_gem_freemem (sio->gem, sio);
+	hawk_gem_freemem(sio->gem, sio);
 }
 
 int hawk_sio_init (hawk_sio_t* sio, hawk_gem_t* gem, const hawk_ooch_t* path, int flags)
@@ -156,7 +156,7 @@ int hawk_sio_init (hawk_sio_t* sio, hawk_gem_t* gem, const hawk_ooch_t* path, in
 	if (hawk_tio_init(&sio->tio.io, gem, topt) <= -1) goto oops03;
 
 	/* store the back-reference to sio in the extension area.*/
-	/*HAWK_ASSERT(hawk, (&sio->tio.io + 1) == &sio->tio.xtn);*/
+	/*HAWK_ASSERT((&sio->tio.io + 1) == &sio->tio.xtn);*/
 	*(hawk_sio_t**)(&sio->tio.io + 1) = sio;
 
 	if (hawk_tio_attachin(&sio->tio.io, file_input, sio->inbuf, HAWK_COUNTOF(sio->inbuf)) <= -1 ||
@@ -171,13 +171,13 @@ int hawk_sio_init (hawk_sio_t* sio, hawk_gem_t* gem, const hawk_ooch_t* path, in
 	return 0;
 
 oops04:
-	hawk_tio_fini (&sio->tio.io);
+	hawk_tio_fini(&sio->tio.io);
 oops03:
-	if (sio->path) hawk_gem_freemem (sio->gem, sio->path);
+	if (sio->path) hawk_gem_freemem(sio->gem, sio->path);
 oops02:
-	hawk_fio_fini (&sio->file);
+	hawk_fio_fini(&sio->file);
 oops01:
-	if (sio->mtx) hawk_mtx_close (sio->mtx);
+	if (sio->mtx) hawk_mtx_close(sio->mtx);
 oops00:
 	return -1;
 }
@@ -208,11 +208,11 @@ int hawk_sio_initstd (hawk_sio_t* sio, hawk_gem_t* gem, hawk_sio_std_t std, int
 void hawk_sio_fini (hawk_sio_t* sio)
 {
 	/*if (hawk_sio_flush (sio) <= -1) return -1;*/
-	hawk_sio_flush (sio);
+	hawk_sio_flush(sio);
-	hawk_tio_fini (&sio->tio.io);
+	hawk_tio_fini(&sio->tio.io);
-	hawk_fio_fini (&sio->file);
+	hawk_fio_fini(&sio->file);
-	if (sio->path) hawk_gem_freemem (sio->gem, sio->path);
+	if (sio->path) hawk_gem_freemem(sio->gem, sio->path);
-	if (sio->mtx) hawk_mtx_close (sio->mtx);
+	if (sio->mtx) hawk_mtx_close(sio->mtx);
 }
 
 hawk_cmgr_t* hawk_sio_getcmgr (hawk_sio_t* sio)
@@ -222,7 +222,7 @@ hawk_cmgr_t* hawk_sio_getcmgr (hawk_sio_t* sio)
 
 void hawk_sio_setcmgr (hawk_sio_t* sio, hawk_cmgr_t* cmgr)
 {
-	hawk_tio_setcmgr (&sio->tio.io, cmgr);
+	hawk_tio_setcmgr(&sio->tio.io, cmgr);
 }
 
 hawk_sio_hnd_t hawk_sio_gethnd (const hawk_sio_t* sio)
@@ -242,34 +242,34 @@ const hawk_ooch_t* hawk_sio_getpath (hawk_sio_t* sio)
 hawk_ooi_t hawk_sio_flush (hawk_sio_t* sio)
 {
 	hawk_ooi_t n;
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	n = hawk_tio_flush(&sio->tio.io);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 	return n;
 }
 
 void hawk_sio_drain (hawk_sio_t* sio)
 {
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	hawk_tio_drain (&sio->tio.io);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 }
 
 hawk_ooi_t hawk_sio_getbchar (hawk_sio_t* sio, hawk_bch_t* c)
 {
 	hawk_ooi_t n;
-	LOCK_INPUT (sio);
+	LOCK_INPUT(sio);
 	n = hawk_tio_readbchars(&sio->tio.io, c, 1);
-	UNLOCK_INPUT (sio);
+	UNLOCK_INPUT(sio);
 	return n;
 }
 
 hawk_ooi_t hawk_sio_getuchar (hawk_sio_t* sio, hawk_uch_t* c)
 {
 	hawk_ooi_t n;
-	LOCK_INPUT (sio);
+	LOCK_INPUT(sio);
 	n = hawk_tio_readuchars(&sio->tio.io, c, 1);
-	UNLOCK_INPUT (sio);
+	UNLOCK_INPUT(sio);
 	return n;
 }
 
@@ -284,10 +284,10 @@ hawk_ooi_t hawk_sio_getbcstr (hawk_sio_t* sio, hawk_bch_t* buf, hawk_oow_t size)
 	 * so I don't implement any hack here */
 #endif
 
-	LOCK_INPUT (sio);
+	LOCK_INPUT(sio);
 	n = hawk_tio_readbchars(&sio->tio.io, buf, size - 1);
 	if (n <= -1) return -1;
-	UNLOCK_INPUT (sio);
+	UNLOCK_INPUT(sio);
 
 	buf[n] = '\0';
 	return n;
@@ -301,9 +301,9 @@ hawk_ooi_t hawk_sio_getbchars (hawk_sio_t* sio, hawk_bch_t* buf, hawk_oow_t size
 	 * so I don't implement any hack here */
 #endif
 
-	LOCK_INPUT (sio);
+	LOCK_INPUT(sio);
 	n = hawk_tio_readbchars(&sio->tio.io, buf, size);
-	UNLOCK_INPUT (sio);
+	UNLOCK_INPUT(sio);
 
 	return n;
 }
@@ -319,9 +319,9 @@ hawk_ooi_t hawk_sio_getucstr (hawk_sio_t* sio, hawk_uch_t* buf, hawk_oow_t size)
 	 * so I don't implement any hack here */
 #endif
 
-	LOCK_INPUT (sio);
+	LOCK_INPUT(sio);
 	n = hawk_tio_readuchars(&sio->tio.io, buf, size - 1);
-	UNLOCK_INPUT (sio);
+	UNLOCK_INPUT(sio);
 
 	buf[n] = '\0';
 	return n;
@@ -336,9 +336,9 @@ hawk_ooi_t hawk_sio_getuchars(hawk_sio_t* sio, hawk_uch_t* buf, hawk_oow_t size)
 	 * so I don't implement any hack here */
 #endif
 
-	LOCK_INPUT (sio);
+	LOCK_INPUT(sio);
 	n = hawk_tio_readuchars (&sio->tio.io, buf, size);
-	UNLOCK_INPUT (sio);
+	UNLOCK_INPUT(sio);
 
 	return n;
 }
@@ -362,9 +362,9 @@ static hawk_ooi_t putbc_no_mutex (hawk_sio_t* sio, hawk_bch_t c)
 hawk_ooi_t hawk_sio_putbchar (hawk_sio_t* sio, hawk_bch_t c)
 {
 	hawk_ooi_t n;
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	n = putbc_no_mutex(sio, c);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 	return n;
 }
 
@@ -390,9 +390,9 @@ static hawk_ooi_t put_uchar_no_mutex (hawk_sio_t* sio, hawk_uch_t c)
 hawk_ooi_t hawk_sio_putuchar (hawk_sio_t* sio, hawk_uch_t c)
 {
 	hawk_ooi_t n;
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	n = put_uchar_no_mutex(sio, c);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 	return n;
 }
 
@@ -406,7 +406,7 @@ hawk_ooi_t hawk_sio_putbcstr (hawk_sio_t* sio, const hawk_bch_t* str)
 #elif defined(__OS2__)
 	if (sio->status & STATUS_LINE_BREAK)
 	{
-		LOCK_OUTPUT (sio);
+		LOCK_OUTPUT(sio);
 		for (n = 0; n < HAWK_TYPE_MAX(hawk_ooi_t) && str[n] != '\0'; n++)
 		{
 			if ((n = putbc_no_mutex(sio, str[n])) <= -1)
@@ -415,14 +415,14 @@ hawk_ooi_t hawk_sio_putbcstr (hawk_sio_t* sio, const hawk_bch_t* str)
 				break;
 			}
 		}
-		UNLOCK_OUTPUT (sio);
+		UNLOCK_OUTPUT(sio);
 		return n;
 	}
 #endif
 
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	n = hawk_tio_writebchars(&sio->tio.io, str, (hawk_oow_t)-1);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 	return n;
 }
 
@@ -437,7 +437,7 @@ hawk_ooi_t hawk_sio_putbchars (hawk_sio_t* sio, const hawk_bch_t* str, hawk_oow_
 	if (sio->status & STATUS_LINE_BREAK)
 	{
 		if (size > HAWK_TYPE_MAX(hawk_ooi_t)) size = HAWK_TYPE_MAX(hawk_ooi_t);
-		LOCK_OUTPUT (sio);
+		LOCK_OUTPUT(sio);
 		for (n = 0; n < size; n++)
 		{
 			if (putbc_no_mutex(sio, str[n]) <= -1)
@@ -446,14 +446,14 @@ hawk_ooi_t hawk_sio_putbchars (hawk_sio_t* sio, const hawk_bch_t* str, hawk_oow_
 				break;
 			}
 		}
-		UNLOCK_OUTPUT (sio);
+		UNLOCK_OUTPUT(sio);
 		return n;
 	}
 #endif
 
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	n = hawk_tio_writebchars (&sio->tio.io, str, size);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 	return n;
 }
 
@@ -490,7 +490,7 @@ hawk_ooi_t hawk_sio_putucstr (hawk_sio_t* sio, const hawk_uch_t* str)
 #elif defined(__OS2__)
 	if (sio->status & STATUS_LINE_BREAK)
 	{
-		LOCK_OUTPUT (sio);
+		LOCK_OUTPUT(sio);
 		for (n = 0; n < HAWK_TYPE_MAX(hawk_ooi_t) && str[n] != '\0'; n++)
 		{
 			if (put_uchar_no_mutex(sio, str[n]) <= -1)
@@ -499,14 +499,14 @@ hawk_ooi_t hawk_sio_putucstr (hawk_sio_t* sio, const hawk_uch_t* str)
 				break;
 			}
 		}
-		UNLOCK_OUTPUT (sio);
+		UNLOCK_OUTPUT(sio);
 		return n;
 	}
 #endif
 
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	n = hawk_tio_writeuchars(&sio->tio.io, str, (hawk_oow_t)-1);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 	return n;
 }
 
@@ -564,7 +564,7 @@ hawk_ooi_t hawk_sio_putuchars (hawk_sio_t* sio, const hawk_uch_t* str, hawk_oow_
 	if (sio->status & STATUS_LINE_BREAK)
 	{
 		if (size > HAWK_TYPE_MAX(hawk_ooi_t)) size = HAWK_TYPE_MAX(hawk_ooi_t);
-		LOCK_OUTPUT (sio);
+		LOCK_OUTPUT(sio);
 		for (n = 0; n < size; n++)
 		{
 			if (put_uchar_no_mutex(sio, str[n]) <= -1)
@@ -573,14 +573,14 @@ hawk_ooi_t hawk_sio_putuchars (hawk_sio_t* sio, const hawk_uch_t* str, hawk_oow_
 				break;
 			}
 		}
-		UNLOCK_OUTPUT (sio);
+		UNLOCK_OUTPUT(sio);
 		return n;
 	}
 #endif
 
-	LOCK_OUTPUT (sio);
+	LOCK_OUTPUT(sio);
 	n = hawk_tio_writeuchars(&sio->tio.io, str, size);
-	UNLOCK_OUTPUT (sio);
+	UNLOCK_OUTPUT(sio);
 	return n;
 }
 
@@ -634,8 +634,8 @@ static hawk_ooi_t file_input (hawk_tio_t* tio, hawk_tio_cmd_t cmd, void* buf, ha
 		hawk_sio_t* sio;
 
 		sio = *(hawk_sio_t**)(tio + 1);
-		/*HAWK_ASSERT (tio->hawk, sio != HAWK_NULL);
+		/*HAWK_ASSERT(sio != HAWK_NULL);
-		HAWK_ASSERT (tio->hawk, tio->hawk == sio->hawk);*/
+		HAWK_ASSERT(tio->hawk == sio->hawk);*/
 
 		return hawk_fio_read(&sio->file, buf, size);
 	}
@@ -650,8 +650,8 @@ static hawk_ooi_t file_output (hawk_tio_t* tio, hawk_tio_cmd_t cmd, void* buf, h
 		hawk_sio_t* sio;
 
 		sio = *(hawk_sio_t**)(tio + 1);
-		/*HAWK_ASSERT (tio->hawk, sio != HAWK_NULL);
+		/*HAWK_ASSERT(sio != HAWK_NULL);
-		HAWK_ASSERT (tio->hawk, tio->hawk == sio->hawk);*/
+		HAWK_ASSERT(tio->hawk == sio->hawk);*/
 
 		return hawk_fio_write(&sio->file, buf, size);
 	}

lib/std-cut.c

@@ -77,7 +77,6 @@ hawk_cut_t* hawk_cut_openstd (hawk_oow_t xtnsize, hawk_errinf_t* errinf)
 hawk_cut_t* hawk_cut_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t* cmgr, hawk_errinf_t* errinf)
 {
 	hawk_cut_t* cut;
-	xtn_t* xtn;
 
 	if (!mmgr) mmgr = hawk_get_sys_mmgr();
 	if (!cmgr) cmgr = hawk_get_cmgr_by_id(HAWK_CMGR_UTF8);
@@ -86,7 +85,7 @@ hawk_cut_t* hawk_cut_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, haw
 	cut = hawk_cut_open(mmgr, HAWK_SIZEOF(xtn_t) + xtnsize, cmgr, errinf);
 	if (HAWK_UNLIKELY(!cut)) return HAWK_NULL;
 
-	cut->_instsize += HAWK_SIZEOF(xtn_t);
+	cut->instsize_ += HAWK_SIZEOF(xtn_t);
 
 	return cut;
 }

lib/std-json.c

@@ -52,7 +52,7 @@ hawk_json_t* hawk_json_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, h
 	json = hawk_json_open(mmgr, HAWK_SIZEOF(xtn_t) + xtnsize, cmgr, prim, errinf);
 	if (HAWK_UNLIKELY(!json)) return HAWK_NULL;
 
-	json->_instsize += HAWK_SIZEOF(xtn_t);
+	json->instsize_ += HAWK_SIZEOF(xtn_t);
 
 	return json;
 }

lib/std-sed.c

@@ -121,7 +121,7 @@ hawk_sed_t* hawk_sed_openstdwithmmgr(hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk
 	sed = hawk_sed_open(mmgr, HAWK_SIZEOF(xtn_t) + xtnsize, cmgr, errinf);
 	if (HAWK_UNLIKELY(!sed)) return HAWK_NULL;
 
-	sed->_instsize += HAWK_SIZEOF(xtn_t);
+	sed->instsize_ += HAWK_SIZEOF(xtn_t);
 	return sed;
 }
 

lib/std.c

@@ -1014,7 +1014,7 @@ hawk_t* hawk_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t
 	if (HAWK_UNLIKELY(!hawk)) return HAWK_NULL;
 
 	/* adjust the object size by the sizeof xtn_t so that hawk_getxtn() returns the right pointer. */
-	hawk->_instsize += HAWK_SIZEOF(xtn_t);
+	hawk->instsize_ += HAWK_SIZEOF(xtn_t);
 
 /*
 #if defined(USE_DLFCN)
@@ -2738,7 +2738,7 @@ static void fini_rxtn (hawk_rtx_t* rtx, void* ctx)
 
 	if (rxtn->cmgrtab_inited)
 	{
-		hawk_htb_fini (&rxtn->cmgrtab);
+		hawk_htb_fini(&rxtn->cmgrtab);
 		rxtn->cmgrtab_inited = 0;
 	}
 }
@@ -3009,7 +3009,7 @@ static hawk_rtx_t* open_rtx_std (
 	rtx = hawk_rtx_open(hawk, HAWK_SIZEOF(rxtn_t) + xtnsize, &rio);
 	if (HAWK_UNLIKELY(!rtx)) return HAWK_NULL;
 
-	rtx->_instsize += HAWK_SIZEOF(rxtn_t);
+	rtx->instsize_ += HAWK_SIZEOF(rxtn_t);
 
 	rxtn = GET_RXTN(rtx);
 

lib/val.c

@@ -1723,7 +1723,7 @@ void hawk_rtx_refupval(hawk_rtx_t* rtx, hawk_val_t* val)
 	#endif
 
 	#if defined(USE_ATOMIC_REFCNT) && __has_builtin(__atomic_fetch_add)
-		__atomic_fetch_add(&val->v_refs, 1, __ATOMIC_RELAXED);
+		__atomic_fetch_add(&val->v_refs, 1, HAWK_ATOMIC_RELAXED);
 	#else
 		val->v_refs++;
 	#endif
@@ -1744,7 +1744,7 @@ void hawk_rtx_refdownval(hawk_rtx_t* rtx, hawk_val_t* val)
 		HAWK_ASSERT(val->v_refs > 0);
 
 	#if defined(USE_ATOMIC_REFCNT) && __has_builtin(__atomic_fetch_sub)
-		if (__atomic_fetch_sub(&val->v_refs, 1, __ATOMIC_RELAXED) == 1)
+		if (__atomic_fetch_sub(&val->v_refs, 1, HAWK_ATOMIC_RELAXED) == 1)
 		{
 			hawk_rtx_freeval (rtx, val, HAWK_RTX_FREEVAL_CACHE);
 		}
@@ -1768,7 +1768,7 @@ void hawk_rtx_refdownval_nofree (hawk_rtx_t* rtx, hawk_val_t* val)
 		HAWK_ASSERT(val->v_refs > 0);
 
 	#if defined(USE_ATOMIC_REFCNT) && __has_builtin(__atomic_fetch_sub)
-		__atomic_fetch_sub(&val->v_refs, 1, __ATOMIC_RELAXED);
+		__atomic_fetch_sub(&val->v_refs, 1, HAWK_ATOMIC_RELAXED);
 	#else
 		val->v_refs--;
 	#endif