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

Compare commits

base: hyung-hwan/hawk:b1179aca174d4e93eb19af7ca6930be613d879d1
Branches Tags
hyung-hwan/hawk:main hyung-hwan/hawk:xstack
...
compare: hyung-hwan/hawk:9e2248266c5c185f0da280a70c9624abc3dc8392
Branches Tags
hyung-hwan/hawk:main hyung-hwan/hawk:xstack
3 Commits
b1179aca17 ... 9e2248266c
Author SHA1 Message Date
hyung-hwan 9e2248266c touched up signal handling code
continuous-integration/drone/push Build is failing
Details
2026-01-12 14:19:52 +09:00
hyung-hwan 4f2c148b3b touched up the signal handling code a bit 2026-01-12 02:50:28 +09:00
hyung-hwan 957bcf2b4e fixed a bug in hawk_rtx_killecb()/hawk_killecb()/hawk_sed_killecb() 
initial support for signal handling. some race condition issues yet to be resolved
 2026-01-12 00:27:27 +09:00
26 changed files with 729 additions and 252 deletions
Expand all files Collapse all files
bin/hawk.c
+40 -11
View File
@@ -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_FV(.stmt, on_statement),
HAWK_FV(.gblset, HAWK_NULL)
HAWK_FV(.ctx, HAWK_NULL)
HAWK_SFN(close) HAWK_NULL,
#if defined(ENABLE_STATEMENT_CALLBACK)
HAWK_SFN(stmt) on_statement,
#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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+10 -10
View File
@@ -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->_gem.mmgr = mmgr;
cut->_gem.cmgr = cmgr;
cut->instsize_ = HAWK_SIZEOF(*cut);
cut->gem_.mmgr = mmgr;
cut->gem_.cmgr = cmgr;
/* initialize error handling fields */
cut->_gem.errnum = HAWK_ENOERR;
cut->_gem.errmsg[0] = '\0';
cut->_gem.errloc.line = 0;
cut->_gem.errloc.colm = 0;
cut->_gem.errloc.file = HAWK_NULL;
cut->_gem.errstr = hawk_dfl_errstr;
cut->gem_.errnum = HAWK_ENOERR;
cut->gem_.errmsg[0] = '\0';
cut->gem_.errloc.line = 0;
cut->gem_.errloc.colm = 0;
cut->gem_.errloc.file = HAWK_NULL;
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
+4 -4
View File
@@ -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.errloc = rtx->_gem.errloc;
hawk_copy_oocstr(hawk->_gem.errmsg, HAWK_COUNTOF(hawk->_gem.errmsg), rtx->_gem.errmsg);
hawk->gem_.errnum = rtx->gem_.errnum;
hawk->gem_.errloc = rtx->gem_.errloc;
hawk_copy_oocstr(hawk->gem_.errmsg, HAWK_COUNTOF(hawk->gem_.errmsg), rtx->gem_.errmsg);
}
/* ------------------------------------------------------------------------- */
lib/hawk-cmn.h
+57 -4
View File
@@ -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
+12 -12
View File
@@ -42,8 +42,8 @@
typedef struct hawk_cut_t hawk_cut_t;
#define HAWK_CUT_HDR \
hawk_oow_t _instsize; \
hawk_gem_t _gem
hawk_oow_t instsize_; \
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_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 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 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_getgem(cut) (&((hawk_cut_alt_t*)(cut))->_gem)
#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_setcmgr(cut,_cmgr) (((hawk_cut_alt_t*)(cut))->_gem.cmgr = (_cmgr))
#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_getmmgr(cut) (((hawk_cut_alt_t*)(cut))->gem_.mmgr)
#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))
#endif /* HAWK_HAVE_INLINE */
/**
lib/hawk-json.h
+12 -12
View File
@@ -34,8 +34,8 @@
typedef struct hawk_json_t hawk_json_t;
#define HAWK_JSON_HDR \
hawk_oow_t _instsize; \
hawk_gem_t _gem
hawk_oow_t instsize_; \
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_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 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 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_getgem(json) (&((hawk_json_alt_t*)(json))->_gem)
#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_setcmgr(json,_cmgr) (((hawk_json_alt_t*)(json))->_gem.cmgr = (_cmgr))
#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_getmmgr(json) (((hawk_json_alt_t*)(json))->gem_.mmgr)
#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))
#endif /* HAWK_HAVE_INLINE */
/**
lib/hawk-prv.h
+28 -1
View File
@@ -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
+16 -19
View File
@@ -62,8 +62,8 @@
typedef struct hawk_sed_t hawk_sed_t;
#define HAWK_SED_HDR \
hawk_oow_t _instsize; \
hawk_gem_t _gem
hawk_oow_t instsize_; \
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
{
/**
* called by hawk_sed_close().
*/
hawk_sed_ecb_close_t close;
void* ctx;
hawk_sed_ecb_close_t close; /* called by hawk_sed_close() */
/* internal use only. don't touch this field */
hawk_sed_ecb_t* next;
void* ctx; /* user context */
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_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 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 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_getgem(sed) (&((hawk_sed_alt_t*)(sed))->_gem)
#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_setcmgr(sed,_cmgr) (((hawk_sed_alt_t*)(sed))->_gem.cmgr = (_cmgr))
#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_getmmgr(sed) (((hawk_sed_alt_t*)(sed))->gem_.mmgr)
#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))
#endif /* HAWK_HAVE_INLINE */
lib/hawk.c
+19 -18
View File
@@ -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->_gem.mmgr = mmgr;
hawk->_gem.cmgr = cmgr;
hawk->instsize_ = HAWK_SIZEOF(*hawk);
hawk->gem_.mmgr = mmgr;
hawk->gem_.cmgr = cmgr;
/* initialize error handling fields */
hawk->_gem.errnum = HAWK_ENOERR;
hawk->_gem.errmsg[0] = '\0';
hawk->_gem.errloc.line = 0;
hawk->_gem.errloc.colm = 0;
hawk->_gem.errloc.file = HAWK_NULL;
hawk->_gem.errstr = hawk_dfl_errstr;
hawk->gem_.errnum = HAWK_ENOERR;
hawk->gem_.errmsg[0] = '\0';
hawk->gem_.errloc.line = 0;
hawk->gem_.errloc.colm = 0;
hawk->gem_.errloc.file = HAWK_NULL;
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;
else hawk->ecb = cur->next;
cur->next = HAWK_NULL;
if (prev) prev->next_ = cur->next_;
else hawk->ecb = cur->next_;
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;
top->next = HAWK_NULL;
hawk->ecb = top->next_;
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
+61 -31
View File
@@ -75,8 +75,8 @@
* \sa hawk_rtx_t hawk_open hawk_close
*/
#define HAWK_HDR \
hawk_oow_t _instsize; \
hawk_gem_t _gem
hawk_oow_t instsize_; \
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_gem_t _gem; \
hawk_oow_t instsize_; \
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 */
hawk_ecb_t* next;
/* internal use only. don't touch this field */
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 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_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_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_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 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_getcmgr(hawk) (((hawk_alt_t*)(hawk))->_gem.cmgr)
#define hawk_setcmgr(hawk,_cmgr) (((hawk_alt_t*)(hawk))->_gem.cmgr = (_cmgr))
#define hawk_getmmgr(hawk) (((hawk_alt_t*)(hawk))->gem_.mmgr)
#define hawk_getcmgr(hawk) (((hawk_alt_t*)(hawk))->gem_.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 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_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_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_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 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_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_getmmgr(rtx) (((hawk_rtx_alt_t*)(rtx))->gem_.mmgr)
#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))
#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
+13 -13
View File
@@ -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->_gem.mmgr = mmgr;
json->_gem.cmgr = cmgr;
json->instsize_ = HAWK_SIZEOF(*json);
json->gem_.mmgr = mmgr;
json->gem_.cmgr = cmgr;
/* initialize error handling fields */
json->_gem.errnum = HAWK_ENOERR;
json->_gem.errmsg[0] = '\0';
json->_gem.errloc.line = 0;
json->_gem.errloc.colm = 0;
json->_gem.errloc.file = HAWK_NULL;
json->_gem.errstr = hawk_dfl_errstr;
json->gem_.errnum = HAWK_ENOERR;
json->gem_.errmsg[0] = '\0';
json->gem_.errloc.line = 0;
json->gem_.errloc.colm = 0;
json->gem_.errloc.file = HAWK_NULL;
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
-1
View File
@@ -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
+110 -10
View File
@@ -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));
if (HAWK_UNLIKELY(!mod->ctx)) return -1;
mctx = (mod_ctx_t*)hawk_callocmem(hawk, HAWK_SIZEOF(mod_ctx_t));
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
+1 -1
View File
@@ -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
+6
View File
@@ -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
+256 -20
View File
@@ -24,11 +24,10 @@
#include "hawk-prv.h"
#define PRINT_IOERR -99
#define CMP_ERROR -99
#define DEF_BUF_CAPA 256
#define HAWK_RTX_STACK_INCREMENT 512
#define PRINT_IOERR (-99)
#define CMP_ERROR (-99)
#define DEF_BUF_CAPA (256)
#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;
else rtx->ecb = cur->next;
cur->next = HAWK_NULL;
if (prev) prev->next_ = cur->next_;
else rtx->ecb = cur->next_;
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;
top->next = HAWK_NULL;
rtx->ecb = top->next_;
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
+19 -19
View File
@@ -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->_gem.mmgr = mmgr;
sed->_gem.cmgr = cmgr;
sed->instsize_ = HAWK_SIZEOF(*sed);
sed->gem_.mmgr = mmgr;
sed->gem_.cmgr = cmgr;
/* initialize error handling fields */
sed->_gem.errnum = HAWK_ENOERR;
sed->_gem.errmsg[0] = '\0';
sed->_gem.errloc.line = 0;
sed->_gem.errloc.colm = 0;
sed->_gem.errloc.file = HAWK_NULL;
sed->_gem.errstr = hawk_dfl_errstr;
sed->gem_.errnum = HAWK_ENOERR;
sed->gem_.errmsg[0] = '\0';
sed->gem_.errloc.line = 0;
sed->gem_.errloc.colm = 0;
sed->gem_.errloc.file = HAWK_NULL;
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;
else sed->ecb = cur->next;
cur->next = HAWK_NULL;
if (prev) prev->next_ = cur->next_;
else sed->ecb = cur->next_;
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;
top->next = HAWK_NULL;
sed->ecb = top->next_;
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
+53 -53
View File
@@ -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_tio_fini (&sio->tio.io);
hawk_fio_fini (&sio->file);
if (sio->path) hawk_gem_freemem (sio->gem, sio->path);
if (sio->mtx) hawk_mtx_close (sio->mtx);
hawk_sio_flush(sio);
hawk_tio_fini(&sio->tio.io);
hawk_fio_fini(&sio->file);
if (sio->path) hawk_gem_freemem(sio->gem, sio->path);
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 (tio->hawk, tio->hawk == sio->hawk);*/
/*HAWK_ASSERT(sio != HAWK_NULL);
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 (tio->hawk, tio->hawk == sio->hawk);*/
/*HAWK_ASSERT(sio != HAWK_NULL);
HAWK_ASSERT(tio->hawk == sio->hawk);*/
return hawk_fio_write(&sio->file, buf, size);
}
lib/std-cut.c
+1 -2
View File
@@ -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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+3 -3
View File
@@ -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
+3 -3
View File
@@ -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