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

updated hak_open()/hak_openstd()/etc to accept the pointer to hak_errinf_t to convey an error message upon instantiation failure.

Browse Source 
added hak_errbint_t and hak_erruinf_t and related functions
enhanced the wchar_t detection for wide_char yes:4w
This commit is contained in:
hyung-hwan
2025-10-06 00:59:20 +09:00
parent 78f43c8b4f
commit 56dfb3630e
13 changed files with 298 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
bin/hak.c
View File

@ -30,6 +30,7 @@
#include <hak.h>
#include <hak-chr.h>
#include <hak-cmgr.h>
#include <hak-str.h>
#include <hak-utl.h>
#include <hak-opt.h>
@ -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

2
lib/comp.c
View File

@ -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);

102
lib/err.c
View File

@ -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));

4
lib/fmt.c
View File

@ -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;

10
lib/hak-cmn.h
View File

@ -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

2
lib/hak-json.h
View File

@ -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 (

4
lib/hak-x.h
View File

@ -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 (

20
lib/hak.c
View File

@ -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);
}

96
lib/hak.h
View File

@ -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,

63
lib/json.c
View File

@ -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);
}
/* ========================================================================= */

10
lib/std.c
View File

@ -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);
}
/* --------------------------------------------------------------------- */

33
lib/x-client.c
View File

@ -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)
{

62
lib/x-server.c
View File

@ -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);
}