From 56dfb3630ee84f9073649dbaffce0b4676a6e66f Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Mon, 6 Oct 2025 00:59:20 +0900 Subject: [PATCH] updated hak_open()/hak_openstd()/etc to accept the pointer to hak_errinf_t to convey an error message upon instantiation failure. added hak_errbint_t and hak_erruinf_t and related functions enhanced the wchar_t detection for wide_char yes:4w --- bin/hak.c | 33 +++++++++++----- lib/comp.c | 2 +- lib/err.c | 102 +++++++++++++++++++++++++++++++++++++------------ lib/fmt.c | 4 +- lib/hak-cmn.h | 10 +++-- lib/hak-json.h | 2 +- lib/hak-x.h | 4 +- lib/hak.c | 20 ++++++---- lib/hak.h | 96 ++++++++++++++++++++++++++++++++++++++-------- lib/json.c | 63 ++++++++++++++++-------------- lib/std.c | 10 ++--- lib/x-client.c | 33 +++++++++------- lib/x-server.c | 62 ++++++++++++++++-------------- 13 files changed, 298 insertions(+), 143 deletions(-) diff --git a/bin/hak.c b/bin/hak.c index d047baa..6f2edd9 100644 --- a/bin/hak.c +++ b/bin/hak.c @@ -30,6 +30,7 @@ #include #include +#include #include #include #include @@ -279,9 +280,9 @@ static int handle_dbgopt (hak_t* hak, const hak_bch_t* str) } while (cm); - hak_getoption (hak, HAK_TRAIT, &trait); + hak_getoption(hak, HAK_TRAIT, &trait); trait |= dbgopt; - hak_setoption (hak, HAK_TRAIT, &trait); + hak_setoption(hak, HAK_TRAIT, &trait); return 0; } #endif @@ -364,7 +365,7 @@ static void set_signal_to_default (int sig) static void print_info (void) { #if defined(HAK_CONFIGURE_CMD) && defined(HAK_CONFIGURE_ARGS) - printf ("Configured with: %s %s\n", HAK_CONFIGURE_CMD, HAK_CONFIGURE_ARGS); + printf("Configured with: %s %s\n", HAK_CONFIGURE_CMD, HAK_CONFIGURE_ARGS); #elif defined(_WIN32) printf("Built for windows\n"); #else @@ -563,7 +564,7 @@ static int on_fed_cnode_in_interactive_mode (hak_t* hak, hak_cnode_t* obj) /*print_error(hak, "compile"); */ xtn->feed.pos = xtn->feed.len; /* arrange to discard the rest of the line */ return -1; /* this causes the feed function to fail and - the error hander for to print the error message */ + the error handler to print the error message */ } xtn->feed.ncompexprs++; @@ -765,7 +766,7 @@ static int feed_loop (hak_t* hak, xtn_t* xtn, int verbose) } else { - print_incomplete_expression_error (hak); + print_incomplete_expression_error(hak); goto reset_on_feed_error; } #endif @@ -826,6 +827,7 @@ int main (int argc, char* argv[]) hak_t* hak = HAK_NULL; xtn_t* xtn; hak_cb_t hakcb; + hak_errinf_t errinf; hak_bci_t c; static hak_bopt_lng_t lopt[] = @@ -922,10 +924,21 @@ int main (int argc, char* argv[]) if ((opt.ind + 1) != argc && (opt.ind + 2) != argc && !show_info) goto print_usage; #endif - hak = hak_openstd(HAK_SIZEOF(xtn_t), HAK_NULL); + hak = hak_openstd(HAK_SIZEOF(xtn_t), &errinf); if (HAK_UNLIKELY(!hak)) { - printf ("ERROR: cannot open hak\n"); + const hak_bch_t* msg; + #if defined(HAK_OOCH_IS_UCH) + hak_bch_t msgbuf[HAK_ERRMSG_CAPA]; + hak_oow_t msglen, wcslen; + msglen = HAK_COUNTOF(msgbuf); + hak_conv_ucstr_to_bcstr_with_cmgr(errinf.msg, &wcslen, msgbuf, &msglen, hak_get_cmgr_by_id(HAK_CMGR_UTF8)); + msg = msgbuf; + #else + msg = errinf.msg; + #endif + + printf("ERROR: cannot open hak - %s\n", msg); goto oops; } @@ -992,7 +1005,7 @@ int main (int argc, char* argv[]) if (show_info) { - print_info (); + print_info(); return 0; } @@ -1033,9 +1046,9 @@ int main (int argc, char* argv[]) // in the non-INTERACTIVE mode, the compiler generates MAKE_BLOCK for lambda functions. { hak_bitmask_t trait; - hak_getoption (hak, HAK_TRAIT, &trait); + hak_getoption(hak, HAK_TRAIT, &trait); trait |= HAK_TRAIT_INTERACTIVE; - hak_setoption (hak, HAK_TRAIT, &trait); + hak_setoption(hak, HAK_TRAIT, &trait); } #endif diff --git a/lib/comp.c b/lib/comp.c index a2196f7..a82a013 100644 --- a/lib/comp.c +++ b/lib/comp.c @@ -2172,7 +2172,7 @@ static int compile_break_p1 (hak_t* hak) HAK_ASSERT(hak, cf->opcode == COP_COMPILE_BREAK_P1); HAK_ASSERT(hak, cf->operand != HAK_NULL); - jip = cf->u._break.jump_inst_pos;; + jip = cf->u._break.jump_inst_pos; /* HAK_CODE_LONG_PARAM_SIZE + 1 => size of the long JUMP_FORWARD instruction */ jump_offset = hak->code.bc.len - jip - (HAK_CODE_LONG_PARAM_SIZE + 1); diff --git a/lib/err.c b/lib/err.c index e3edd69..8e8c287 100644 --- a/lib/err.c +++ b/lib/err.c @@ -251,7 +251,7 @@ const hak_bch_t* hak_geterrbmsg (hak_t* hak) msg = (hak->errmsg.len <= 0)? hak_errnum_to_errstr(hak->errnum): hak->errmsg.buf; mbslen = HAK_COUNTOF(hak->errmsg.xerrmsg); - hak_conv_ucstr_to_bcstr_with_cmgr (msg, &wcslen, hak->errmsg.xerrmsg, &mbslen, HAK_CMGR(hak)); + hak_conv_ucstr_to_bcstr_with_cmgr(msg, &wcslen, hak->errmsg.xerrmsg, &mbslen, HAK_CMGR(hak)); return hak->errmsg.xerrmsg; #endif @@ -266,7 +266,7 @@ const hak_uch_t* hak_geterrumsg (hak_t* hak) msg = (hak->errmsg.len <= 0)? hak_errnum_to_errstr(hak->errnum): hak->errmsg.buf; wcslen = HAK_COUNTOF(hak->errmsg.xerrmsg); - hak_conv_bcstr_to_ucstr_with_cmgr (msg, &mbslen, hak->errmsg.xerrmsg, &wcslen, HAK_CMGR(hak), 1); + hak_conv_bcstr_to_ucstr_with_cmgr(msg, &mbslen, hak->errmsg.xerrmsg, &wcslen, HAK_CMGR(hak), 1); return hak->errmsg.xerrmsg; #else @@ -274,6 +274,60 @@ const hak_uch_t* hak_geterrumsg (hak_t* hak) #endif } +void hak_geterrbinf (hak_t* hak, hak_errbinf_t* errinf) +{ +#if defined(HAK_OOCH_IS_BCH) + errinf->num = hak->errnum; + errinf->loc = hak->errloc; + hak_copy_oocstr(errinf->msg, HAK_COUNTOF(errinf->msg), (hak->errmsg[0] == '\0'? hak_errnum_to_errstr(hak->errnum): hak->errmsg)); +#else + const hak_ooch_t* msg; + hak_oow_t wcslen, mbslen; + + /*errinf->num = hak->errnum;*/ + errinf->loc.line = hak->errloc.line; + errinf->loc.colm = hak->errloc.colm; + if (!hak->errloc.file) errinf->loc.file = HAK_NULL; + else + { + mbslen = HAK_COUNTOF(hak->errmsg.xerrlocfile); + hak_conv_ucstr_to_bcstr_with_cmgr(hak->errloc.file, &wcslen, hak->errmsg.xerrlocfile, &mbslen, hak->_cmgr); + errinf->loc.file = hak->errmsg.xerrlocfile; /* this can be truncated and is transient */ + } + + msg = (hak->errmsg.buf[0] == '\0')? hak_errnum_to_errstr(hak->errnum): hak->errmsg.buf; + mbslen = HAK_COUNTOF(errinf->msg); + hak_conv_ucstr_to_bcstr_with_cmgr(msg, &wcslen, errinf->msg, &mbslen, hak->_cmgr); +#endif +} + +void hak_geterruinf (hak_t* hak, hak_erruinf_t* errinf) +{ +#if defined(HAK_OOCH_IS_BCH) + const hak_ooch_t* msg; + hak_oow_t wcslen, mbslen; + + /*errinf->num = hak->errnum;*/ + errinf->loc.line = hak->errloc.line; + errinf->loc.colm = hak->errloc.colm; + if (!hak->errloc.file) errinf->loc.file = HAK_NULL; + else + { + wcslen = HAK_COUNTOF(hak->xerrlocfile); + hak_conv_bcstr_to_ucstr_with_cmgr(hak->errloc.file, &mbslen, hak->xerrlocfile, &wcslen, hak->_cmgr, 1); + errinf->loc.file = hak->xerrlocfile; /* this can be truncated and is transient */ + } + + msg = (hak->errmsg[0] == '\0')? hak_errnum_to_errstr(hak->errnum): hak->errmsg; + wcslen = HAK_COUNTOF(errinf->msg); + hak_conv_bcstr_to_ucstr_with_cmgr(msg, &mbslen, errinf->msg, &wcslen, hak->_cmgr, 1); +#else + errinf->num = hak->errnum; + errinf->loc = hak->errloc; + hak_copy_oocstr(errinf->msg, HAK_COUNTOF(errinf->msg), (hak->errmsg.buf[0] == '\0'? hak_errnum_to_errstr(hak->errnum): hak->errmsg.buf)); +#endif +} + hak_oow_t hak_copyerrbmsg (hak_t* hak, hak_bch_t* buf, hak_oow_t len) { return hak_copy_bcstr(buf, len, hak_geterrbmsg(hak)); @@ -326,7 +380,7 @@ static int err_bcs (hak_t* hak, hak_fmtout_t* fmtout, const hak_bch_t* ptr, hak_ #if defined(HAK_OOCH_IS_UCH) if (max <= 0) return 1; - hak_conv_bchars_to_uchars_with_cmgr (ptr, &len, &hak->errmsg.buf[hak->errmsg.len], &max, HAK_CMGR(hak), 1); + hak_conv_bchars_to_uchars_with_cmgr(ptr, &len, &hak->errmsg.buf[hak->errmsg.len], &max, HAK_CMGR(hak), 1); hak->errmsg.len += max; #else if (len > max) len = max; @@ -353,7 +407,7 @@ static int err_ucs (hak_t* hak, hak_fmtout_t* fmtout, const hak_uch_t* ptr, hak_ hak->errmsg.len += len; #else if (max <= 0) return 1; - hak_conv_uchars_to_bchars_with_cmgr (ptr, &len, &hak->errmsg.buf[hak->errmsg.len], &max, HAK_CMGR(hak)); + hak_conv_uchars_to_bchars_with_cmgr(ptr, &len, &hak->errmsg.buf[hak->errmsg.len], &max, HAK_CMGR(hak)); hak->errmsg.len += max; #endif hak->errmsg.buf[hak->errmsg.len] = '\0'; @@ -373,9 +427,9 @@ void hak_seterrbfmt (hak_t* hak, hak_errnum_t errnum, const hak_bch_t* fmt, ...) fo.putuchars = err_ucs; fo.putobj = hak_fmt_object; - va_start (ap, fmt); + va_start(ap, fmt); hak_bfmt_outv(hak, &fo, fmt, ap); - va_end (ap); + va_end(ap); hak->errnum = errnum; HAK_MEMSET(&hak->errloc, 0, HAK_SIZEOF(hak->errloc)); @@ -394,9 +448,9 @@ void hak_seterrufmt (hak_t* hak, hak_errnum_t errnum, const hak_uch_t* fmt, ...) fo.putuchars = err_ucs; fo.putobj = hak_fmt_object; - va_start (ap, fmt); + va_start(ap, fmt); hak_ufmt_outv(hak, &fo, fmt, ap); - va_end (ap); + va_end(ap); hak->errnum = errnum; HAK_MEMSET(&hak->errloc, 0, HAK_SIZEOF(hak->errloc)); @@ -442,18 +496,18 @@ void hak_seterrufmtv (hak_t* hak, hak_errnum_t errnum, const hak_uch_t* fmt, va_ void hak_seterrbfmtloc (hak_t* hak, hak_errnum_t errnum, const hak_loc_t* loc, const hak_bch_t* fmt, ...) { va_list ap; - va_start (ap, fmt); + va_start(ap, fmt); hak_seterrbfmtv(hak, errnum, fmt, ap); - va_end (ap); + va_end(ap); hak->errloc = *loc; } void hak_seterrufmtloc (hak_t* hak, hak_errnum_t errnum, const hak_loc_t* loc, const hak_uch_t* fmt, ...) { va_list ap; - va_start (ap, fmt); + va_start(ap, fmt); hak_seterrufmtv(hak, errnum, fmt, ap); - va_end (ap); + va_end(ap); hak->errloc = *loc; } @@ -488,9 +542,9 @@ void hak_seterrbfmtwithsyserr (hak_t* hak, int syserr_type, int syserr_code, con { errnum = hak->vmprim.syserrstrb(hak, syserr_type, syserr_code, hak->errmsg.tmpbuf.bch, HAK_COUNTOF(hak->errmsg.tmpbuf.bch)); - va_start (ap, fmt); + va_start(ap, fmt); hak_seterrbfmtv(hak, errnum, fmt, ap); - va_end (ap); + va_end(ap); if (HAK_COUNTOF(hak->errmsg.buf) - hak->errmsg.len >= 5) { @@ -512,9 +566,9 @@ void hak_seterrbfmtwithsyserr (hak_t* hak, int syserr_type, int syserr_code, con HAK_ASSERT(hak, hak->vmprim.syserrstru != HAK_NULL); errnum = hak->vmprim.syserrstru(hak, syserr_type, syserr_code, hak->errmsg.tmpbuf.uch, HAK_COUNTOF(hak->errmsg.tmpbuf.uch)); - va_start (ap, fmt); + va_start(ap, fmt); hak_seterrbfmtv(hak, errnum, fmt, ap); - va_end (ap); + va_end(ap); if (HAK_COUNTOF(hak->errmsg.buf) - hak->errmsg.len >= 5) { @@ -545,9 +599,9 @@ void hak_seterrufmtwithsyserr (hak_t* hak, int syserr_type, int syserr_code, con { errnum = hak->vmprim.syserrstrb(hak, syserr_type, syserr_code, hak->errmsg.tmpbuf.bch, HAK_COUNTOF(hak->errmsg.tmpbuf.bch)); - va_start (ap, fmt); + va_start(ap, fmt); hak_seterrufmtv(hak, errnum, fmt, ap); - va_end (ap); + va_end(ap); if (HAK_COUNTOF(hak->errmsg.buf) - hak->errmsg.len >= 5) { @@ -569,9 +623,9 @@ void hak_seterrufmtwithsyserr (hak_t* hak, int syserr_type, int syserr_code, con HAK_ASSERT(hak, hak->vmprim.syserrstru != HAK_NULL); errnum = hak->vmprim.syserrstru(hak, syserr_type, syserr_code, hak->errmsg.tmpbuf.uch, HAK_COUNTOF(hak->errmsg.tmpbuf.uch)); - va_start (ap, fmt); + va_start(ap, fmt); hak_seterrufmtv(hak, errnum, fmt, ap); - va_end (ap); + va_end(ap); if (HAK_COUNTOF(hak->errmsg.buf) - hak->errmsg.len >= 5) { @@ -617,9 +671,9 @@ void hak_setsynerrbfmt (hak_t* hak, hak_synerrnum_t num, const hak_loc_t* loc, c va_list ap; int i, selen; - va_start (ap, msgfmt); + va_start(ap, msgfmt); hak_seterrbfmtv(hak, HAK_ESYNERR, msgfmt, ap); - va_end (ap); + va_end(ap); selen = HAK_COUNTOF(syntax_error) - 1; HAK_MEMMOVE(&hak->errmsg.buf[selen], &hak->errmsg.buf[0], HAK_SIZEOF(hak->errmsg.buf[0]) * (HAK_COUNTOF(hak->errmsg.buf) - selen)); @@ -676,9 +730,9 @@ void hak_setsynerrufmt (hak_t* hak, hak_synerrnum_t num, const hak_loc_t* loc, c va_list ap; int i, selen; - va_start (ap, msgfmt); + va_start(ap, msgfmt); hak_seterrufmtv(hak, HAK_ESYNERR, msgfmt, ap); - va_end (ap); + va_end(ap); selen = HAK_COUNTOF(syntax_error) - 1; HAK_MEMMOVE(&hak->errmsg.buf[selen], &hak->errmsg.buf[0], HAK_SIZEOF(hak->errmsg.buf[0]) * (HAK_COUNTOF(hak->errmsg.buf) - selen)); diff --git a/lib/fmt.c b/lib/fmt.c index d049d60..466ceb5 100644 --- a/lib/fmt.c +++ b/lib/fmt.c @@ -617,7 +617,7 @@ static int fmt_outv (hak_t* hak, hak_fmtout_t* fmtout, va_list ap) case '5': case '6': case '7': case '8': case '9': { if (flagc & FLAGC_LENMOD) goto invalid_format; - for (n = 0;; fmtptr += fmtchsz) + for (n = 0; ; fmtptr += fmtchsz) { n = n * 10 + uch - '0'; switch (fmtout->fmt_type) @@ -2212,7 +2212,7 @@ static HAK_INLINE int format_stack_args (hak_t* hak, hak_fmtout_t* fmtout, hak_o case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (flagc & FLAGC_LENMOD) goto invalid_format; - for (n = 0;; ++fmtptr) + for (n = 0; ; ++fmtptr) { n = n * 10 + ch - '0'; ch = *fmtptr; diff --git a/lib/hak-cmn.h b/lib/hak-cmn.h index 778774e..efe5997 100644 --- a/lib/hak-cmn.h +++ b/lib/hak-cmn.h @@ -420,21 +420,23 @@ typedef unsigned char hak_bchu_t; /* unsigned version of hak_bch_t for #define HAK_SIZEOF_BCI_T HAK_SIZEOF_INT #if defined(HAK_WIDE_CHAR_SIZE) && (HAK_WIDE_CHAR_SIZE >= 4) -# if defined(__GNUC__) && defined(__CHAR32_TYPE__) +# if defined(__WCHAR_TYPE__) && defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ == HAK_WIDE_CHAR_SIZE) + typedef __WCHAR_TYPE__ hak_uch_t; +# elif defined(__GNUC__) && defined(__CHAR32_TYPE__) typedef __CHAR32_TYPE__ hak_uch_t; # else typedef hak_uint32_t hak_uch_t; # endif - typedef hak_uint32_t hak_uchu_t; /* same as hak_uch_t as it is already unsigned */ + typedef hak_uint32_t hak_uchu_t; # define HAK_SIZEOF_UCH_T 4 #elif defined(__GNUC__) && defined(__CHAR16_TYPE__) typedef __CHAR16_TYPE__ hak_uch_t; - typedef hak_uint16_t hak_uchu_t; /* same as hak_uch_t as it is already unsigned */ + typedef hak_uint16_t hak_uchu_t; # define HAK_SIZEOF_UCH_T 2 #else typedef hak_uint16_t hak_uch_t; - typedef hak_uint16_t hak_uchu_t; /* same as hak_uch_t as it is already unsigned */ + typedef hak_uint16_t hak_uchu_t; # define HAK_SIZEOF_UCH_T 2 #endif diff --git a/lib/hak-json.h b/lib/hak-json.h index 16e64fd..7ed85e5 100644 --- a/lib/hak-json.h +++ b/lib/hak-json.h @@ -111,7 +111,7 @@ HAK_EXPORT hak_json_t* hak_json_open ( hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_json_prim_t* prim, - hak_errnum_t* errnum + hak_errinf_t* errinf ); HAK_EXPORT void hak_json_close ( diff --git a/lib/hak-x.h b/lib/hak-x.h index 8da7bb3..7dcf959 100644 --- a/lib/hak-x.h +++ b/lib/hak-x.h @@ -251,7 +251,7 @@ HAK_EXPORT hak_server_t* hak_server_open ( hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_server_prim_t* prim, - hak_errnum_t* errnum + hak_errinf_t* errinf ); HAK_EXPORT void hak_server_close ( @@ -372,7 +372,7 @@ HAK_EXPORT hak_client_t* hak_client_open ( hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_client_prim_t* prim, - hak_errnum_t* errnum + hak_errinf_t* errinf ); HAK_EXPORT void hak_client_close ( diff --git a/lib/hak.c b/lib/hak.c index 664371e..70ae278 100644 --- a/lib/hak.c +++ b/lib/hak.c @@ -24,7 +24,7 @@ #include "hak-prv.h" -hak_t* hak_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, const hak_vmprim_t* vmprim, hak_errnum_t* errnum) +hak_t* hak_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, const hak_vmprim_t* vmprim, hak_errinf_t* errinf) { hak_t* hak; @@ -32,17 +32,22 @@ hak_t* hak_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, const hak_vmprim_t* vmprim HAK_ASSERT(hak, HAK_SIZEOF(hak_oow_t) == HAK_SIZEOF(hak_oop_t)); hak = (hak_t*)HAK_MMGR_ALLOC(mmgr, HAK_SIZEOF(*hak) + xtnsize); - if (hak) + if (HAK_LIKELY(hak)) { if (hak_init(hak, mmgr, vmprim) <= -1) { - if (errnum) *errnum = hak->errnum; - HAK_MMGR_FREE (mmgr, hak); + if (errinf) hak_geterrinf(hak, errinf); + HAK_MMGR_FREE(mmgr, hak); hak = HAK_NULL; } else HAK_MEMSET(hak + 1, 0, xtnsize); } - else if (errnum) *errnum = HAK_ESYSMEM; + else if (errinf) + { + HAK_MEMSET(errinf, 0, HAK_SIZEOF(*errinf)); + errinf->num = HAK_ESYSMEM; + hak_copy_oocstr(errinf->msg, HAK_COUNTOF(errinf->msg), hak_errnum_to_errstr(errinf->num)); + } return hak; } @@ -50,7 +55,7 @@ hak_t* hak_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, const hak_vmprim_t* vmprim void hak_close (hak_t* hak) { hak_fini(hak); - HAK_MMGR_FREE (HAK_MMGR(hak), hak); + HAK_MMGR_FREE(HAK_MMGR(hak), hak); } void* hak_getxtn (hak_t* hak) @@ -440,7 +445,6 @@ int hak_setoption (hak_t* hak, hak_option_t id, const void* value) hak->option.log_maxcapa = *(hak_oow_t*)value; break; - case HAK_LOG_TARGET_BCSTR: { hak_bch_t* v1; @@ -724,7 +728,7 @@ void* hak_reallocmem (hak_t* hak, void* ptr, hak_oow_t size) void hak_freemem (hak_t* hak, void* ptr) { - HAK_MMGR_FREE (HAK_MMGR(hak), ptr); + HAK_MMGR_FREE(HAK_MMGR(hak), ptr); } diff --git a/lib/hak.h b/lib/hak.h index 2c6173e..b97ec02 100644 --- a/lib/hak.h +++ b/lib/hak.h @@ -39,6 +39,30 @@ typedef struct hak_mod_t hak_mod_t; /* ========================================================================== */ +struct hak_bloc_t +{ + hak_oow_t line; /**< line */ + hak_oow_t colm; /**< column */ + const hak_bch_t* file; /**< file specified in #include */ +}; +typedef struct hak_bloc_t hak_bloc_t; + +struct hak_uloc_t +{ + hak_oow_t line; /**< line */ + hak_oow_t colm; /**< column */ + const hak_uch_t* file; /**< file specified in #include */ +}; +typedef struct hak_uloc_t hak_uloc_t; + +#if defined(HAK_OOCH_IS_UCH) +typedef hak_uloc_t hak_loc_t; +#else +typedef hak_bloc_t hak_loc_t; +#endif + +/* ========================================================================== */ + /** * The hak_errnum_t type defines the error codes. */ @@ -179,6 +203,40 @@ enum hak_synerrnum_t }; typedef enum hak_synerrnum_t hak_synerrnum_t; + +/* ========================================================================== */ + +#define HAK_ERRMSG_CAPA (2048) + +/** + * The hak_errbinf_t type defines a placeholder for error information. + */ +struct hak_errbinf_t +{ + hak_oow_t _instsize; + hak_errnum_t num; /**< error number */ + hak_bch_t msg[HAK_ERRMSG_CAPA]; /**< error message */ + hak_bloc_t loc; /**< error location */ +}; +typedef struct hak_errbinf_t hak_errbinf_t; + +struct hak_erruinf_t +{ + hak_oow_t _instsize; + hak_errnum_t num; /**< error number */ + hak_uch_t msg[HAK_ERRMSG_CAPA]; /**< error message */ + hak_uloc_t loc; /**< error location */ +}; +typedef struct hak_erruinf_t hak_erruinf_t; + +#if defined(HAK_OOCH_IS_UCH) +typedef hak_erruinf_t hak_errinf_t; +#else +typedef hak_errbinf_t hak_errinf_t; +#endif + +/* ========================================================================== */ + enum hak_option_t { HAK_TRAIT, @@ -1255,14 +1313,6 @@ enum hak_io_cmd_t }; typedef enum hak_io_cmd_t hak_io_cmd_t; -struct hak_loc_t -{ - hak_oow_t line; /**< line */ - hak_oow_t colm; /**< column */ - const hak_ooch_t* file; /**< file specified in #include */ -}; -typedef struct hak_loc_t hak_loc_t; - struct hak_lxc_t { hak_ooci_t c; /**< character */ @@ -1649,14 +1699,15 @@ struct hak_t hak_bch_t bch[HAK_ERRMSG_CAPA]; hak_uch_t uch[HAK_ERRMSG_CAPA]; } tmpbuf; - #if defined(HAK_OOCH_IS_BCH) - hak_uch_t xerrmsg[HAK_ERRMSG_CAPA]; - #else + #if defined(HAK_OOCH_IS_UCH) hak_bch_t xerrmsg[HAK_ERRMSG_CAPA * 2]; + hak_bch_t xerrlocfile[256 * 2]; + #else + hak_uch_t xerrmsg[HAK_ERRMSG_CAPA]; + hak_uch_t xerrlocfile[256]; #endif hak_ooch_t buf[HAK_ERRMSG_CAPA]; hak_oow_t len; - } errmsg; hak_loc_t errloc; int shuterr; @@ -2130,7 +2181,7 @@ HAK_EXPORT hak_t* hak_open ( hak_mmgr_t* mmgr, hak_oow_t xtnsize, const hak_vmprim_t* vmprim, - hak_errnum_t* errnum + hak_errinf_t* errinf ); /**/ @@ -2140,13 +2191,13 @@ HAK_EXPORT hak_t* hak_open ( HAK_EXPORT hak_t* hak_openstdwithmmgr ( hak_mmgr_t* mmgr, hak_oow_t xtnsize, - hak_errnum_t* errnum + hak_errinf_t* errinf ); /**/ HAK_EXPORT hak_t* hak_openstd ( hak_oow_t xtnsize, - hak_errnum_t* errnum + hak_errinf_t* errinf ); /** @@ -2281,6 +2332,21 @@ HAK_EXPORT const hak_bch_t* hak_geterrbmsg ( hak_t* hak ); +HAK_EXPORT void hak_geterrbinf ( + hak_t* hak, + hak_errbinf_t* errinf +); + +HAK_EXPORT void hak_geterruinf ( + hak_t* hak, + hak_erruinf_t* errinf +); +#if defined(HAK_OOCH_IS_UCH) +# define hak_geterrinf hak_geterruinf +#else +# define hak_geterrinf hak_geterrbinf +#endif + HAK_EXPORT hak_oow_t hak_copyerrbmsg ( hak_t* hak, hak_bch_t* buf, diff --git a/lib/json.c b/lib/json.c index a171036..46444ca 100644 --- a/lib/json.c +++ b/lib/json.c @@ -263,7 +263,7 @@ static int invoke_data_inst (hak_json_t* json, hak_json_inst_t inst) { if (inst != HAK_JSON_INST_STRING) { - hak_json_seterrbfmt (json, HAK_EINVAL, "dictionary key not a string - %.*js", json->tok.len, json->tok.ptr); + hak_json_seterrbfmt(json, HAK_EINVAL, "dictionary key not a string - %.*js", json->tok.len, json->tok.ptr); return -1; } @@ -328,7 +328,7 @@ static int handle_string_value_char (hak_json_t* json, hak_ooci_t c) if (n == 0 || n > HAK_COUNTOF(bcsbuf)) { /* illegal character or buffer to small */ - hak_json_seterrbfmt (json, HAK_EECERR, "unable to convert %jc", json->state_stack->u.sv.acc); + hak_json_seterrbfmt(json, HAK_EECERR, "unable to convert %jc", json->state_stack->u.sv.acc); return -1; } @@ -476,7 +476,7 @@ static int handle_character_value_char (hak_json_t* json, hak_ooci_t c) if (json->tok.len < 1) { - hak_json_seterrbfmt (json, HAK_EINVAL, "no character in a character literal"); + hak_json_seterrbfmt(json, HAK_EINVAL, "no character in a character literal"); return -1; } if (invoke_data_inst(json, HAK_JSON_INST_CHARACTER) <= -1) return -1; @@ -488,7 +488,7 @@ static int handle_character_value_char (hak_json_t* json, hak_ooci_t c) if (json->tok.len > 1) { - hak_json_seterrbfmt (json, HAK_EINVAL, "too many characters in a character literal - %.*js", json->tok.len, json->tok.ptr); + hak_json_seterrbfmt(json, HAK_EINVAL, "too many characters in a character literal - %.*js", json->tok.len, json->tok.ptr); return -1; } @@ -515,7 +515,7 @@ static int handle_numeric_value_char (hak_json_t* json, hak_ooci_t c) HAK_ASSERT(json->dummy_hak, json->tok.len > 0); if (!is_digitchar(json->tok.ptr[json->tok.len - 1])) { - hak_json_seterrbfmt (json, HAK_EINVAL, "invalid numeric value - %.*js", json->tok.len, json->tok.ptr); + hak_json_seterrbfmt(json, HAK_EINVAL, "invalid numeric value - %.*js", json->tok.len, json->tok.ptr); return -1; } if (invoke_data_inst(json, HAK_JSON_INST_NUMBER) <= -1) return -1; @@ -539,7 +539,7 @@ static int handle_word_value_char (hak_json_t* json, hak_ooci_t c) else if (hak_comp_oochars_bcstr(json->tok.ptr, json->tok.len, "false") == 0) inst = HAK_JSON_INST_FALSE; else { - hak_json_seterrbfmt (json, HAK_EINVAL, "invalid word value - %.*js", json->tok.len, json->tok.ptr); + hak_json_seterrbfmt(json, HAK_EINVAL, "invalid word value - %.*js", json->tok.len, json->tok.ptr); return -1; } @@ -572,7 +572,7 @@ static int handle_start_char (hak_json_t* json, hak_ooci_t c) } else { - hak_json_seterrbfmt (json, HAK_EINVAL, "not starting with [ or { - %jc", (hak_ooch_t)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "not starting with [ or { - %jc", (hak_ooch_t)c); return -1; } } @@ -589,7 +589,7 @@ static int handle_char_in_array (hak_json_t* json, hak_ooci_t c) { if (!json->state_stack->u.ia.got_value) { - hak_json_seterrbfmt (json, HAK_EINVAL, "redundant comma in array - %jc", (hak_ooch_t)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "redundant comma in array - %jc", (hak_ooch_t)c); return -1; } json->state_stack->u.ia.got_value = 0; @@ -604,7 +604,7 @@ static int handle_char_in_array (hak_json_t* json, hak_ooci_t c) { if (json->state_stack->u.ia.got_value) { - hak_json_seterrbfmt (json, HAK_EINVAL, "comma required in array - %jc", (hak_ooch_t)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "comma required in array - %jc", (hak_ooch_t)c); return -1; } @@ -651,7 +651,7 @@ static int handle_char_in_array (hak_json_t* json, hak_ooci_t c) } else { - hak_json_seterrbfmt (json, HAK_EINVAL, "wrong character inside array - %jc[%d]", (hak_ooch_t)c, (int)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "wrong character inside array - %jc[%d]", (hak_ooch_t)c, (int)c); return -1; } } @@ -669,7 +669,7 @@ static int handle_char_in_dic (hak_json_t* json, hak_ooci_t c) { if (json->state_stack->u.id.state != 1) { - hak_json_seterrbfmt (json, HAK_EINVAL, "redundant colon in dictionary - %jc", (hak_ooch_t)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "redundant colon in dictionary - %jc", (hak_ooch_t)c); return -1; } json->state_stack->u.id.state++; @@ -679,7 +679,7 @@ static int handle_char_in_dic (hak_json_t* json, hak_ooci_t c) { if (json->state_stack->u.id.state != 3) { - hak_json_seterrbfmt (json, HAK_EINVAL, "redundant comma in dicitonary - %jc", (hak_ooch_t)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "redundant comma in dicitonary - %jc", (hak_ooch_t)c); return -1; } json->state_stack->u.id.state = 0; @@ -694,12 +694,12 @@ static int handle_char_in_dic (hak_json_t* json, hak_ooci_t c) { if (json->state_stack->u.id.state == 1) { - hak_json_seterrbfmt (json, HAK_EINVAL, "colon required in dicitonary - %jc", (hak_ooch_t)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "colon required in dicitonary - %jc", (hak_ooch_t)c); return -1; } else if (json->state_stack->u.id.state == 3) { - hak_json_seterrbfmt (json, HAK_EINVAL, "comma required in dicitonary - %jc", (hak_ooch_t)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "comma required in dicitonary - %jc", (hak_ooch_t)c); return -1; } @@ -746,7 +746,7 @@ static int handle_char_in_dic (hak_json_t* json, hak_ooci_t c) } else { - hak_json_seterrbfmt (json, HAK_EINVAL, "wrong character inside dictionary - %jc[%d]", (hak_ooch_t)c, (int)c); + hak_json_seterrbfmt(json, HAK_EINVAL, "wrong character inside dictionary - %jc[%d]", (hak_ooch_t)c, (int)c); return -1; } } @@ -768,7 +768,7 @@ start_over: } else { - hak_json_seterrbfmt (json, HAK_EFINIS, "unexpected end of data"); + hak_json_seterrbfmt(json, HAK_EFINIS, "unexpected end of data"); return -1; } } @@ -804,7 +804,7 @@ start_over: break; default: - hak_json_seterrbfmt (json, HAK_EINTERN, "internal error - must not be called for state %d", (int)json->state_stack->state); + hak_json_seterrbfmt(json, HAK_EINTERN, "internal error - must not be called for state %d", (int)json->state_stack->state); return -1; } @@ -911,7 +911,7 @@ oops: /* ========================================================================= */ -hak_json_t* hak_json_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_json_prim_t* prim, hak_errnum_t* errnum) +hak_json_t* hak_json_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_json_prim_t* prim, hak_errinf_t* errinf) { hak_json_t* json; hak_t* hak; @@ -920,14 +920,19 @@ hak_json_t* hak_json_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_json_prim_t* json = (hak_json_t*)HAK_MMGR_ALLOC(mmgr, HAK_SIZEOF(*json) + xtnsize); if (!json) { - if (errnum) *errnum = HAK_ESYSMEM; + if (errinf) + { + HAK_MEMSET(errinf, 0, HAK_SIZEOF(*errinf)); + errinf->num = HAK_ESYSMEM; + hak_copy_oocstr(errinf->msg, HAK_COUNTOF(errinf->msg), hak_errnum_to_errstr(errinf->num)); + } return HAK_NULL; } - hak = hak_openstdwithmmgr(mmgr, HAK_SIZEOF(*xtn), errnum); + hak = hak_openstdwithmmgr(mmgr, HAK_SIZEOF(*xtn), errinf); if (!hak) { - HAK_MMGR_FREE (mmgr, json); + HAK_MMGR_FREE(mmgr, json); return HAK_NULL; } @@ -987,7 +992,7 @@ int hak_json_setoption (hak_json_t* json, hak_json_option_t id, const void* valu return 0; } - hak_json_seterrnum (json, HAK_EINVAL); + hak_json_seterrnum(json, HAK_EINVAL); return -1; } @@ -1004,7 +1009,7 @@ int hak_json_getoption (hak_json_t* json, hak_json_option_t id, void* value) return 0; }; - hak_json_seterrnum (json, HAK_EINVAL); + hak_json_seterrnum(json, HAK_EINVAL); return -1; } @@ -1057,7 +1062,7 @@ void hak_json_seterrbfmt (hak_json_t* json, hak_errnum_t errnum, const hak_bch_t va_list ap; va_start (ap, fmt); - hak_seterrbfmtv (json->dummy_hak, errnum, fmt, ap); + hak_seterrbfmtv(json->dummy_hak, errnum, fmt, ap); va_end (ap); HAK_ASSERT(json->dummy_hak, HAK_COUNTOF(json->errmsg.buf) == HAK_COUNTOF(json->dummy_hak->errmsg.buf)); @@ -1071,7 +1076,7 @@ void hak_json_seterrufmt (hak_json_t* json, hak_errnum_t errnum, const hak_uch_t va_list ap; va_start (ap, fmt); - hak_seterrufmtv (json->dummy_hak, errnum, fmt, ap); + hak_seterrufmtv(json->dummy_hak, errnum, fmt, ap); va_end (ap); HAK_ASSERT(json->dummy_hak, HAK_COUNTOF(json->errmsg.buf) == HAK_COUNTOF(json->dummy_hak->errmsg.buf)); @@ -1105,7 +1110,7 @@ void* hak_json_allocmem (hak_json_t* json, hak_oow_t size) void* ptr; ptr = HAK_MMGR_ALLOC(json->mmgr, size); - if (!ptr) hak_json_seterrnum (json, HAK_ESYSMEM); + if (!ptr) hak_json_seterrnum(json, HAK_ESYSMEM); return ptr; } @@ -1114,7 +1119,7 @@ void* hak_json_callocmem (hak_json_t* json, hak_oow_t size) void* ptr; ptr = HAK_MMGR_ALLOC(json->mmgr, size); - if (!ptr) hak_json_seterrnum (json, HAK_ESYSMEM); + if (!ptr) hak_json_seterrnum(json, HAK_ESYSMEM); else HAK_MEMSET(ptr, 0, size); return ptr; } @@ -1122,13 +1127,13 @@ void* hak_json_callocmem (hak_json_t* json, hak_oow_t size) void* hak_json_reallocmem (hak_json_t* json, void* ptr, hak_oow_t size) { ptr = HAK_MMGR_REALLOC(json->mmgr, ptr, size); - if (!ptr) hak_json_seterrnum (json, HAK_ESYSMEM); + if (!ptr) hak_json_seterrnum(json, HAK_ESYSMEM); return ptr; } void hak_json_freemem (hak_json_t* json, void* ptr) { - HAK_MMGR_FREE (json->mmgr, ptr); + HAK_MMGR_FREE(json->mmgr, ptr); } /* ========================================================================= */ diff --git a/lib/std.c b/lib/std.c index 4b5af5f..9a8cca4 100644 --- a/lib/std.c +++ b/lib/std.c @@ -4089,7 +4089,7 @@ static LONG WINAPI msw_exception_filter (struct _EXCEPTION_POINTERS* exinfo) } #endif -hak_t* hak_openstdwithmmgr (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_errnum_t* errnum) +hak_t* hak_openstdwithmmgr (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_errinf_t* errinf) { hak_t* hak; hak_vmprim_t vmprim; @@ -4116,7 +4116,7 @@ hak_t* hak_openstdwithmmgr (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_errnum_t* e vmprim.vm_getsig = vm_getsig; vmprim.vm_setsig = vm_setsig; - hak = hak_open(mmgr, HAK_SIZEOF(xtn_t) + xtnsize, &vmprim, errnum); + hak = hak_open(mmgr, HAK_SIZEOF(xtn_t) + xtnsize, &vmprim, errinf); if (HAK_UNLIKELY(!hak)) return HAK_NULL; /* adjust the object size by the sizeof xtn_t so that hak_getxtn() returns the right pointer. */ @@ -4133,7 +4133,7 @@ hak_t* hak_openstdwithmmgr (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_errnum_t* e cb.vm_cleanup = cb_vm_cleanup; if (hak_regcb(hak, &cb) == HAK_NULL) { - if (errnum) *errnum = HAK_ERRNUM(hak); + if (errinf) hak_geterrinf(hak, errinf); hak_close(hak); return HAK_NULL; } @@ -4145,9 +4145,9 @@ hak_t* hak_openstdwithmmgr (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_errnum_t* e return hak; } -hak_t* hak_openstd (hak_oow_t xtnsize, hak_errnum_t* errnum) +hak_t* hak_openstd (hak_oow_t xtnsize, hak_errinf_t* errinf) { - return hak_openstdwithmmgr(&sys_mmgr, xtnsize, errnum); + return hak_openstdwithmmgr(&sys_mmgr, xtnsize, errinf); } /* --------------------------------------------------------------------- */ diff --git a/lib/x-client.c b/lib/x-client.c index 04132ee..78693c3 100644 --- a/lib/x-client.c +++ b/lib/x-client.c @@ -156,7 +156,7 @@ static void client_log_write_for_dummy (hak_t* hak, hak_bitmask_t mask, const ha client->prim.log_write (client, mask, msg, len); } -hak_client_t* hak_client_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_client_prim_t* prim, hak_errnum_t* errnum) +hak_client_t* hak_client_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_client_prim_t* prim, hak_errinf_t* errinf) { hak_client_t* client = HAK_NULL; hak_t* hak = HAK_NULL; @@ -166,20 +166,25 @@ hak_client_t* hak_client_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_client_p client = (hak_client_t*)HAK_MMGR_ALLOC(mmgr, HAK_SIZEOF(*client) + xtnsize); if (HAK_UNLIKELY(!client)) { - if (errnum) *errnum = HAK_ESYSMEM; - return HAK_NULL; + if (errinf) + { + HAK_MEMSET(errinf, 0, HAK_SIZEOF(*errinf)); + errinf->num = HAK_ESYSMEM; + hak_copy_oocstr(errinf->msg, HAK_COUNTOF(errinf->msg), hak_errnum_to_errstr(errinf->num)); + } + goto oops; } - hak = hak_openstdwithmmgr(mmgr, HAK_SIZEOF(*xtn), errnum); - if (HAK_UNLIKELY(!hak)) - { - HAK_MMGR_FREE (mmgr, client); - return HAK_NULL; - } + hak = hak_openstdwithmmgr(mmgr, HAK_SIZEOF(*xtn), errinf); + if (HAK_UNLIKELY(!hak)) goto oops; if (hak_sys_open_pipes(pfd, 1) <= -1) { - if (errnum) *errnum = hak->vmprim.syserrstrb(hak, 0, errno, HAK_NULL, 0); + if (errinf) + { + hak_seterrbfmtwithsyserr(hak, 0, errno, HAK_NULL, 0); + hak_geterrinf(hak, errinf); + } goto oops; } @@ -215,7 +220,7 @@ hak_client_t* hak_client_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_client_p oops: /* NOTE: pipe should be closed if jump to here is made after pipe() above */ if (hak) hak_close(hak); - if (client) HAK_MMGR_FREE (mmgr, client); + if (client) HAK_MMGR_FREE(mmgr, client); return HAK_NULL; } @@ -234,7 +239,7 @@ void hak_client_close (hak_client_t* client) hak_sys_close_pipes(client->mux_pipe); hak_close (client->dummy_hak); - HAK_MMGR_FREE (client->_mmgr, client); + HAK_MMGR_FREE(client->_mmgr, client); } int hak_client_setoption (hak_client_t* client, hak_client_option_t id, const void* value) @@ -433,7 +438,7 @@ void* hak_client_reallocmem (hak_client_t* client, void* ptr, hak_oow_t size) void hak_client_freemem (hak_client_t* client, void* ptr) { - HAK_MMGR_FREE (client->_mmgr, ptr); + HAK_MMGR_FREE(client->_mmgr, ptr); } /* ========================================================================= */ @@ -673,7 +678,7 @@ hak_client_logbfmt(client, HAK_LOG_STDERR, "send error - %hs\n", strerror(errno) hak_uint8_t* bptr; ssize_t x; - bptr = hak_xproto_getbuf(client->remote.proto, &bcap);; + bptr = hak_xproto_getbuf(client->remote.proto, &bcap); x = recv(client->remote.sck, bptr, bcap, 0); if (x <= -1) { diff --git a/lib/x-server.c b/lib/x-server.c index 14fd05c..a02277b 100644 --- a/lib/x-server.c +++ b/lib/x-server.c @@ -888,10 +888,10 @@ static int kill_server_worker (hak_xproto_t* proto, hak_oow_t wid) worker = proto_to_worker(proto); server = worker->server; - pthread_mutex_lock (&server->worker_mutex); + pthread_mutex_lock(&server->worker_mutex); if (wid >= server->wid_map.capa) { - hak_server_seterrnum (server, HAK_ENOENT); + hak_server_seterrnum(server, HAK_ENOENT); xret = -1; } else @@ -900,7 +900,7 @@ static int kill_server_worker (hak_xproto_t* proto, hak_oow_t wid) if (!server->wid_map.ptr[wid].used) { - hak_server_seterrnum (server, HAK_ENOENT); + hak_server_seterrnum(server, HAK_ENOENT); xret = -1; } else @@ -908,17 +908,17 @@ static int kill_server_worker (hak_xproto_t* proto, hak_oow_t wid) worker = server->wid_map.ptr[wid].u.worker; if (!worker) { - hak_server_seterrnum (server, HAK_ENOENT); + hak_server_seterrnum(server, HAK_ENOENT); xret = -1; } else { - if (worker->sck) shutdown (worker->sck, SHUT_RDWR); - if (worker->hak) hak_abort (worker->hak); + if (worker->sck) shutdown(worker->sck, SHUT_RDWR); + if (worker->hak) hak_abort(worker->hak); } } } - pthread_mutex_unlock (&server->worker_mutex); + pthread_mutex_unlock(&server->worker_mutex); return xret; } @@ -1105,7 +1105,7 @@ static int send_chars (hak_xproto_t* proto, hak_xpkt_type_t xpkt_type, const hak /* ========================================================================= */ -hak_server_t* hak_server_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_server_prim_t* prim, hak_errnum_t* errnum) +hak_server_t* hak_server_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_server_prim_t* prim, hak_errinf_t* errinf) { hak_server_t* server = HAK_NULL; hak_t* hak = HAK_NULL; @@ -1117,26 +1117,32 @@ hak_server_t* hak_server_open (hak_mmgr_t* mmgr, hak_oow_t xtnsize, hak_server_p server = (hak_server_t*)HAK_MMGR_ALLOC(mmgr, HAK_SIZEOF(*server) + xtnsize); if (!server) { - if (errnum) *errnum = HAK_ESYSMEM; - return HAK_NULL; + esysmem: + if (errinf) + { + HAK_MEMSET(errinf, 0, HAK_SIZEOF(*errinf)); + errinf->num = HAK_ESYSMEM; + hak_copy_oocstr(errinf->msg, HAK_COUNTOF(errinf->msg), hak_errnum_to_errstr(errinf->num)); + } + goto oops; } - hak = hak_openstdwithmmgr(mmgr, HAK_SIZEOF(*xtn), errnum); + hak = hak_openstdwithmmgr(mmgr, HAK_SIZEOF(*xtn), errinf); if (!hak) goto oops; /* replace the vmprim.log_write function */ hak->vmprim.log_write = server_log_write_for_dummy; tmr = hak_tmr_open(hak, 0, 1024); /* TOOD: make the timer's default size configurable */ - if (!tmr) - { - if (errnum) *errnum = HAK_ESYSMEM; - goto oops; - } + if (!tmr) goto esysmem; if (hak_sys_open_pipes(pfd, 1) <= -1) { - if (errnum) *errnum = hak->vmprim.syserrstrb(hak, 0, errno, HAK_NULL, 0); + if (errinf) + { + hak_seterrbfmtwithsyserr(hak, 0, errno, HAK_NULL, 0); + hak_geterrinf(hak, errinf); + } goto oops; } @@ -1188,7 +1194,7 @@ oops: /* NOTE: pipe should be closed if jump to here is made after pipe() above */ if (tmr) hak_tmr_close (tmr); if (hak) hak_close(hak); - if (server) HAK_MMGR_FREE (mmgr, server); + if (server) HAK_MMGR_FREE(mmgr, server); return HAK_NULL; } @@ -1215,7 +1221,7 @@ void hak_server_close (hak_server_t* server) hak_tmr_close (server->tmr); hak_close (server->dummy_hak); - HAK_MMGR_FREE (server->_mmgr, server); + HAK_MMGR_FREE(server->_mmgr, server); } static HAK_INLINE int prepare_to_acquire_wid (hak_server_t* server) @@ -1232,7 +1238,7 @@ static HAK_INLINE int prepare_to_acquire_wid (hak_server_t* server) { if (server->wid_map.capa >= HAK_SERVER_WID_MAX) { - hak_server_seterrnum (server, HAK_EFLOOD); + hak_server_seterrnum(server, HAK_EFLOOD); return -1; } @@ -1463,7 +1469,7 @@ static int worker_step (hak_server_worker_t* worker) hak_oow_t bcap; hak_uint8_t* bptr; - bptr = hak_xproto_getbuf(proto, &bcap);; + bptr = hak_xproto_getbuf(proto, &bcap); x = recv(worker->sck, bptr, bcap, 0); if (x <= -1) { @@ -2096,7 +2102,7 @@ int hak_server_setoption (hak_server_t* server, hak_server_option_t id, const vo return 0; } - hak_server_seterrnum (server, HAK_EINVAL); + hak_server_seterrnum(server, HAK_EINVAL); return -1; } @@ -2141,7 +2147,7 @@ int hak_server_getoption (hak_server_t* server, hak_server_option_t id, void* va return 0; }; - hak_server_seterrnum (server, HAK_EINVAL); + hak_server_seterrnum(server, HAK_EINVAL); return -1; } @@ -2181,7 +2187,7 @@ const hak_ooch_t* hak_server_geterrmsg (hak_server_t* server) return server->errmsg.buf; } -void hak_server_seterrnum (hak_server_t* server, hak_errnum_t errnum) +void hak_server_seterrnum(hak_server_t* server, hak_errnum_t errnum) { /*if (server->shuterr) return; */ server->errnum = errnum; @@ -2222,7 +2228,7 @@ void* hak_server_allocmem (hak_server_t* server, hak_oow_t size) void* ptr; ptr = HAK_MMGR_ALLOC(server->_mmgr, size); - if (!ptr) hak_server_seterrnum (server, HAK_ESYSMEM); + if (!ptr) hak_server_seterrnum(server, HAK_ESYSMEM); return ptr; } @@ -2231,7 +2237,7 @@ void* hak_server_callocmem (hak_server_t* server, hak_oow_t size) void* ptr; ptr = HAK_MMGR_ALLOC(server->_mmgr, size); - if (!ptr) hak_server_seterrnum (server, HAK_ESYSMEM); + if (!ptr) hak_server_seterrnum(server, HAK_ESYSMEM); else HAK_MEMSET(ptr, 0, size); return ptr; } @@ -2239,11 +2245,11 @@ void* hak_server_callocmem (hak_server_t* server, hak_oow_t size) void* hak_server_reallocmem (hak_server_t* server, void* ptr, hak_oow_t size) { ptr = HAK_MMGR_REALLOC(server->_mmgr, ptr, size); - if (!ptr) hak_server_seterrnum (server, HAK_ESYSMEM); + if (!ptr) hak_server_seterrnum(server, HAK_ESYSMEM); return ptr; } void hak_server_freemem (hak_server_t* server, void* ptr) { - HAK_MMGR_FREE (server->_mmgr, ptr); + HAK_MMGR_FREE(server->_mmgr, ptr); }