From ef1bb5f689e01f8ba538081ec7fc0ce3c5084758 Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Sat, 14 Dec 2019 16:05:10 +0000 Subject: [PATCH] added log writer --- hawk/bin/main.c | 14 +- hawk/lib/Hawk.cpp | 2 +- hawk/lib/err.c | 8 +- hawk/lib/fmt.c | 23 ++- hawk/lib/fnc.c | 57 +++---- hawk/lib/hawk-cmn.h | 21 +++ hawk/lib/hawk-prv.h | 12 ++ hawk/lib/hawk.c | 61 +++++--- hawk/lib/hawk.h | 25 +++- hawk/lib/htb.c | 41 ++--- hawk/lib/parse.c | 55 ++++--- hawk/lib/run.c | 42 +++--- hawk/lib/std.c | 357 ++++++++++++++++++++++++++++++++++++++++---- hawk/lib/val.c | 22 +-- 14 files changed, 546 insertions(+), 194 deletions(-) diff --git a/hawk/bin/main.c b/hawk/bin/main.c index 6db859dd..058d1efe 100644 --- a/hawk/bin/main.c +++ b/hawk/bin/main.c @@ -407,7 +407,7 @@ static void dprint_return (hawk_rtx_t* rtx, hawk_val_t* ret) } else { - dprint (HAWK_T("[RETURN] - [%.*s]\n"), (int)len, str); + dprint (HAWK_T("[RETURN] - [%.*js]\n"), len, str); hawk_freemem (hawk_rtx_gethawk(rtx), str); } } @@ -923,18 +923,16 @@ static void print_hawk_error (hawk_t* awk) { const hawk_loc_t* loc = hawk_geterrloc(awk); -/* TODO: proper logging mask */ -printf ("print_hawk_error... TODO: \n"); -/* hawk_logfmt (awk, 0, - HAWK_T("ERROR: CODE %d LINE %zu COLUMN %zu %s%s%s- %s\n"), - hawk_geterrnum(awk), + hawk_logfmt (awk, HAWK_LOG_STDERR, + HAWK_T("ERROR: CODE %d LINE %zu COLUMN %zu %js%js%js- %js\n"), + (int)hawk_geterrnum(awk), (hawk_oow_t)loc->line, (hawk_oow_t)loc->colm, ((loc->file == HAWK_NULL)? HAWK_T(""): HAWK_T("FILE ")), ((loc->file == HAWK_NULL)? HAWK_T(""): loc->file), ((loc->file == HAWK_NULL)? HAWK_T(""): HAWK_T(" ")), hawk_geterrmsg(awk) - );*/ + ); } static void print_hawk_rtx_error (hawk_rtx_t* rtx) @@ -1282,6 +1280,8 @@ oops: } +/* ---------------------------------------------------------------------- */ + #if defined(FAKE_SOCKET) socket () {} listen () {} diff --git a/hawk/lib/Hawk.cpp b/hawk/lib/Hawk.cpp index 5abb5b72..8d629611 100644 --- a/hawk/lib/Hawk.cpp +++ b/hawk/lib/Hawk.cpp @@ -1355,7 +1355,7 @@ int Hawk::open () #if defined(HAWK_USE_HTB_FOR_FUNCTION_MAP) this->functionMap = hawk_htb_open( - hawk_getmmgr(this->awk), HAWK_SIZEOF(this), 512, 70, + hawk_getgem(this->awk), HAWK_SIZEOF(this), 512, 70, HAWK_SIZEOF(hawk_ooch_t), 1 ); if (this->functionMap == HAWK_NULL) diff --git a/hawk/lib/err.c b/hawk/lib/err.c index 3f093a22..bd55fad7 100644 --- a/hawk/lib/err.c +++ b/hawk/lib/err.c @@ -304,7 +304,7 @@ static int err_uchars (hawk_fmtout_t* fmtout, const hawk_uch_t* ptr, hawk_oow_t } -void hawk_seterrbfmt (hawk_t* hawk, hawk_errnum_t errnum, hawk_loc_t* errloc, const hawk_bch_t* errfmt, ...) +void hawk_seterrbfmt (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* errfmt, ...) { va_list ap; hawk_fmtout_t fo; @@ -327,7 +327,7 @@ void hawk_seterrbfmt (hawk_t* hawk, hawk_errnum_t errnum, hawk_loc_t* errloc, co hawk->_gem.errloc = (errloc? *errloc: _nullloc); } -void hawk_seterrufmt (hawk_t* hawk, hawk_errnum_t errnum, hawk_loc_t* errloc, const hawk_uch_t* errfmt, ...) +void hawk_seterrufmt (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_uch_t* errfmt, ...) { va_list ap; hawk_fmtout_t fo; @@ -485,7 +485,7 @@ static int rtx_err_uchars (hawk_fmtout_t* fmtout, const hawk_uch_t* ptr, hawk_oo return 1; /* success */ } -void hawk_rtx_seterrbfmt (hawk_rtx_t* rtx, hawk_errnum_t errnum, const hawk_loc_t* errloc, const hawk_bch_t* errfmt, ...) +void hawk_rtx_seterrbfmt (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* errfmt, ...) { va_list ap; hawk_fmtout_t fo; @@ -508,7 +508,7 @@ void hawk_rtx_seterrbfmt (hawk_rtx_t* rtx, hawk_errnum_t errnum, const hawk_loc_ rtx->_gem.errloc = (errloc? *errloc: _nullloc); } -void hawk_rtx_seterrufmt (hawk_rtx_t* rtx, hawk_errnum_t errnum, const hawk_loc_t* errloc, const hawk_uch_t* errfmt, ...) +void hawk_rtx_seterrufmt (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_uch_t* errfmt, ...) { va_list ap; hawk_fmtout_t fo; diff --git a/hawk/lib/fmt.c b/hawk/lib/fmt.c index 4fb1b84c..31482e39 100644 --- a/hawk/lib/fmt.c +++ b/hawk/lib/fmt.c @@ -1509,7 +1509,15 @@ int hawk_ufmt_out (hawk_fmtout_t* fmtout, const hawk_uch_t* fmt, ...) * FORMATTED LOG OUTPUT * -------------------------------------------------------------------------- */ -#if 0 +/* i don't want an error raised inside the callback to override + * the existing error number and message. */ +#define log_write(hawk,mask,ptr,len) do { \ + int shuterr = (hawk)->shuterr; \ + (hawk)->shuterr = 1; \ + (hawk)->prm.logwrite (hawk, mask, ptr, len); \ + (hawk)->shuterr = shuterr; \ +} while(0) + static int log_oocs (hawk_fmtout_t* fmtout, const hawk_ooch_t* ptr, hawk_oow_t len) { hawk_t* hawk = (hawk_t*)fmtout->ctx; @@ -1527,7 +1535,7 @@ static int log_oocs (hawk_fmtout_t* fmtout, const hawk_ooch_t* ptr, hawk_oow_t l hawk->log.ptr[hawk->log.len++] = '\n'; } - vmprim_log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); + log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); hawk->log.len = 0; } @@ -1546,8 +1554,8 @@ redo: len = max; } - newcapa = HAWK_ALIGN_POW2(hawk->log.len + len, 512); /* TODO: adjust this capacity */ - if (newcapa > hawk->option.log_maxcapa) + newcapa = HAWK_ALIGN_POW2(hawk->log.len + len, HAWK_LOG_CAPA_ALIGN); + if (newcapa > hawk->opt.log_maxcapa) { /* [NOTE] * it doesn't adjust newcapa to hawk->option.log_maxcapa. @@ -1571,7 +1579,7 @@ redo: /* no line ending - append a line terminator */ hawk->log.ptr[hawk->log.len++] = '\n'; } - vmprim_log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); + log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); hawk->log.len = 0; } @@ -1684,7 +1692,7 @@ hawk_ooi_t hawk_logbfmtv (hawk_t* hawk, hawk_bitmask_t mask, const hawk_bch_t* f if (hawk->log.len > 0 && hawk->log.ptr[hawk->log.len - 1] == '\n') { - vmprim_log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); + log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); hawk->log.len = 0; } @@ -1737,7 +1745,7 @@ hawk_ooi_t hawk_logufmtv (hawk_t* hawk, hawk_bitmask_t mask, const hawk_uch_t* f if (hawk->log.len > 0 && hawk->log.ptr[hawk->log.len - 1] == '\n') { - vmprim_log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); + log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len); hawk->log.len = 0; } return (x <= -1)? -1: fo.count; @@ -1754,7 +1762,6 @@ hawk_ooi_t hawk_logufmt (hawk_t* hawk, hawk_bitmask_t mask, const hawk_uch_t* fm return x; } -#endif /* -------------------------------------------------------------------------- * STRING FORMATTING diff --git a/hawk/lib/fnc.c b/hawk/lib/fnc.c index 46bde37b..4b72ddf0 100644 --- a/hawk/lib/fnc.c +++ b/hawk/lib/fnc.c @@ -94,7 +94,7 @@ static hawk_fnc_t sysfnctab[] = { {HAWK_T("systime"), 7}, 0, { {A_MAX, 0, HAWK_T("sys") }, HAWK_NULL, 0 }, HAWK_NULL} }; -static hawk_fnc_t* add_fnc (hawk_t* awk, const hawk_ooch_t* name, const hawk_fnc_spec_t* spec) +static hawk_fnc_t* add_fnc (hawk_t* hawk, const hawk_ooch_t* name, const hawk_fnc_spec_t* spec) { hawk_fnc_t* fnc; hawk_oow_t fnc_size; @@ -105,7 +105,7 @@ static hawk_fnc_t* add_fnc (hawk_t* awk, const hawk_ooch_t* name, const hawk_fnc ncs.len = hawk_count_oocstr(name); if (ncs.len <= 0) { - hawk_seterrnum (awk, HAWK_EINVAL, HAWK_NULL); + hawk_seterrnum (hawk, HAWK_EINVAL, HAWK_NULL); return HAWK_NULL; } @@ -113,16 +113,16 @@ static hawk_fnc_t* add_fnc (hawk_t* awk, const hawk_ooch_t* name, const hawk_fnc * such a function registered won't take effect because * the word is treated as a keyword */ - if (hawk_findfncwithoocs(awk, &ncs) != HAWK_NULL) + if (hawk_findfncwithoocs(hawk, &ncs) != HAWK_NULL) { - hawk_seterrnum (awk, HAWK_EEXIST, &ncs); + hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_EEXIST, "unable to add existing function - %js", name); return HAWK_NULL; } speclen = spec->arg.spec? hawk_count_oocstr(spec->arg.spec): 0; fnc_size = HAWK_SIZEOF(*fnc) + (ncs.len + 1 + speclen + 1) * HAWK_SIZEOF(hawk_ooch_t); - fnc = (hawk_fnc_t*)hawk_callocmem(awk, fnc_size); + fnc = (hawk_fnc_t*)hawk_callocmem(hawk, fnc_size); if (fnc) { hawk_ooch_t* tmp; @@ -139,10 +139,11 @@ static hawk_fnc_t* add_fnc (hawk_t* awk, const hawk_ooch_t* name, const hawk_fnc fnc->spec.arg.spec = tmp; } - if (hawk_htb_insert(awk->fnc.user, (hawk_ooch_t*)ncs.ptr, ncs.len, fnc, 0) == HAWK_NULL) + if (hawk_htb_insert(hawk->fnc.user, (hawk_ooch_t*)ncs.ptr, ncs.len, fnc, 0) == HAWK_NULL) { - hawk_seterrnum (awk, HAWK_ENOMEM, HAWK_NULL); - hawk_freemem (awk, fnc); + const hawk_ooch_t* bem = hawk_backuperrmsg(hawk); + hawk_seterrbfmt (hawk, HAWK_NULL, hawk_geterrnum(hawk), "unable to add function - %js - %js", name, bem); + hawk_freemem (hawk, fnc); fnc = HAWK_NULL; } } @@ -216,7 +217,7 @@ hawk_fnc_t* hawk_addfncwithucstr (hawk_t* awk, const hawk_uch_t* name, const haw #endif } -int hawk_delfncwithbcstr (hawk_t* awk, const hawk_bch_t* name) +int hawk_delfncwithbcstr (hawk_t* hawk, const hawk_bch_t* name) { hawk_bcs_t ncs; hawk_ucs_t wcs; @@ -225,27 +226,27 @@ int hawk_delfncwithbcstr (hawk_t* awk, const hawk_bch_t* name) ncs.len = hawk_count_bcstr(name); #if defined(HAWK_OOCH_IS_BCH) - if (hawk_htb_delete(awk->fnc.user, ncs.ptr, ncs.len) <= -1) + if (hawk_htb_delete(hawk->fnc.user, ncs.ptr, ncs.len) <= -1) { - hawk_seterrnum (awk, HAWK_ENOENT, &ncs); + hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such function - %hs", name); return -1; } #else - wcs.ptr = hawk_dupbtoucstr(awk, ncs.ptr, &wcs.len, 0); + wcs.ptr = hawk_dupbtoucstr(hawk, ncs.ptr, &wcs.len, 0); if (!wcs.ptr) return -1; - if (hawk_htb_delete(awk->fnc.user, wcs.ptr, wcs.len) <= -1) + if (hawk_htb_delete(hawk->fnc.user, wcs.ptr, wcs.len) <= -1) { - hawk_seterrnum (awk, HAWK_ENOENT, &wcs); - hawk_freemem (awk, wcs.ptr); + hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such function - %hs", name); + hawk_freemem (hawk, wcs.ptr); return -1; } - hawk_freemem (awk, wcs.ptr); + hawk_freemem (hawk, wcs.ptr); #endif return 0; } -int hawk_delfncwithucstr (hawk_t* awk, const hawk_uch_t* name) +int hawk_delfncwithucstr (hawk_t* hawk, const hawk_uch_t* name) { hawk_ucs_t ncs; hawk_bcs_t mbs; @@ -254,19 +255,19 @@ int hawk_delfncwithucstr (hawk_t* awk, const hawk_uch_t* name) ncs.len = hawk_count_ucstr(name); #if defined(HAWK_OOCH_IS_BCH) - mbs.ptr = hawk_duputobcstr(awk, ncs.ptr, &mbs.len); + mbs.ptr = hawk_duputobcstr(hawk, ncs.ptr, &mbs.len); if (!mbs.ptr) return -1; - if (hawk_htb_delete(awk->fnc.user, mbs.ptr, mbs.len) <= -1) + if (hawk_htb_delete(hawk->fnc.user, mbs.ptr, mbs.len) <= -1) { - hawk_seterrnum (awk, HAWK_ENOENT, &mbs); - hawk_freemem (awk, mbs.ptr); + hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such function - %ls", name); + hawk_freemem (hawk, mbs.ptr); return -1; } - hawk_freemem (awk, mbs.ptr); + hawk_freemem (hawk, mbs.ptr); #else - if (hawk_htb_delete(awk->fnc.user, ncs.ptr, ncs.len) <= -1) + if (hawk_htb_delete(hawk->fnc.user, ncs.ptr, ncs.len) <= -1) { - hawk_seterrnum (awk, HAWK_ENOENT, &ncs); + hawk_seterrbfmt (hawk, HAWK_NULL, HAWK_ENOENT, "no such function - %ls", name); return -1; } #endif @@ -303,7 +304,7 @@ static hawk_fnc_t* find_fnc (hawk_t* awk, const hawk_oocs_t* name) if ((awk->opt.trait & fnc->spec.trait) == fnc->spec.trait) return fnc; } - hawk_seterrnum (awk, HAWK_ENOENT, name); + hawk_seterrbfmt (awk, HAWK_NULL, HAWK_ENOENT, "no such function - %js", name); return HAWK_NULL; } @@ -1656,7 +1657,7 @@ static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, goto done; } - hawk_rtx_seterrfmt (rtx, HAWK_ENOTMAP, HAWK_NULL, HAWK_T("source not a map")); + hawk_rtx_seterrfmt (rtx, HAWK_NULL, HAWK_ENOTMAP, HAWK_T("source not a map")); return -1; } @@ -1672,7 +1673,7 @@ static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, a2 = hawk_rtx_getarg(rtx, 2); if (HAWK_RTX_GETVALTYPE(rtx, a2) != HAWK_VAL_FUN) { - hawk_rtx_seterrfmt (rtx, HAWK_EINVAL, HAWK_NULL, HAWK_T("comparator not a function")); + hawk_rtx_seterrfmt (rtx, HAWK_NULL, HAWK_EINVAL, HAWK_T("comparator not a function")); return -1; } @@ -1680,7 +1681,7 @@ static HAWK_INLINE int __fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, if (fun->nargs < 2) { /* the comparison accepts less than 2 arguments */ - hawk_rtx_seterrfmt (rtx, HAWK_EINVAL, HAWK_NULL, HAWK_T("%.*s not accepting 2 arguments"), (int)fun->name.len, fun->name.ptr); + hawk_rtx_seterrfmt (rtx, HAWK_NULL, HAWK_EINVAL, HAWK_T("%.*js not accepting 2 arguments"), fun->name.len, fun->name.ptr); return -1; } } diff --git a/hawk/lib/hawk-cmn.h b/hawk/lib/hawk-cmn.h index 38eaad50..016107f7 100644 --- a/hawk/lib/hawk-cmn.h +++ b/hawk/lib/hawk-cmn.h @@ -928,6 +928,27 @@ struct hawk_gem_t hawk_loc_t errloc; }; +enum hawk_log_mask_t +{ + HAWK_LOG_DEBUG = (1u << 0), + HAWK_LOG_INFO = (1u << 1), + HAWK_LOG_WARN = (1u << 2), + HAWK_LOG_ERROR = (1u << 3), + HAWK_LOG_FATAL = (1u << 4), + + HAWK_LOG_UNTYPED = (1u << 6), /* only to be used by HAWK_DEBUGx() and HAWK_INFOx() */ + HAWK_LOG_PARSER = (1u << 7), + HAWK_LOG_RTX = (1u << 8), + HAWK_LOG_APP = (1u << 9), + + HAWK_LOG_ALL_LEVELS = (HAWK_LOG_DEBUG | HAWK_LOG_INFO | HAWK_LOG_WARN | HAWK_LOG_ERROR | HAWK_LOG_FATAL), + HAWK_LOG_ALL_TYPES = (HAWK_LOG_UNTYPED | HAWK_LOG_PARSER | HAWK_LOG_RTX | HAWK_LOG_APP), + + HAWK_LOG_STDOUT = (1u << 14), /* write log messages to stdout without timestamp. HAWK_LOG_STDOUT wins over HAWK_LOG_STDERR. */ + HAWK_LOG_STDERR = (1u << 15) /* write log messages to stderr without timestamp. */ +}; +typedef enum hawk_log_mask_t hawk_log_mask_t; + /* ========================================================================= * MACROS THAT CHANGES THE BEHAVIORS OF THE C COMPILER/LINKER * =========================================================================*/ diff --git a/hawk/lib/hawk-prv.h b/hawk/lib/hawk-prv.h index 3a40e4e8..fd58ef0b 100644 --- a/hawk/lib/hawk-prv.h +++ b/hawk/lib/hawk-prv.h @@ -209,6 +209,8 @@ struct hawk_t } depth; hawk_oow_t rtx_stack_limit; + hawk_oow_t log_mask; + hawk_oow_t log_maxcapa; } opt; /* parse tree */ @@ -317,6 +319,16 @@ struct hawk_t hawk_bch_t berrmsg[HAWK_ERRMSG_CAPA * 2]; #endif + struct + { + hawk_ooch_t* ptr; + hawk_oow_t len; + hawk_oow_t capa; + hawk_bitmask_t last_mask; + hawk_bitmask_t default_type_mask; + } log; + int shuterr; + int haltall; hawk_ecb_t* ecb; diff --git a/hawk/lib/hawk.c b/hawk/lib/hawk.c index 19ee7dbf..e53ee710 100644 --- a/hawk/lib/hawk.c +++ b/hawk/lib/hawk.c @@ -183,6 +183,8 @@ int hawk_init (hawk_t* awk, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr, const hawk_prm awk->opt.trait |= HAWK_CRLF; #endif awk->opt.rtx_stack_limit = HAWK_DFL_RTX_STACK_LIMIT; + awk->opt.log_mask = HAWK_LOG_ALL_LEVELS | HAWK_LOG_ALL_TYPES; + awk->opt.log_maxcapa = HAWK_DFL_LOG_MAXCAPA; awk->tree.ngbls = 0; awk->tree.ngbls_base = 0; @@ -423,12 +425,12 @@ static int dup_str_opt (hawk_t* awk, const void* value, hawk_oocs_t* tmp) return 0; } -int hawk_setopt (hawk_t* awk, hawk_opt_t id, const void* value) +int hawk_setopt (hawk_t* hawk, hawk_opt_t id, const void* value) { switch (id) { case HAWK_TRAIT: - awk->opt.trait = *(const int*)value; + hawk->opt.trait = *(const int*)value; return 0; case HAWK_MODPREFIX: @@ -437,21 +439,21 @@ int hawk_setopt (hawk_t* awk, hawk_opt_t id, const void* value) hawk_oocs_t tmp; int idx; - if (dup_str_opt (awk, value, &tmp) <= -1) return -1; + if (dup_str_opt(hawk, value, &tmp) <= -1) return -1; idx = id - HAWK_MODPREFIX; - if (awk->opt.mod[idx].ptr) hawk_freemem (awk, awk->opt.mod[idx].ptr); + if (hawk->opt.mod[idx].ptr) hawk_freemem (hawk, hawk->opt.mod[idx].ptr); - awk->opt.mod[idx] = tmp; + hawk->opt.mod[idx] = tmp; return 0; } case HAWK_INCLUDEDIRS: { hawk_oocs_t tmp; - if (dup_str_opt (awk, value, &tmp) <= -1) return -1; - if (awk->opt.incldirs.ptr) hawk_freemem (awk, awk->opt.incldirs.ptr); - awk->opt.incldirs = tmp; + if (dup_str_opt(hawk, value, &tmp) <= -1) return -1; + if (hawk->opt.incldirs.ptr) hawk_freemem (hawk, hawk->opt.incldirs.ptr); + hawk->opt.incldirs = tmp; return 0; } @@ -462,35 +464,45 @@ int hawk_setopt (hawk_t* awk, hawk_opt_t id, const void* value) case HAWK_DEPTH_EXPR_RUN: case HAWK_DEPTH_REX_BUILD: case HAWK_DEPTH_REX_MATCH: - awk->opt.depth.a[id - HAWK_DEPTH_INCLUDE] = *(const hawk_oow_t*)value; + hawk->opt.depth.a[id - HAWK_DEPTH_INCLUDE] = *(const hawk_oow_t*)value; return 0; case HAWK_RTX_STACK_LIMIT: - awk->opt.rtx_stack_limit = *(const hawk_oow_t*)value; - if (awk->opt.rtx_stack_limit < HAWK_MIN_RTX_STACK_LIMIT) awk->opt.rtx_stack_limit = HAWK_MIN_RTX_STACK_LIMIT; - else if (awk->opt.rtx_stack_limit > HAWK_MAX_RTX_STACK_LIMIT) awk->opt.rtx_stack_limit = HAWK_MAX_RTX_STACK_LIMIT; + hawk->opt.rtx_stack_limit = *(const hawk_oow_t*)value; + if (hawk->opt.rtx_stack_limit < HAWK_MIN_RTX_STACK_LIMIT) hawk->opt.rtx_stack_limit = HAWK_MIN_RTX_STACK_LIMIT; + else if (hawk->opt.rtx_stack_limit > HAWK_MAX_RTX_STACK_LIMIT) hawk->opt.rtx_stack_limit = HAWK_MAX_RTX_STACK_LIMIT; return 0; + + + case HAWK_LOG_MASK: + hawk->opt.log_mask = *(hawk_bitmask_t*)value; + return 0; + + case HAWK_LOG_MAXCAPA: + hawk->opt.log_maxcapa = *(hawk_oow_t*)value; + return 0; + } - hawk_seterrnum (awk, HAWK_EINVAL, HAWK_NULL); + hawk_seterrnum (hawk, HAWK_EINVAL, HAWK_NULL); return -1; } -int hawk_getopt (hawk_t* awk, hawk_opt_t id, void* value) +int hawk_getopt (hawk_t* hawk, hawk_opt_t id, void* value) { switch (id) { case HAWK_TRAIT: - *(int*)value = awk->opt.trait; + *(int*)value = hawk->opt.trait; return 0; case HAWK_MODPREFIX: case HAWK_MODPOSTFIX: - *(const hawk_ooch_t**)value = awk->opt.mod[id - HAWK_MODPREFIX].ptr; + *(const hawk_ooch_t**)value = hawk->opt.mod[id - HAWK_MODPREFIX].ptr; return 0; case HAWK_INCLUDEDIRS: - *(const hawk_ooch_t**)value = awk->opt.incldirs.ptr; + *(const hawk_ooch_t**)value = hawk->opt.incldirs.ptr; return 0; case HAWK_DEPTH_INCLUDE: @@ -500,15 +512,24 @@ int hawk_getopt (hawk_t* awk, hawk_opt_t id, void* value) case HAWK_DEPTH_EXPR_RUN: case HAWK_DEPTH_REX_BUILD: case HAWK_DEPTH_REX_MATCH: - *(hawk_oow_t*)value = awk->opt.depth.a[id - HAWK_DEPTH_INCLUDE]; + *(hawk_oow_t*)value = hawk->opt.depth.a[id - HAWK_DEPTH_INCLUDE]; return 0; case HAWK_RTX_STACK_LIMIT: - *(hawk_oow_t*)value = awk->opt.rtx_stack_limit; + *(hawk_oow_t*)value = hawk->opt.rtx_stack_limit; return 0; + + case HAWK_LOG_MASK: + *(hawk_bitmask_t*)value = hawk->opt.log_mask; + return 0; + + case HAWK_LOG_MAXCAPA: + *(hawk_oow_t*)value = hawk->opt.log_maxcapa; + return 0; + }; - hawk_seterrnum (awk, HAWK_EINVAL, HAWK_NULL); + hawk_seterrnum (hawk, HAWK_EINVAL, HAWK_NULL); return -1; } diff --git a/hawk/lib/hawk.h b/hawk/lib/hawk.h index a707a556..f3db1d59 100644 --- a/hawk/lib/hawk.h +++ b/hawk/lib/hawk.h @@ -481,6 +481,15 @@ typedef void (*hawk_mod_close_t) ( /* ------------------------------------------------------------------------ */ +typedef void (*hawk_log_write_t) ( + hawk_t* hawk, + hawk_bitmask_t mask, + const hawk_ooch_t* msg, + hawk_oow_t len +); + +/* ------------------------------------------------------------------------ */ + #if 0 typedef void* (*hawk_buildrex_t) ( hawk_t* awk, @@ -711,6 +720,7 @@ struct hawk_prm_t hawk_mod_close_t modclose; hawk_mod_getsym_t modgetsym; + hawk_log_write_t logwrite; #if 0 struct { @@ -1112,10 +1122,15 @@ enum hawk_opt_t HAWK_DEPTH_REX_BUILD, HAWK_DEPTH_REX_MATCH, - HAWK_RTX_STACK_LIMIT + HAWK_RTX_STACK_LIMIT, + HAWK_LOG_MASK, + HAWK_LOG_MAXCAPA }; typedef enum hawk_opt_t hawk_opt_t; +#define HAWK_LOG_CAPA_ALIGN (512) +#define HAWK_DFL_LOG_MAXCAPA (HAWK_LOG_CAPA_ALIGN * 16) + /* ------------------------------------------------------------------------ */ /** @@ -1585,16 +1600,16 @@ HAWK_EXPORT void hawk_seterrnum ( HAWK_EXPORT void hawk_seterrbfmt ( hawk_t* awk, + const hawk_loc_t* errloc, hawk_errnum_t errnum, - hawk_loc_t* errloc, const hawk_bch_t* errfmt, ... ); HAWK_EXPORT void hawk_seterrufmt ( hawk_t* awk, + const hawk_loc_t* errloc, hawk_errnum_t errnum, - hawk_loc_t* errloc, const hawk_uch_t* errfmt, ... ); @@ -2424,16 +2439,16 @@ HAWK_EXPORT void hawk_rtx_seterrinf ( HAWK_EXPORT void hawk_rtx_seterrbfmt ( hawk_rtx_t* rtx, - hawk_errnum_t errnum, const hawk_loc_t* errloc, + hawk_errnum_t errnum, const hawk_bch_t* errfmt, ... ); HAWK_EXPORT void hawk_rtx_seterrufmt ( hawk_rtx_t* rtx, - hawk_errnum_t errnum, const hawk_loc_t* errloc, + hawk_errnum_t errnum, const hawk_uch_t* errfmt, ... ); diff --git a/hawk/lib/htb.c b/hawk/lib/htb.c index e6e5ed44..4d6ba142 100644 --- a/hawk/lib/htb.c +++ b/hawk/lib/htb.c @@ -80,10 +80,10 @@ HAWK_INLINE pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t } else { - KPTR(n) = kcop (htb, kptr, klen); + KPTR(n) = kcop(htb, kptr, klen); if (KPTR(n) == HAWK_NULL) { - hawk_gem_freemem (htb->gem, n); + hawk_gem_freemem (htb->gem, n); return HAWK_NULL; } } @@ -109,7 +109,7 @@ HAWK_INLINE pair_t* hawk_htb_allocpair (hawk_htb_t* htb, void* kptr, hawk_oow_t { if (htb->style->freeer[HAWK_HTB_KEY] != HAWK_NULL) htb->style->freeer[HAWK_HTB_KEY] (htb, KPTR(n), KLEN(n)); - hawk_gem_freemem (htb->gem, n); + hawk_gem_freemem (htb->gem, n); return HAWK_NULL; } } @@ -123,11 +123,10 @@ HAWK_INLINE void hawk_htb_freepair (hawk_htb_t* htb, pair_t* pair) htb->style->freeer[HAWK_HTB_KEY] (htb, KPTR(pair), KLEN(pair)); if (htb->style->freeer[HAWK_HTB_VAL] != HAWK_NULL) htb->style->freeer[HAWK_HTB_VAL] (htb, VPTR(pair), VLEN(pair)); - hawk_gem_freemem (htb->gem, pair); + hawk_gem_freemem (htb->gem, pair); } -static HAWK_INLINE pair_t* change_pair_val ( - hawk_htb_t* htb, pair_t* pair, void* vptr, hawk_oow_t vlen) +static HAWK_INLINE pair_t* change_pair_val (hawk_htb_t* htb, pair_t* pair, void* vptr, hawk_oow_t vlen) { if (VPTR(pair) == vptr && VLEN(pair) == vlen) { @@ -160,9 +159,7 @@ static HAWK_INLINE pair_t* change_pair_val ( else { /* need to reconstruct the pair */ - pair_t* p = hawk_htb_allocpair (htb, - KPTR(pair), KLEN(pair), - vptr, vlen); + pair_t* p = hawk_htb_allocpair(htb, KPTR(pair), KLEN(pair), vptr, vlen); if (p == HAWK_NULL) return HAWK_NULL; hawk_htb_freepair (htb, pair); return p; @@ -170,7 +167,7 @@ static HAWK_INLINE pair_t* change_pair_val ( } else { - void* nvptr = vcop (htb, vptr, vlen); + void* nvptr = vcop(htb, vptr, vlen); if (nvptr == HAWK_NULL) return HAWK_NULL; VPTR(pair) = nvptr; VLEN(pair) = vlen; @@ -183,7 +180,6 @@ static HAWK_INLINE pair_t* change_pair_val ( } } - return pair; } @@ -359,7 +355,7 @@ pair_t* hawk_htb_search (const hawk_htb_t* htb, const void* kptr, hawk_oow_t kle while (pair != HAWK_NULL) { - if (htb->style->comper (htb, KPTR(pair), KLEN(pair), kptr, klen) == 0) + if (htb->style->comper(htb, KPTR(pair), KLEN(pair), kptr, klen) == 0) { return pair; } @@ -367,6 +363,7 @@ pair_t* hawk_htb_search (const hawk_htb_t* htb, const void* kptr, hawk_oow_t kle pair = NEXT(pair); } + hawk_gem_seterrnum (htb->gem, HAWK_NULL, HAWK_ENOENT); return HAWK_NULL; } @@ -466,8 +463,7 @@ static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, /* old pair destroyed. new pair reallocated. * relink to include the new pair but to drop * the old pair. */ - if (prev == HAWK_NULL) - htb->bucket[hc] = p; + if (prev == HAWK_NULL) htb->bucket[hc] = p; else NEXT(prev) = p; NEXT(p) = next; } @@ -479,6 +475,7 @@ static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, case INSERT: /* return failure */ + hawk_gem_seterrnum (htb->gem, HAWK_NULL, HAWK_EEXIST); return HAWK_NULL; } } @@ -487,7 +484,11 @@ static HAWK_INLINE pair_t* insert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, pair = next; } - if (opt == UPDATE) return HAWK_NULL; + if (opt == UPDATE) + { + hawk_gem_seterrnum (htb->gem, HAWK_NULL, HAWK_ENOENT); + return HAWK_NULL; + } if (htb->threshold > 0 && htb->size >= htb->threshold) { @@ -545,10 +546,10 @@ pair_t* hawk_htb_cbsert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, cbserter_ { next = NEXT(pair); - if (htb->style->comper (htb, KPTR(pair), KLEN(pair), kptr, klen) == 0) + if (htb->style->comper(htb, KPTR(pair), KLEN(pair), kptr, klen) == 0) { /* found a pair with a matching key */ - p = cbserter (htb, pair, kptr, klen, ctx); + p = cbserter(htb, pair, kptr, klen, ctx); if (p == HAWK_NULL) { /* error returned by the callback function */ @@ -559,8 +560,7 @@ pair_t* hawk_htb_cbsert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, cbserter_ /* old pair destroyed. new pair reallocated. * relink to include the new pair but to drop * the old pair. */ - if (prev == HAWK_NULL) - htb->bucket[hc] = p; + if (prev == HAWK_NULL) htb->bucket[hc] = p; else NEXT(prev) = p; NEXT(p) = next; } @@ -583,7 +583,7 @@ pair_t* hawk_htb_cbsert (hawk_htb_t* htb, void* kptr, hawk_oow_t klen, cbserter_ HAWK_ASSERT (htb->gem, pair == HAWK_NULL); - pair = cbserter (htb, HAWK_NULL, kptr, klen, ctx); + pair = cbserter(htb, HAWK_NULL, kptr, klen, ctx); if (pair == HAWK_NULL) return HAWK_NULL; /* error */ NEXT(pair) = htb->bucket[hc]; @@ -620,6 +620,7 @@ int hawk_htb_delete (hawk_htb_t* htb, const void* kptr, hawk_oow_t klen) pair = NEXT(pair); } + hawk_gem_seterrnum (htb->gem, HAWK_NULL, HAWK_ENOENT); return -1; } diff --git a/hawk/lib/parse.c b/hawk/lib/parse.c index 6d4ff79e..bab29820 100644 --- a/hawk/lib/parse.c +++ b/hawk/lib/parse.c @@ -435,7 +435,7 @@ static global_t gtab[] = #define SETERR_ARG(awk,code,ep,el) SETERR_ARG_LOC(awk,code,ep,el,HAWK_NULL) -#define ADJERR_LOC(rtx,l) do { (awk)->_gem.errloc = *(l); } while (0) +#define ADJERR_LOC(hawk,l) do { (hawk)->_gem.errloc = *(l); } while (0) static HAWK_INLINE int is_plain_var (hawk_nde_t* nde) { @@ -580,7 +580,7 @@ static int parse (hawk_t* awk) p = hawk_htb_getfirstpair(awk->parse.funs, &buckno); while (p != HAWK_NULL) { - if (hawk_htb_search (awk->tree.funs, HAWK_HTB_KPTR(p), HAWK_HTB_KLEN(p)) == HAWK_NULL) + if (hawk_htb_search(awk->tree.funs, HAWK_HTB_KPTR(p), HAWK_HTB_KLEN(p)) == HAWK_NULL) { hawk_nde_t* nde; @@ -942,7 +942,7 @@ static int parse_progunit (hawk_t* awk) if (get_token(awk) <= -1) return -1; if (!MATCH(awk, TOK_IDENT)) { - hawk_seterrfmt (awk, HAWK_EIDENT, &awk->ptok.loc, HAWK_T("identifier expected for '@pragma'")); + hawk_seterrfmt (awk, &awk->ptok.loc, HAWK_EIDENT, HAWK_T("identifier expected for '@pragma'")); return -1; } @@ -957,7 +957,7 @@ static int parse_progunit (hawk_t* awk) if (!MATCH(awk, TOK_IDENT)) { error_ident_on_off_expected_for_implicit: - hawk_seterrfmt (awk, HAWK_EIDENT, &awk->ptok.loc, HAWK_T("identifier 'on' or 'off' expected for 'implicit'")); + hawk_seterrfmt (awk, &awk->ptok.loc, HAWK_EIDENT, HAWK_T("identifier 'on' or 'off' expected for 'implicit'")); return -1; } @@ -997,7 +997,7 @@ static int parse_progunit (hawk_t* awk) } else { - hawk_seterrfmt (awk, HAWK_EIDENT, &awk->ptok.loc, HAWK_T("unknown @pragma identifier - %.*s"), (int)name.len, name.ptr); + hawk_seterrfmt (awk, &awk->ptok.loc, HAWK_EIDENT, HAWK_T("unknown @pragma identifier - %.*js"), name.len, name.ptr); return -1; } @@ -1143,10 +1143,10 @@ static int parse_progunit (hawk_t* awk) ploc = awk->ptok.loc; awk->parse.id.block = PARSE_ACTION_BLOCK; - if (parse_action_block (awk, ptn, 1) == HAWK_NULL) + if (parse_action_block(awk, ptn, 1) == HAWK_NULL) { hawk_clrpt (awk, ptn); - return -1; + return -1; } if (!eof) @@ -1181,15 +1181,14 @@ static int parse_progunit (hawk_t* awk) } awk->parse.id.block = PARSE_ACTION_BLOCK; - if (parse_action_block (awk, ptn, 0) == HAWK_NULL) + if (parse_action_block(awk, ptn, 0) == HAWK_NULL) { hawk_clrpt (awk, ptn); - return -1; + return -1; } /* skip a semicolon after an action block if any */ - if (MATCH(awk,TOK_SEMICOLON) && - get_token (awk) <= -1) return -1; + if (MATCH(awk,TOK_SEMICOLON) && get_token(awk) <= -1) return -1; } } @@ -1228,9 +1227,9 @@ static hawk_nde_t* parse_function (hawk_t* awk) /* check if it is a builtin function */ if ((hawk_findfncwithoocs(awk, &name) != HAWK_NULL && (rederr = HAWK_EFNCRED)) || /* check if it has already been defined as a function */ - (hawk_htb_search (awk->tree.funs, name.ptr, name.len) != HAWK_NULL && (rederr = HAWK_EFUNRED)) || + (hawk_htb_search(awk->tree.funs, name.ptr, name.len) != HAWK_NULL && (rederr = HAWK_EFUNRED)) || /* check if it conflicts with a named variable */ - (hawk_htb_search (awk->parse.named, name.ptr, name.len) != HAWK_NULL && (rederr = HAWK_EVARRED)) || + (hawk_htb_search(awk->parse.named, name.ptr, name.len) != HAWK_NULL && (rederr = HAWK_EVARRED)) || /* check if it coincides to be a global variable name */ (((g = find_global (awk, &name)) != HAWK_ARR_NIL) && (rederr = HAWK_EGBLRED))) { @@ -1409,7 +1408,7 @@ static hawk_nde_t* parse_function (hawk_t* awk) /* if hawk_htb_insert() fails for other reasons than memory * shortage, there should be implementaion errors as duplicate * functions are detected earlier in this function */ - SETERR_LOC (awk, HAWK_ENOMEM, &awk->tok.loc); + ADJERR_LOC (awk, &awk->tok.loc); goto oops; } @@ -1864,25 +1863,23 @@ static int add_global (hawk_t* awk, const hawk_oocs_t* name, hawk_loc_t* xloc, i * global X; * function x() { print X++; } */ - if (hawk_htb_search (awk->parse.named, name, len) != HAWK_NULL) + if (hawk_htb_search(awk->parse.named, name, len) != HAWK_NULL) { SETERR_ARG_LOC (awk, HAWK_EVARRED, name, len, xloc); return -1; } #endif - ngbls = HAWK_ARR_SIZE (awk->parse.gbls); + ngbls = HAWK_ARR_SIZE(awk->parse.gbls); if (ngbls >= HAWK_MAX_GBLS) { SETERR_LOC (awk, HAWK_EGBLTM, xloc); return -1; } - if (hawk_arr_insert (awk->parse.gbls, - HAWK_ARR_SIZE(awk->parse.gbls), - (hawk_ooch_t*)name->ptr, name->len) == HAWK_ARR_NIL) + if (hawk_arr_insert(awk->parse.gbls, HAWK_ARR_SIZE(awk->parse.gbls), (hawk_ooch_t*)name->ptr, name->len) == HAWK_ARR_NIL) { - SETERR_LOC (awk, HAWK_ENOMEM, xloc); + ADJERR_LOC (awk, xloc); return -1; } @@ -5350,7 +5347,7 @@ static hawk_nde_t* parse_primary_ident_noseg (hawk_t* awk, const hawk_loc_t* xlo * for reference */ if (hawk_htb_upsert(awk->parse.named, name->ptr, name->len, HAWK_NULL, 0) == HAWK_NULL) { - SETERR_LOC (awk, HAWK_ENOMEM, xloc); + ADJERR_LOC (awk, xloc); hawk_freemem (awk, tmp); } else @@ -5762,7 +5759,7 @@ make_node: /* store a non-builtin function call into the awk->parse.funs table */ if (!hawk_htb_upsert(awk->parse.funs, name->ptr, name->len, call, 0)) { - SETERR_LOC (awk, HAWK_ENOMEM, xloc); + ADJERR_LOC (awk, xloc); goto oops; } } @@ -7159,12 +7156,12 @@ static hawk_mod_t* query_module (hawk_t* awk, const hawk_oocs_t segs[], int nseg { if (hawk_geterrnum(awk) == HAWK_ENOERR) { - hawk_seterrfmt (awk, HAWK_ENOENT, HAWK_NULL, HAWK_T("module '%.*js' not found"), (int)segs[0].len, segs[0].ptr); + hawk_seterrfmt (awk, HAWK_NULL, HAWK_ENOENT, HAWK_T("module '%.*js' not found"), segs[0].len, segs[0].ptr); } else { const hawk_ooch_t* olderrmsg = hawk_backuperrmsg(awk); - hawk_seterrfmt (awk, HAWK_ENOENT, HAWK_NULL, HAWK_T("module '%.*js' not found - %js"), (int)segs[0].len, segs[0].ptr, olderrmsg); + hawk_seterrfmt (awk, HAWK_NULL, HAWK_ENOENT, HAWK_T("module '%.*js' not found - %js"), segs[0].len, segs[0].ptr, olderrmsg); } return HAWK_NULL; } @@ -7188,12 +7185,12 @@ static hawk_mod_t* query_module (hawk_t* awk, const hawk_oocs_t segs[], int nseg { if (hawk_geterrnum(awk) == HAWK_ENOERR) { - hawk_seterrfmt (awk, HAWK_ENOENT, HAWK_NULL, HAWK_T("module '%.*js' not found"), (int)(12 + buflen)); + hawk_seterrfmt (awk, HAWK_NULL, HAWK_ENOENT, HAWK_T("module '%.*js' not found"), (12 + buflen), &buf[1]); } else { - const hawk_ooch_t* olderrmsg = hawk_backuperrmsg(awk); - hawk_seterrfmt (awk, HAWK_ENOENT, HAWK_NULL, HAWK_T("module '%.*js' not found - %js"), (int)(12 + buflen), &buf[1], olderrmsg); + const hawk_ooch_t* bem = hawk_backuperrmsg(awk); + hawk_seterrfmt (awk, HAWK_NULL, HAWK_ENOENT, HAWK_T("module '%.*js' not found - %js"), (12 + buflen), &buf[1], bem); } awk->prm.modclose (awk, md.handle); return HAWK_NULL; @@ -7227,12 +7224,12 @@ done: { if (hawk_geterrnum(awk) == HAWK_ENOERR) { - hawk_seterrfmt (awk, HAWK_ENOENT, HAWK_NULL, HAWK_T("unable to find '%.*js' in module '%.*js'"), (int)segs[1].len, segs[1].ptr, (int)segs[0].len, segs[0].ptr); + hawk_seterrfmt (awk, HAWK_NULL, HAWK_ENOENT, HAWK_T("unable to find '%.*js' in module '%.*js'"), segs[1].len, segs[1].ptr, segs[0].len, segs[0].ptr); } else { const hawk_ooch_t* olderrmsg = hawk_backuperrmsg(awk); - hawk_seterrfmt (awk, HAWK_ENOENT, HAWK_NULL, HAWK_T("unable to find '%.*js' in module '%.*js' - %js"), (int)segs[1].len, segs[1].ptr, (int)segs[0].len, segs[0].ptr, olderrmsg); + hawk_seterrfmt (awk, HAWK_NULL, HAWK_ENOENT, HAWK_T("unable to find '%.*js' in module '%.*js' - %js"), segs[1].len, segs[1].ptr, segs[0].len, segs[0].ptr, olderrmsg); } return HAWK_NULL; } diff --git a/hawk/lib/run.c b/hawk/lib/run.c index fe9614da..889abc1c 100644 --- a/hawk/lib/run.c +++ b/hawk/lib/run.c @@ -939,7 +939,7 @@ static int init_rtx (hawk_rtx_t* rtx, hawk_t* awk, hawk_rio_cbs_t* rio) if (hawk_becs_init(&rtx->formatmbs.out, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_6; if (hawk_becs_init(&rtx->formatmbs.fmt, hawk_rtx_getgem(rtx), 256) <= -1) goto oops_7; - rtx->named = hawk_htb_open(hawk_rtx_gethawk(rtx), HAWK_SIZEOF(rtx), 1024, 70, HAWK_SIZEOF(hawk_ooch_t), 1); + rtx->named = hawk_htb_open(hawk_rtx_getgem(rtx), HAWK_SIZEOF(rtx), 1024, 70, HAWK_SIZEOF(hawk_ooch_t), 1); if (!rtx->named) goto oops_8; *(hawk_rtx_t**)hawk_htb_getxtn(rtx->named) = rtx; hawk_htb_setstyle (rtx->named, &style_for_named); @@ -2539,15 +2539,10 @@ static int delete_indexed ( hawk_rtx_refupval (rtx, idx); - if (HAWK_RTX_GETVALTYPE (rtx, idx) == HAWK_VAL_STR) + if (HAWK_RTX_GETVALTYPE(rtx, idx) == HAWK_VAL_STR) { /* delete x["abc"] */ - - hawk_htb_delete ( - map, - ((hawk_val_str_t*)idx)->val.ptr, - ((hawk_val_str_t*)idx)->val.len - ); + hawk_htb_delete (map, ((hawk_val_str_t*)idx)->val.ptr, ((hawk_val_str_t*)idx)->val.len); hawk_rtx_refdownval (rtx, idx); } else @@ -2560,13 +2555,13 @@ static int delete_indexed ( out.type = HAWK_RTX_VALTOSTR_CPLCPY; out.u.cplcpy.ptr = buf; out.u.cplcpy.len = HAWK_COUNTOF(buf); - if (hawk_rtx_valtostr (rtx, idx, &out) <= -1) + if (hawk_rtx_valtostr(rtx, idx, &out) <= -1) { int n; /* retry it in dynamic mode */ out.type = HAWK_RTX_VALTOSTR_CPLDUP; - n = hawk_rtx_valtostr (rtx, idx, &out); + n = hawk_rtx_valtostr(rtx, idx, &out); hawk_rtx_refdownval (rtx, idx); if (n <= -1) { @@ -2621,7 +2616,7 @@ static int run_delete_named (hawk_rtx_t* rtx, hawk_nde_var_t* var) { hawk_rtx_refupval (rtx, tmp); hawk_rtx_refdownval (rtx, tmp); - SETERR_LOC (rtx, HAWK_ENOMEM, &var->loc); + ADJERR_LOC (rtx, &var->loc); return -1; } @@ -3533,7 +3528,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* run, hawk_nde_var_t* var, h if (hawk_htb_upsert (run->named, var->id.name.ptr, var->id.name.len, val, 0) == HAWK_NULL) { - SETERR_LOC (run, HAWK_ENOMEM, &var->loc); + ADJERR_LOC (run, &var->loc); return HAWK_NULL; } @@ -3636,9 +3631,7 @@ retry: { hawk_htb_pair_t* pair; pair = hawk_htb_search(rtx->named, var->id.name.ptr, var->id.name.len); - map = (pair == HAWK_NULL)? - (hawk_val_map_t*)hawk_val_nil: - (hawk_val_map_t*)HAWK_HTB_VPTR(pair); + map = (pair == HAWK_NULL)? (hawk_val_map_t*)hawk_val_nil: (hawk_val_map_t*)HAWK_HTB_VPTR(pair); break; } @@ -3679,7 +3672,7 @@ retry: if (hawk_htb_upsert(rtx->named, var->id.name.ptr, var->id.name.len, tmp, 0) == HAWK_NULL) { hawk_rtx_refdownval (rtx, tmp); - SETERR_LOC (rtx, HAWK_ENOMEM, &var->loc); + ADJERR_LOC (rtx, &var->loc); return HAWK_NULL; } @@ -3755,7 +3748,7 @@ retry: if (hawk_htb_upsert(map->map, str, len, val, 0) == HAWK_NULL) { if (str != idxbuf) hawk_rtx_freemem (rtx, str); - SETERR_LOC (rtx, HAWK_ENOMEM, &var->loc); + ADJERR_LOC (rtx, &var->loc); return HAWK_NULL; } @@ -4077,8 +4070,7 @@ static hawk_val_t* eval_binop_in (hawk_rtx_t* rtx, hawk_nde_t* left, hawk_nde_t* hawk_htb_t* map; map = ((hawk_val_map_t*)rv)->map; - res = (hawk_htb_search (map, str, len) == HAWK_NULL)? - HAWK_VAL_ZERO: HAWK_VAL_ONE; + res = (hawk_htb_search(map, str, len) == HAWK_NULL)? HAWK_VAL_ZERO: HAWK_VAL_ONE; if (str != idxbuf) hawk_rtx_freemem (rtx, str); hawk_rtx_refdownval (rtx, rv); @@ -6285,7 +6277,7 @@ static int get_reference (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_val_t*** ref) pair = hawk_htb_upsert(rtx->named, tgt->id.name.ptr, tgt->id.name.len, hawk_val_nil, 0); if (!pair) { - SETERR_LOC (rtx, HAWK_ENOMEM, &nde->loc); + ADJERR_LOC (rtx, &nde->loc); return -1; } } @@ -6317,7 +6309,7 @@ static int get_reference (hawk_rtx_t* rtx, hawk_nde_t* nde, hawk_val_t*** ref) pair = hawk_htb_upsert(rtx->named, tgt->id.name.ptr, tgt->id.name.len, hawk_val_nil, 0); if (pair == HAWK_NULL) { - SETERR_LOC (rtx, HAWK_ENOMEM, &nde->loc); + ADJERR_LOC (rtx, &nde->loc); return -1; } } @@ -6428,7 +6420,7 @@ static hawk_val_t** get_reference_indexed (hawk_rtx_t* rtx, hawk_nde_var_t* nde, if (pair == HAWK_NULL) { if (str != idxbuf) hawk_rtx_freemem (rtx, str); - SETERR_LOC (rtx, HAWK_ENOMEM, &nde->loc); + ADJERR_LOC (rtx, &nde->loc); return HAWK_NULL; } @@ -6586,7 +6578,7 @@ static hawk_val_t* eval_namedidx (hawk_rtx_t* rtx, hawk_nde_t* nde) pair = hawk_htb_upsert(rtx->named, tgt->id.name.ptr, tgt->id.name.len, hawk_val_nil, 0); if (pair == HAWK_NULL) { - SETERR_LOC (rtx, HAWK_ENOMEM, &nde->loc); + ADJERR_LOC (rtx, &nde->loc); return HAWK_NULL; } @@ -6807,7 +6799,7 @@ static int __raw_push (hawk_rtx_t* rtx, void* val) rtx->stack = tmp; rtx->stack_limit = n; */ - hawk_rtx_seterrfmt (rtx, HAWK_ESTACK, HAWK_NULL, HAWK_T("runtime stack full")); + hawk_rtx_seterrfmt (rtx, HAWK_NULL, HAWK_ESTACK, HAWK_T("runtime stack full")); return -1; } @@ -6832,7 +6824,7 @@ read_again: } #if defined(DEBUG_RUN) - hawk_logfmt (hawk_rtx_gethawk(rtx), HAWK_T("record len = %d str=[%.*s]\n"), (int)HAWK_OOECS_LEN(buf), (int)HAWK_OOECS_LEN(buf), HAWK_OOECS_PTR(buf)); + hawk_logfmt (hawk_rtx_gethawk(rtx), HAWK_T("record len = %d str=[%.*js]\n"), (int)HAWK_OOECS_LEN(buf), HAWK_OOECS_LEN(buf), HAWK_OOECS_PTR(buf)); #endif if (n == 0) { diff --git a/hawk/lib/std.c b/hawk/lib/std.c index cf56e105..b5190eb0 100644 --- a/hawk/lib/std.c +++ b/hawk/lib/std.c @@ -71,6 +71,12 @@ # endif #endif +enum logfd_flag_t +{ + LOGFD_TTY = (1 << 0), + LOGFD_OPENED_HERE = (1 << 1) +}; + typedef struct xtn_t { struct @@ -133,6 +139,18 @@ typedef struct xtn_t hawk_ecb_t ecb; int stdmod_up; + + struct + { + int fd; + int fd_flag; /* bitwise OR'ed fo logfd_flag_t bits */ + + struct + { + hawk_bch_t buf[4096]; + hawk_oow_t len; + } out; + } log; } xtn_t; typedef struct rxtn_t @@ -202,9 +220,8 @@ static hawk_mmgr_t sys_mmgr = HAWK_NULL }; -/* ========================================================================= */ +/* ----------------------------------------------------------------------- */ -static ioattr_t* get_ioattr (hawk_htb_t* tab, const hawk_ooch_t* ptr, hawk_oow_t len); hawk_flt_t hawk_stdmathpow (hawk_t* awk, hawk_flt_t x, hawk_flt_t y) { @@ -428,16 +445,12 @@ void* hawk_stdmodopen (hawk_t* awk, const hawk_mod_spec_t* spec) #else modpath = hawk_dupucstrarrtobcstr(awk, tmp, HAWK_NULL); #endif - if (!modpath) - { - hawk_seterrnum (awk, HAWK_ENOMEM, HAWK_NULL); - return HAWK_NULL; - } + if (!modpath) return HAWK_NULL; h = dlopen(modpath, RTLD_NOW); if (!h) { - hawk_seterrfmt (awk, HAWK_ESYSERR, HAWK_NULL, HAWK_T("%hs"), dlerror()); + hawk_seterrfmt (awk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), dlerror()); } hawk_freemem (awk, modpath); @@ -507,6 +520,292 @@ void* hawk_stdmodgetsym (hawk_t* awk, void* handle, const hawk_ooch_t* name) return s; } +/* ----------------------------------------------------------------------- */ + +static HAWK_INLINE void reset_log_to_default (xtn_t* xtn) +{ +#if defined(ENABLE_LOG_INITIALLY) + xtn->log.fd = 2; + xtn->log.fd_flag = 0; + #if defined(HAVE_ISATTY) + if (isatty(xtn->log.fd)) xtn->log.fd_flag |= LOGFD_TTY; + #endif +#else + xtn->log.fd = -1; + xtn->log.fd_flag = 0; +#endif +} + +#if defined(EMSCRIPTEN) +EM_JS(int, write_all, (int, const hawk_bch_t* ptr, hawk_oow_t len), { + // UTF8ToString() doesn't handle a null byte in the middle of an array. + // Use the heap memory and pass the right portion to UTF8Decoder. + //console.log ("%s", UTF8ToString(ptr, len)); + console.log ("%s", UTF8Decoder.decode(HEAPU8.subarray(ptr, ptr + len))); + return 0; +}); + +#else + +static int write_all (int fd, const hawk_bch_t* ptr, hawk_oow_t len) +{ +#if defined(EMSCRIPTEN) + EM_ASM_ ({ + // UTF8ToString() doesn't handle a null byte in the middle of an array. + // Use the heap memory and pass the right portion to UTF8Decoder. + //console.log ("%s", UTF8ToString($0, $1)); + console.log ("%s", UTF8Decoder.decode(HEAPU8.subarray($0, $0 + $1))); + }, ptr, len); +#else + while (len > 0) + { + hawk_ooi_t wr; + + wr = write(fd, ptr, len); + + if (wr <= -1) + { + #if defined(EAGAIN) && defined(EWOULDBLOCK) && (EAGAIN == EWOULDBLOCK) + if (errno == EAGAIN) continue; + #else + #if defined(EAGAIN) + if (errno == EAGAIN) continue; + #elif defined(EWOULDBLOCK) + if (errno == EWOULDBLOCK) continue; + #endif + #endif + + #if defined(EINTR) + /* TODO: would this interfere with non-blocking nature of this VM? */ + if (errno == EINTR) continue; + #endif + return -1; + } + + ptr += wr; + len -= wr; + } +#endif + + return 0; +} +#endif + +static int write_log (hawk_t* hawk, int fd, const hawk_bch_t* ptr, hawk_oow_t len) +{ + xtn_t* xtn = GET_XTN(hawk); + + while (len > 0) + { + if (xtn->log.out.len > 0) + { + hawk_oow_t rcapa, cplen; + + rcapa = HAWK_COUNTOF(xtn->log.out.buf) - xtn->log.out.len; + cplen = (len >= rcapa)? rcapa: len; + + HAWK_MEMCPY (&xtn->log.out.buf[xtn->log.out.len], ptr, cplen); + xtn->log.out.len += cplen; + ptr += cplen; + len -= cplen; + + if (xtn->log.out.len >= HAWK_COUNTOF(xtn->log.out.buf)) + { + int n; + n = write_all(fd, xtn->log.out.buf, xtn->log.out.len); + xtn->log.out.len = 0; + if (n <= -1) return -1; + } + } + else + { + hawk_oow_t rcapa; + + rcapa = HAWK_COUNTOF(xtn->log.out.buf); + if (len >= rcapa) + { + if (write_all(fd, ptr, rcapa) <= -1) return -1; + ptr += rcapa; + len -= rcapa; + } + else + { + HAWK_MEMCPY (xtn->log.out.buf, ptr, len); + xtn->log.out.len += len; + ptr += len; + len -= len; + } + } + } + + return 0; +} + +static void flush_log (hawk_t* hawk, int fd) +{ + xtn_t* xtn = GET_XTN(hawk); + if (xtn->log.out.len > 0) + { + write_all (fd, xtn->log.out.buf, xtn->log.out.len); + xtn->log.out.len = 0; + } +} + +static void log_write (hawk_t* hawk, hawk_bitmask_t mask, const hawk_ooch_t* msg, hawk_oow_t len) +{ + xtn_t* xtn = GET_XTN(hawk); + hawk_bch_t buf[256]; + hawk_oow_t ucslen, bcslen, msgidx; + int n, logfd; + + if (mask & HAWK_LOG_STDERR) logfd = 2; + else if (mask & HAWK_LOG_STDOUT) logfd = 1; + else + { + logfd = xtn->log.fd; +#if !defined(EMSCRIPTEN) + if (logfd <= -1) return; +#endif + } + +/* TODO: beautify the log message. + * do classification based on mask. */ + if (!(mask & (HAWK_LOG_STDOUT | HAWK_LOG_STDERR))) + { + #if defined(_WIN32) + TIME_ZONE_INFORMATION tzi; + SYSTEMTIME now; + #else + time_t now; + struct tm tm, *tmp; + #endif + #if defined(HAWK_OOCH_IS_UCH) + char ts[32 * HAWK_BCSIZE_MAX]; + #else + char ts[32]; + #endif + hawk_oow_t tslen; + + #if defined(_WIN32) + /* %z for strftime() in win32 seems to produce a long non-numeric timezone name. + * i don't use strftime() for time formatting. */ + GetLocalTime (&now); + if (GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_INVALID) + { + tzi.Bias = -tzi.Bias; + tslen = sprintf(ts, "%04d-%02d-%02d %02d:%02d:%02d %+02.2d%02.2d ", + (int)now.wYear, (int)now.wMonth, (int)now.wDay, + (int)now.wHour, (int)now.wMinute, (int)now.wSecond, + (int)(tzi.Bias / 60), (int)(tzi.Bias % 60)); + } + else + { + tslen = sprintf(ts, "%04d-%02d-%02d %02d:%02d:%02d ", + (int)now.wYear, (int)now.wMonth, (int)now.wDay, + (int)now.wHour, (int)now.wMinute, (int)now.wSecond); + } + #elif defined(__OS2__) + now = time(HAWK_NULL); + + #if defined(__WATCOMC__) + tmp = _localtime(&now, &tm); + #else + tmp = localtime(&now); + #endif + + #if defined(__BORLANDC__) + /* the borland compiler doesn't handle %z properly - it showed 00 all the time */ + tslen = strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S %Z ", tmp); + #else + tslen = strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S %z ", tmp); + #endif + if (tslen == 0) + { + tslen = sprintf(ts, "%04d-%02d-%02d %02d:%02d:%02d ", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec); + } + + #elif defined(__DOS__) + now = time(HAWK_NULL); + tmp = localtime(&now); + /* since i know that %z/%Z is not available in strftime, i switch to sprintf immediately */ + tslen = sprintf(ts, "%04d-%02d-%02d %02d:%02d:%02d ", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec); + #else + now = time(HAWK_NULL); + #if defined(HAVE_LOCALTIME_R) + tmp = localtime_r(&now, &tm); + #else + tmp = localtime(&now); + #endif + + #if defined(HAVE_STRFTIME_SMALL_Z) + tslen = strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S %z ", tmp); + #else + tslen = strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S %Z ", tmp); + #endif + if (tslen == 0) + { + tslen = sprintf(ts, "%04d-%02d-%02d %02d:%02d:%02d ", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec); + } + #endif + + write_log (hawk, logfd, ts, tslen); + } + + if (logfd == xtn->log.fd && (xtn->log.fd_flag & LOGFD_TTY)) + { + if (mask & HAWK_LOG_FATAL) write_log (hawk, logfd, "\x1B[1;31m", 7); + else if (mask & HAWK_LOG_ERROR) write_log (hawk, logfd, "\x1B[1;32m", 7); + else if (mask & HAWK_LOG_WARN) write_log (hawk, logfd, "\x1B[1;33m", 7); + } + +#if defined(HAWK_OOCH_IS_UCH) + msgidx = 0; + while (len > 0) + { + ucslen = len; + bcslen = HAWK_COUNTOF(buf); + + /*n = hawk_convootobchars(hawk, &msg[msgidx], &ucslen, buf, &bcslen);*/ + n = hawk_conv_uchars_to_bchars_with_cmgr(&msg[msgidx], &ucslen, buf, &bcslen, hawk_getcmgr(hawk)); + if (n == 0 || n == -2) + { + /* n = 0: + * converted all successfully + * n == -2: + * buffer not sufficient. not all got converted yet. + * write what have been converted this round. */ + + HAWK_ASSERT (hawk, ucslen > 0); /* if this fails, the buffer size must be increased */ + + /* attempt to write all converted characters */ + if (write_log(hawk, logfd, buf, bcslen) <= -1) break; + + if (n == 0) break; + else + { + msgidx += ucslen; + len -= ucslen; + } + } + else if (n <= -1) + { + /* conversion error but i just stop here but don't treat it as a hard error. */ + break; + } + } +#else + write_log (hawk, logfd, msg, len); +#endif + + if (logfd == xtn->log.fd && (xtn->log.fd_flag & LOGFD_TTY)) + { + if (mask & (HAWK_LOG_FATAL | HAWK_LOG_ERROR | HAWK_LOG_WARN)) write_log (hawk, logfd, "\x1B[0m", 4); + } + + flush_log (hawk, logfd); +} +/* ----------------------------------------------------------------------- */ + static int add_globals (hawk_t* awk); static int add_functions (hawk_t* awk); @@ -523,6 +822,9 @@ static void fini_xtn (hawk_t* awk) hawk_stdmodshutdown (awk); xtn->stdmod_up = 0; } + + if ((xtn->log.fd_flag & LOGFD_OPENED_HERE) && xtn->log.fd >= 0) close (xtn->log.fd); + reset_log_to_default (xtn); } static void clear_xtn (hawk_t* awk) @@ -543,6 +845,8 @@ hawk_t* hawk_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t prm.modclose = hawk_stdmodclose; prm.modgetsym = hawk_stdmodgetsym; + prm.logwrite = log_write; + /* create an object */ awk = hawk_open(mmgr, HAWK_SIZEOF(xtn_t) + xtnsize, cmgr, &prm, errnum); if (!awk) return HAWK_NULL; @@ -550,6 +854,7 @@ hawk_t* hawk_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t /* adjust the object size by the sizeof xtn_t so that hawk_getxtn() returns the right pointer. */ awk->_instsize += HAWK_SIZEOF(xtn_t); + #if defined(USE_DLFCN) if (hawk_setopt(awk, HAWK_MODPOSTFIX, HAWK_T(".so")) <= -1) { @@ -560,8 +865,8 @@ hawk_t* hawk_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t /* initialize extension */ xtn = GET_XTN(awk); - /* the extension area has been cleared in hawk_open(). - * HAWK_MEMSET (xtn, 0, HAWK_SIZEOF(*xtn));*/ + + reset_log_to_default (xtn); /* add intrinsic global variables and functions */ if (add_globals(awk) <= -1 || add_functions(awk) <= -1) @@ -1364,6 +1669,8 @@ int hawk_parsestd (hawk_t* awk, hawk_parsestd_t in[], hawk_parsestd_t* out) /*** RTX_OPENSTD ***/ +static ioattr_t* get_ioattr (hawk_htb_t* tab, const hawk_ooch_t* ptr, hawk_oow_t len); + #if defined(ENABLE_NWIO) static hawk_ooi_t nwio_handler_open (hawk_rtx_t* rtx, hawk_rio_arg_t* riod, int flags, hawk_nwad_t* nwad, hawk_nwio_tmout_t* tmout) { @@ -2010,9 +2317,7 @@ static int build_argcv ( hawk_rtx_refupval (rtx, v_tmp); key_len = hawk_copy_oocstr(key, HAWK_COUNTOF(key), HAWK_T("0")); - if (hawk_htb_upsert ( - ((hawk_val_map_t*)v_argv)->map, - key, key_len, v_tmp, 0) == HAWK_NULL) + if (hawk_htb_upsert (((hawk_val_map_t*)v_argv)->map, key, key_len, v_tmp, 0) == HAWK_NULL) { /* if the assignment operation fails, decrements * the reference of v_tmp to free it */ @@ -2022,7 +2327,6 @@ static int build_argcv ( * map will be freeed when v_argv is freed */ hawk_rtx_refdownval (rtx, v_argv); - hawk_rtx_seterrnum (rtx, HAWK_ENOMEM, HAWK_NULL); return -1; } @@ -2045,13 +2349,10 @@ static int build_argcv ( hawk_rtx_refupval (rtx, v_tmp); - if (hawk_htb_upsert ( - ((hawk_val_map_t*)v_argv)->map, - key, key_len, v_tmp, 0) == HAWK_NULL) + if (hawk_htb_upsert (((hawk_val_map_t*)v_argv)->map, key, key_len, v_tmp, 0) == HAWK_NULL) { hawk_rtx_refdownval (rtx, v_tmp); hawk_rtx_refdownval (rtx, v_argv); - hawk_rtx_seterrnum (rtx, HAWK_ENOMEM, HAWK_NULL); return -1; } } @@ -2201,7 +2502,6 @@ static int build_environ (hawk_rtx_t* rtx, int gbl_id, env_char_t* envarr[]) * map will be freeed when v_env is freed */ hawk_rtx_refdownval (rtx, v_env); - hawk_rtx_seterrnum (rtx, HAWK_ENOMEM, HAWK_NULL); return -1; } @@ -2467,34 +2767,29 @@ static HAWK_INLINE void init_ioattr (ioattr_t* ioattr) } } -static ioattr_t* get_ioattr ( - hawk_htb_t* tab, const hawk_ooch_t* ptr, hawk_oow_t len) +static ioattr_t* get_ioattr (hawk_htb_t* tab, const hawk_ooch_t* ptr, hawk_oow_t len) { hawk_htb_pair_t* pair; - pair = hawk_htb_search (tab, ptr, len); + pair = hawk_htb_search(tab, ptr, len); if (pair) return HAWK_HTB_VPTR(pair); return HAWK_NULL; } -static ioattr_t* find_or_make_ioattr ( - hawk_rtx_t* rtx, hawk_htb_t* tab, const hawk_ooch_t* ptr, hawk_oow_t len) +static ioattr_t* find_or_make_ioattr (hawk_rtx_t* rtx, hawk_htb_t* tab, const hawk_ooch_t* ptr, hawk_oow_t len) { hawk_htb_pair_t* pair; - pair = hawk_htb_search (tab, ptr, len); + pair = hawk_htb_search(tab, ptr, len); if (pair == HAWK_NULL) { ioattr_t ioattr; init_ioattr (&ioattr); - pair = hawk_htb_insert (tab, (void*)ptr, len, (void*)&ioattr, HAWK_SIZEOF(ioattr)); - if (pair == HAWK_NULL) - { - hawk_rtx_seterrnum (rtx, HAWK_ENOMEM, HAWK_NULL); - } + pair = hawk_htb_insert(tab, (void*)ptr, len, (void*)&ioattr, HAWK_SIZEOF(ioattr)); + if (pair == HAWK_NULL) return HAWK_NULL; } return (ioattr_t*)HAWK_HTB_VPTR(pair); @@ -2648,7 +2943,7 @@ static int fnc_getioattr (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi) if (hawk_find_oochar(ptr[i], len[i], HAWK_T('\0'))) goto done; } - ioattr = get_ioattr (&rxtn->cmgrtab, ptr[0], len[0]); + ioattr = get_ioattr(&rxtn->cmgrtab, ptr[0], len[0]); if (ioattr == HAWK_NULL) { init_ioattr (&ioattr_buf); diff --git a/hawk/lib/val.c b/hawk/lib/val.c index e27c5cd0..e421bc45 100644 --- a/hawk/lib/val.c +++ b/hawk/lib/val.c @@ -483,7 +483,7 @@ hawk_val_t* hawk_rtx_makemapval (hawk_rtx_t* rtx) val->stat = 0; val->nstr = 0; val->fcb = 0; - val->map = hawk_htb_open(run, 256, 70, free_mapval, same_mapval, hawk_rtx_getmmgr(run)); + val->map = hawk_htb_open(hawk_rtx_getgem(rtx), 256, 70, free_mapval, same_mapval); if (val->map == HAWK_NULL) { hawk_rtx_freemem (rtx, val); @@ -502,10 +502,9 @@ hawk_val_t* hawk_rtx_makemapval (hawk_rtx_t* rtx) val->fcb = 0; val->map = (hawk_htb_t*)(val + 1); - if (hawk_htb_init(val->map, hawk_rtx_gethawk(rtx), 256, 70, HAWK_SIZEOF(hawk_ooch_t), 1) <= -1) + if (hawk_htb_init(val->map, hawk_rtx_getgem(rtx), 256, 70, HAWK_SIZEOF(hawk_ooch_t), 1) <= -1) { hawk_rtx_freemem (rtx, val); - hawk_rtx_seterrnum (rtx, HAWK_ENOMEM, HAWK_NULL); return HAWK_NULL; } *(hawk_rtx_t**)hawk_htb_getxtn(val->map) = rtx; @@ -585,13 +584,7 @@ hawk_val_t* hawk_rtx_setmapvalfld ( { HAWK_ASSERT (hawk_rtx_gethawk(rtx), HAWK_RTX_GETVALTYPE (rtx, map) == HAWK_VAL_MAP); - if (hawk_htb_upsert ( - ((hawk_val_map_t*)map)->map, - (hawk_ooch_t*)kptr, klen, v, 0) == HAWK_NULL) - { - hawk_rtx_seterrnum (rtx, HAWK_ENOMEM, HAWK_NULL); - return HAWK_NULL; - } + if (hawk_htb_upsert (((hawk_val_map_t*)map)->map, (hawk_ooch_t*)kptr, klen, v, 0) == HAWK_NULL) return HAWK_NULL; /* the value is passed in by an external party. we can't refup() * and refdown() the value if htb_upsert() fails. that way, the value @@ -602,13 +595,11 @@ hawk_val_t* hawk_rtx_setmapvalfld ( return v; } -hawk_val_t* hawk_rtx_getmapvalfld ( - hawk_rtx_t* rtx, hawk_val_t* map, - const hawk_ooch_t* kptr, hawk_oow_t klen) +hawk_val_t* hawk_rtx_getmapvalfld (hawk_rtx_t* rtx, hawk_val_t* map, const hawk_ooch_t* kptr, hawk_oow_t klen) { hawk_htb_pair_t* pair; - HAWK_ASSERT (hawk_rtx_gethawk(rtx), HAWK_RTX_GETVALTYPE (rtx, map) == HAWK_VAL_MAP); + HAWK_ASSERT (hawk_rtx_gethawk(rtx), HAWK_RTX_GETVALTYPE(rtx, map) == HAWK_VAL_MAP); pair = hawk_htb_search(((hawk_val_map_t*)map)->map, kptr, klen); if (pair == HAWK_NULL) @@ -619,7 +610,6 @@ hawk_val_t* hawk_rtx_getmapvalfld ( * so you can easily determine if the key is found by * checking the error number. */ - hawk_rtx_seterrnum (rtx, HAWK_EINVAL, HAWK_NULL); return HAWK_NULL; } @@ -805,7 +795,7 @@ void hawk_rtx_freeval (hawk_rtx_t* rtx, hawk_val_t* val, int cache) { if (cache && rtx->rcache_count < HAWK_COUNTOF(rtx->rcache)) { - rtx->rcache[rtx->rcache_count++] = (hawk_val_ref_t*)val; + rtx->rcache[rtx->rcache_count++] = (hawk_val_ref_t*)val; } else hawk_rtx_freemem (rtx, val); break;