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

update for type correctness
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
hyung-hwan 2024-04-06 16:52:53 +09:00
parent 50bf4a1c0c
commit d578ded2c8
14 changed files with 65 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
bin/main.c
View File

@ -195,11 +195,11 @@ static int handle_logopt (hcl_t* hcl, const hcl_bch_t* logstr)
{ "debug-", 0, HCL_LOG_DEBUG },
/* exclude a specific level */
{ "-fatal", 1, ~HCL_LOG_FATAL },
{ "-error", 1, ~HCL_LOG_ERROR },
{ "-warn", 1, ~HCL_LOG_WARN },
{ "-info", 1, ~HCL_LOG_INFO },
{ "-debug", 1, ~HCL_LOG_DEBUG },
{ "-fatal", 1, ~(hcl_bitmask_t)HCL_LOG_FATAL },
{ "-error", 1, ~(hcl_bitmask_t)HCL_LOG_ERROR },
{ "-warn", 1, ~(hcl_bitmask_t)HCL_LOG_WARN },
{ "-info", 1, ~(hcl_bitmask_t)HCL_LOG_INFO },
{ "-debug", 1, ~(hcl_bitmask_t)HCL_LOG_DEBUG },
};
cm = hcl_find_bchar_in_bcstr(logstr, ',');

12
lib/exec.c
View File

@ -460,7 +460,7 @@ static HCL_INLINE int prepare_to_alloc_pid (hcl_t* hcl)
}
tmp = (hcl_oop_t*)hcl_reallocmem(hcl, hcl->proc_map, HCL_SIZEOF(hcl_oop_t) * new_capa);
if (!tmp) return -1;
if (HCL_UNLIKELY(!tmp)) return -1;
hcl->proc_map_free_first = hcl->proc_map_capa;
for (i = hcl->proc_map_capa, j = hcl->proc_map_capa + 1; j < new_capa; i++, j++)
@ -1579,8 +1579,8 @@ static int add_sem_to_sem_io_tuple (hcl_t* hcl, hcl_oop_semaphore_t sem, hcl_ooi
/* TODO: specify the maximum io_handle supported and check it here instead of just relying on memory allocation success/failure? */
new_capa = HCL_ALIGN_POW2(io_handle + 1, SEM_IO_MAP_ALIGN);
tmp = hcl_reallocmem (hcl, hcl->sem_io_map, HCL_SIZEOF(*tmp) * new_capa);
if (!tmp)
tmp = (hcl_ooi_t*)hcl_reallocmem(hcl, hcl->sem_io_map, HCL_SIZEOF(*tmp) * new_capa);
if (HCL_UNLIKELY(!tmp))
{
const hcl_ooch_t* oldmsg = hcl_backuperrmsg(hcl);
hcl_seterrbfmt (hcl, hcl->errnum, "handle %zd out of supported range - %js", oldmsg);
@ -1611,8 +1611,8 @@ static int add_sem_to_sem_io_tuple (hcl_t* hcl, hcl_oop_semaphore_t sem, hcl_ooi
/* no overflow check when calculating the new capacity
* owing to SEM_IO_TUPLE_MAX check above */
new_capa = hcl->sem_io_tuple_capa + SEM_IO_TUPLE_INC;
tmp = hcl_reallocmem (hcl, hcl->sem_io_tuple, HCL_SIZEOF(hcl_sem_tuple_t) * new_capa);
if (!tmp) return -1;
tmp = (hcl_sem_tuple_t*)hcl_reallocmem(hcl, hcl->sem_io_tuple, HCL_SIZEOF(hcl_sem_tuple_t) * new_capa);
if (HCL_UNLIKELY(!tmp)) return -1;
hcl->sem_io_tuple = tmp;
hcl->sem_io_tuple_capa = new_capa;
@ -2523,7 +2523,7 @@ static HCL_INLINE int exec_syscmd (hcl_t* hcl, hcl_ooi_t nargs)
/* TODO: close file descriptors??? */
argv = (hcl_bch_t**)hcl_allocmem(hcl, (nargs + 2) * HCL_SIZEOF(*argv));
if (argv)
if (HCL_LIKELY(argv))
{
argv[0] = cmd;
HCL_DEBUG1 (hcl, "NARG %d\n", (int)nargs);

4
lib/fmt.c
View File

@ -1581,8 +1581,8 @@ redo:
}
/* +1 to handle line ending injection more easily */
tmp = hcl_reallocmem(hcl, hcl->log.ptr, (newcapa + 1) * HCL_SIZEOF(*tmp));
if (!tmp)
tmp = (hcl_ooch_t*)hcl_reallocmem(hcl, hcl->log.ptr, (newcapa + 1) * HCL_SIZEOF(*tmp));
if (HCL_UNLIKELY(!tmp))
{
make_do:
if (hcl->log.len > 0)

14
lib/gc.c
View File

@ -33,7 +33,7 @@ static struct
{
hcl_oow_t len;
hcl_ooch_t ptr[20];
int syncode;
hcl_syncode_t syncode;
hcl_oow_t offset;
} syminfo[] =
{
@ -1294,7 +1294,7 @@ static int ignite_2 (hcl_t* hcl)
hcl->symtab->tally = HCL_SMOOI_TO_OOP(0);
}
if (HCL_LIKELY(hcl->symtab->bucket == hcl->_nil))
if (HCL_LIKELY((hcl_oop_t)hcl->symtab->bucket == hcl->_nil))
{
/* It's important to assign the result of hcl_instantiate() to a temporary
* variable first and then assign it to hcl->symtab->bucket.
@ -1321,7 +1321,7 @@ static int ignite_2 (hcl_t* hcl)
hcl->sysdic->tally = HCL_SMOOI_TO_OOP(0);
}
if (HCL_LIKELY(hcl->sysdic->bucket == hcl->_nil))
if (HCL_LIKELY((hcl_oop_t)hcl->sysdic->bucket == hcl->_nil))
{
/* It's important to assign the result of hcl_instantiate() to a temporary
* variable first and then assign it to hcl->symtab->bucket.
@ -1576,7 +1576,7 @@ oops:
return -1;
}
int hcl_getsyncodebyoocs_noseterr (hcl_t* hcl, const hcl_oocs_t* name)
hcl_syncode_t hcl_getsyncodebyoocs_noseterr (hcl_t* hcl, const hcl_oocs_t* name)
{
hcl_oow_t i;
for (i = 0; i < HCL_COUNTOF(syminfo); i++)
@ -1584,10 +1584,10 @@ int hcl_getsyncodebyoocs_noseterr (hcl_t* hcl, const hcl_oocs_t* name)
if (hcl_comp_oochars(syminfo[i].ptr, syminfo[i].len, name->ptr, name->len) == 0)
return syminfo[i].syncode;
}
return 0; /* 0 indicates no syntax code found */
return HCL_SYNCODE_NONE; /* indicates no syntax code found */
}
int hcl_getsyncode_noseterr (hcl_t* hcl, const hcl_ooch_t* ptr, const hcl_oow_t len)
hcl_syncode_t hcl_getsyncode_noseterr (hcl_t* hcl, const hcl_ooch_t* ptr, const hcl_oow_t len)
{
hcl_oow_t i;
for (i = 0; i < HCL_COUNTOF(syminfo); i++)
@ -1595,7 +1595,7 @@ int hcl_getsyncode_noseterr (hcl_t* hcl, const hcl_ooch_t* ptr, const hcl_oow_t
if (hcl_comp_oochars(syminfo[i].ptr, syminfo[i].len, ptr, len) == 0)
return syminfo[i].syncode;
}
return 0; /* 0 indicates no syntax code found */
return HCL_SYNCODE_NONE; /* indicates no syntax code found */
}
const hcl_ooch_t* hcl_getsyncodename_noseterr (hcl_t* hcl, hcl_syncode_t syncode)

6
lib/hcl-prv.h
View File

@ -396,7 +396,7 @@ enum hcl_cnode_flag_t
{
HCL_CNODE_AUTO_FORGED = (1 << 0)
};
typedef enum hcl_cnode_flagt hcl_cnode_flag_t;
typedef enum hcl_cnode_flag_t hcl_cnode_flag_t;
#define HCL_CNODE_GET_TYPE(x) ((x)->cn_type)
#define HCL_CNODE_GET_FLAGS(x) ((x)->cn_flags)
@ -1554,12 +1554,12 @@ void hcl_gc_ms_sweep_lazy (
hcl_oow_t allocsize
);
int hcl_getsyncodebyoocs_noseterr (
hcl_syncode_t hcl_getsyncodebyoocs_noseterr (
hcl_t* hcl,
const hcl_oocs_t* name
);
int hcl_getsyncode_noseterr (
hcl_syncode_t hcl_getsyncode_noseterr (
hcl_t* hcl,
const hcl_ooch_t* ptr,
const hcl_oow_t len

14
lib/hcl.c
View File

@ -157,7 +157,7 @@ int hcl_init (hcl_t* hcl, hcl_mmgr_t* mmgr, const hcl_vmprim_t* vmprim)
if (HCL_UNLIKELY(!hcl->log.ptr)) goto oops;
hcl->gci.stack.capa = HCL_ALIGN_POW2(1, 1024); /* TODO: is this a good initial size? */
hcl->gci.stack.ptr = hcl_allocmem(hcl, (hcl->gci.stack.capa + 1) * HCL_SIZEOF(*hcl->gci.stack.ptr));
hcl->gci.stack.ptr = (hcl_oop_t*)hcl_allocmem(hcl, (hcl->gci.stack.capa + 1) * HCL_SIZEOF(*hcl->gci.stack.ptr));
if (HCL_UNLIKELY(!hcl->gci.stack.ptr)) goto oops;
n = hcl_rbt_init(&hcl->modtab, hcl, HCL_SIZEOF(hcl_ooch_t), 1);
@ -397,7 +397,7 @@ void hcl_reset (hcl_t* hcl)
hcl_gc (hcl, 1);
}
static int dup_str_opt (hcl_t* hcl, const void* value, hcl_oocs_t* tmp)
static int dup_str_opt (hcl_t* hcl, const hcl_ooch_t* value, hcl_oocs_t* tmp)
{
if (value)
{
@ -440,10 +440,10 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
hcl_bch_t* v1;
hcl_uch_t* v2;
v1 = hcl_dupbcstr(hcl, value, HCL_NULL);
v1 = hcl_dupbcstr(hcl, (const hcl_bch_t*)value, HCL_NULL);
if (HCL_UNLIKELY(!v1)) return -1;
v2 = hcl_dupbtoucstr(hcl, value, HCL_NULL);
v2 = hcl_dupbtoucstr(hcl, (const hcl_bch_t*)value, HCL_NULL);
if (HCL_UNLIKELY(!v2))
{
hcl_freemem (hcl, v1);
@ -460,10 +460,10 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
hcl_uch_t* v1;
hcl_bch_t* v2;
v1 = hcl_dupucstr(hcl, value, HCL_NULL);
v1 = hcl_dupucstr(hcl, (const hcl_uch_t*)value, HCL_NULL);
if (HCL_UNLIKELY(!v1)) return -1;
v2 = hcl_duputobcstr(hcl, value, HCL_NULL);
v2 = hcl_duputobcstr(hcl, (const hcl_uch_t*)value, HCL_NULL);
if (HCL_UNLIKELY(!v2))
{
hcl_freemem (hcl, v1);
@ -557,7 +557,7 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
hcl_oocs_t tmp;
int idx;
if (dup_str_opt(hcl, value, &tmp) <= -1) return -1;
if (dup_str_opt(hcl, (const hcl_ooch_t*)value, &tmp) <= -1) return -1;
idx = id - HCL_MOD_LIBDIRS;
if (hcl->option.mod[idx].ptr) hcl_freemem (hcl, hcl->option.mod[idx].ptr);

4
lib/hcl.h
View File

@ -1992,7 +1992,9 @@ typedef enum hcl_brand_t hcl_brand_t;
enum hcl_syncode_t
{
/* SYNCODE 0 means it's not a syncode object. so it begins with 1 */
HCL_SYNCODE_NONE = 0,
/* SYNCODE 0 means it's not a syncode object. so the actual code begins with 1 */
/* these enumerators can be set in the SYNCODE flags for a symbol */
HCL_SYNCODE_AND = 1,
HCL_SYNCODE_BREAK,

6
lib/heap.c
View File

@ -26,17 +26,17 @@
static void* xma_alloc (hcl_mmgr_t* mmgr, hcl_oow_t size)
{
return hcl_xma_alloc(mmgr->ctx, size);
return hcl_xma_alloc((hcl_xma_t*)mmgr->ctx, size);
}
static void* xma_realloc (hcl_mmgr_t* mmgr, void* ptr, hcl_oow_t size)
{
return hcl_xma_realloc(mmgr->ctx, ptr, size);
return hcl_xma_realloc((hcl_xma_t*)mmgr->ctx, ptr, size);
}
static void xma_free (hcl_mmgr_t* mmgr, void* ptr)
{
hcl_xma_free (mmgr->ctx, ptr);
hcl_xma_free ((hcl_xma_t*)mmgr->ctx, ptr);
}
hcl_heap_t* hcl_makeheap (hcl_t* hcl, hcl_oow_t size)

10
lib/obj.c
View File

@ -506,7 +506,7 @@ static HCL_INLINE int decode_spec (hcl_t* hcl, hcl_oop_class_t _class, hcl_oow_t
if (HCL_CLASS_SPEC_IS_INDEXED(spec))
{
indexed_type = HCL_CLASS_SPEC_INDEXED_TYPE(spec);
indexed_type = (hcl_obj_type_t)HCL_CLASS_SPEC_INDEXED_TYPE(spec);
/* the number of the fixed fields for a non-pointer object are supported.
* the fixed fields of a pointer object holds named instance variables
@ -603,19 +603,19 @@ hcl_oop_t hcl_instantiate (hcl_t* hcl, hcl_oop_class_t _class, const void* vptr,
break;
case HCL_OBJ_TYPE_CHAR:
oop = hcl_alloccharobj(hcl, HCL_BRAND_INSTANCE, vptr, alloclen);
oop = hcl_alloccharobj(hcl, HCL_BRAND_INSTANCE, (const hcl_ooch_t*)vptr, alloclen);
break;
case HCL_OBJ_TYPE_BYTE:
oop = hcl_allocbyteobj(hcl, HCL_BRAND_INSTANCE, vptr, alloclen);
oop = hcl_allocbyteobj(hcl, HCL_BRAND_INSTANCE, (const hcl_oob_t*)vptr, alloclen);
break;
case HCL_OBJ_TYPE_HALFWORD:
oop = hcl_allochalfwordobj(hcl, HCL_BRAND_INSTANCE, vptr, alloclen);
oop = hcl_allochalfwordobj(hcl, HCL_BRAND_INSTANCE, (const hcl_oohw_t*)vptr, alloclen);
break;
case HCL_OBJ_TYPE_WORD:
oop = hcl_allocwordobj(hcl, HCL_BRAND_INSTANCE, vptr, alloclen);
oop = hcl_allocwordobj(hcl, HCL_BRAND_INSTANCE, (const hcl_oow_t*)vptr, alloclen);
break;
/* TODO: more types... HCL_OBJ_TYPE_INT... HCL_OBJ_TYPE_FLOAT, HCL_OBJ_TYPE_UINT16, etc*/

15
lib/read.c
View File

@ -547,7 +547,8 @@ static HCL_INLINE hcl_cnode_t* leave_list (hcl_t* hcl, hcl_loc_t* list_loc, int*
hcl_cnode_t* head, * tail;
hcl_oow_t count;
hcl_loc_t loc;
int fv, concode;
int fv;
hcl_concode_t concode;
/* the stack must not be empty - cannot leave a list without entering it */
HCL_ASSERT (hcl, hcl->c->r.st != HCL_NULL);
@ -558,7 +559,7 @@ static HCL_INLINE hcl_cnode_t* leave_list (hcl_t* hcl, hcl_loc_t* list_loc, int*
count = rstl->count;
fv = rstl->flagv;
loc = rstl->loc;
concode = LIST_FLAG_GET_CONCODE(fv);
concode = (hcl_concode_t)LIST_FLAG_GET_CONCODE(fv);
hcl->c->r.st = rstl->prev; /* pop off */
hcl_freemem (hcl, rstl); /* dispose of the stack node */
@ -797,7 +798,7 @@ static HCL_INLINE int can_comma_list (hcl_t* hcl)
if (rstl->flagv & (COMMAED | COLONED | COLONEQED | BINOPED)) return 0;
cc = LIST_FLAG_GET_CONCODE(rstl->flagv);
cc = (hcl_concode_t)LIST_FLAG_GET_CONCODE(rstl->flagv);
if (cc == HCL_CONCODE_XLIST)
{
/* defun f(a :: b c) { b := (a + 10); c := (a + 20) }
@ -849,7 +850,7 @@ static HCL_INLINE int can_colon_list (hcl_t* hcl)
/* multiple single-colons - e.g. #{ "abc": : 20 } */
if (rstl->flagv & (COMMAED | COLONED | COLONEQED | BINOPED)) return 0;
cc = LIST_FLAG_GET_CONCODE(rstl->flagv);
cc = (hcl_concode_t)LIST_FLAG_GET_CONCODE(rstl->flagv);
if (cc == HCL_CONCODE_XLIST)
{
/* method defintion with defun - e.g. defun String:length()
@ -882,7 +883,7 @@ static HCL_INLINE int can_coloneq_list (hcl_t* hcl)
/* repeated delimiters - e.g (a := := ...) (a : := ... ) */
if (rstl->flagv & (COMMAED | COLONED | COLONEQED | BINOPED)) return 0;
cc = LIST_FLAG_GET_CONCODE(rstl->flagv);
cc = (hcl_concode_t)LIST_FLAG_GET_CONCODE(rstl->flagv);
/* assignment only in XLIST */
if (cc != HCL_CONCODE_XLIST) return 0;
@ -911,7 +912,7 @@ static HCL_INLINE int can_binop_list (hcl_t* hcl)
/* repeated delimiters - e.g (a ++ ++ ...) (a : := ... ) */
if (rstl->flagv & (COMMAED | COLONED | COLONEQED | BINOPED)) return 0;
cc = LIST_FLAG_GET_CONCODE(rstl->flagv);
cc = (hcl_concode_t)LIST_FLAG_GET_CONCODE(rstl->flagv);
/* assignment only in XLIST */
if (cc != HCL_CONCODE_XLIST) return 0;
@ -2771,7 +2772,7 @@ static int flx_quoted_token (hcl_t* hcl, hcl_ooci_t c) /* string, character */
* byte-string and byte-character literals are 1 greater than
* string and character literals. * see the definition of
* hcl_tok_type_t in hcl-prv.h */
FEED_WRAP_UP (hcl, qt->tok_type + qt->is_byte); /* HCL_TOK_STRLIT or HCL_TOK_CHARLIT */
FEED_WRAP_UP (hcl, (hcl_tok_type_t)(qt->tok_type + qt->is_byte)); /* HCL_TOK_STRLIT or HCL_TOK_CHARLIT */
if (TOKEN_NAME_LEN(hcl) < qt->min_len) goto invalid_token;
goto consumed;
}

4
lib/std.c
View File

@ -929,7 +929,7 @@ hcl_errnum_t hcl_syserrstrb (hcl_t* hcl, int syserr_type, int syserr_code, hcl_b
* a positive error code upon failure */
x = (hcl_oow_t)strerror_r(syserr_code, buf, len);
if (x != (hcl_oow_t)buf && buf[0] == '\0' && x != 0 && x > 1024 && x != (hcl_oow_t)-1)
hcl_copy_bcstr (buf, len, (void*)x);
hcl_copy_bcstr (buf, len, (const hcl_bch_t*)x);
}
#else
/* this may be thread unsafe */
@ -3643,7 +3643,7 @@ static HCL_INLINE int read_udi_stream_bytes (hcl_t* hcl, hcl_io_udiarg_t* arg)
bcslen = (bb->len < HCL_COUNTOF(arg->buf.b))? bb->len: HCL_COUNTOF(arg->buf.b);
ucslen = bcslen;
hcl_copy_bchars (arg->buf.b, bb->buf, bcslen);
hcl_copy_bchars ((hcl_bch_t*)arg->buf.b, bb->buf, bcslen);
remlen = bb->len - bcslen;
if (remlen > 0) HCL_MEMMOVE (bb->buf, &bb->buf[bcslen], remlen);

2
lib/sym.c
View File

@ -204,7 +204,7 @@ hcl_oop_t hcl_makesymbolwithbcstr (hcl_t* hcl, const hcl_bch_t* ptr)
hcl_oop_t hcl_makesymbolwithucstr (hcl_t* hcl, const hcl_uch_t* ptr)
{
#if defined(HCL_OOCH_IS_UCH)
return hcl_makesymbol(hcl, ptr, hcl_count_bcstr(ptr));
return hcl_makesymbol(hcl, ptr, hcl_count_ucstr(ptr));
#else
hcl_uch_t* bcsptr;
hcl_oow_t bcslen;

16
lib/utl.c
View File

@ -558,7 +558,7 @@ hcl_oow_t hcl_byte_to_bcstr (hcl_uint8_t byte, hcl_bch_t* buf, hcl_oow_t size, i
/* ----------------------------------------------------------------------- */
HCL_INLINE int hcl_conv_bchars_to_uchars_with_cmgr (const hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_cmgr_t* cmgr, int all)
int hcl_conv_bchars_to_uchars_with_cmgr (const hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_cmgr_t* cmgr, int all)
{
const hcl_bch_t* p;
int ret = 0;
@ -677,7 +677,7 @@ HCL_INLINE int hcl_conv_bchars_to_uchars_with_cmgr (const hcl_bch_t* bcs, hcl_oo
return ret;
}
HCL_INLINE int hcl_conv_bcstr_to_ucstr_with_cmgr (const hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_cmgr_t* cmgr, int all)
int hcl_conv_bcstr_to_ucstr_with_cmgr (const hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_cmgr_t* cmgr, int all)
{
const hcl_bch_t* bp;
hcl_oow_t mlen, wlen;
@ -698,7 +698,7 @@ HCL_INLINE int hcl_conv_bcstr_to_ucstr_with_cmgr (const hcl_bch_t* bcs, hcl_oow_
return n;
}
HCL_INLINE int hcl_conv_uchars_to_bchars_with_cmgr (const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_cmgr_t* cmgr)
int hcl_conv_uchars_to_bchars_with_cmgr (const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_cmgr_t* cmgr)
{
const hcl_uch_t* p = ucs;
const hcl_uch_t* end = ucs + *ucslen;
@ -765,7 +765,7 @@ HCL_INLINE int hcl_conv_uchars_to_bchars_with_cmgr (const hcl_uch_t* ucs, hcl_oo
return ret;
}
HCL_INLINE int hcl_conv_ucstr_to_bcstr_with_cmgr (const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_cmgr_t* cmgr)
int hcl_conv_ucstr_to_bcstr_with_cmgr (const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_bch_t* bcs, hcl_oow_t* bcslen, hcl_cmgr_t* cmgr)
{
const hcl_uch_t* p = ucs;
int ret = 0;
@ -1052,7 +1052,7 @@ int hcl_convutobcstr (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t* ucslen, hcl_b
/* ----------------------------------------------------------------------- */
HCL_INLINE hcl_uch_t* hcl_dupbtoucharswithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_bch_t* bcs, hcl_oow_t bcslen, hcl_oow_t* ucslen)
hcl_uch_t* hcl_dupbtoucharswithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_bch_t* bcs, hcl_oow_t bcslen, hcl_oow_t* ucslen)
{
hcl_oow_t inlen, outlen;
hcl_uch_t* ptr;
@ -1085,7 +1085,7 @@ hcl_uch_t* hcl_dupbtouchars (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t bcslen,
return hcl_dupbtoucharswithheadroom (hcl, 0, bcs, bcslen, ucslen);
}
HCL_INLINE hcl_bch_t* hcl_duputobcharswithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_uch_t* ucs, hcl_oow_t ucslen, hcl_oow_t* bcslen)
hcl_bch_t* hcl_duputobcharswithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_uch_t* ucs, hcl_oow_t ucslen, hcl_oow_t* bcslen)
{
hcl_oow_t inlen, outlen;
hcl_bch_t* ptr;
@ -1117,7 +1117,7 @@ hcl_bch_t* hcl_duputobchars (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t ucslen,
/* ----------------------------------------------------------------------- */
HCL_INLINE hcl_uch_t* hcl_dupbtoucstrwithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_bch_t* bcs, hcl_oow_t* ucslen)
hcl_uch_t* hcl_dupbtoucstrwithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_bch_t* bcs, hcl_oow_t* ucslen)
{
hcl_oow_t inlen, outlen;
hcl_uch_t* ptr;
@ -1142,7 +1142,7 @@ hcl_uch_t* hcl_dupbtoucstr (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t* ucslen)
return hcl_dupbtoucstrwithheadroom (hcl, 0, bcs, ucslen);
}
HCL_INLINE hcl_bch_t* hcl_duputobcstrwithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_uch_t* ucs, hcl_oow_t* bcslen)
hcl_bch_t* hcl_duputobcstrwithheadroom (hcl_t* hcl, hcl_oow_t headroom_bytes, const hcl_uch_t* ucs, hcl_oow_t* bcslen)
{
hcl_oow_t inlen, outlen;
hcl_bch_t* ptr;

6
lib/xchg.c
View File

@ -330,8 +330,8 @@ int hcl_unmarshalcode (hcl_t* hcl, hcl_code_t* code, hcl_xchg_reader_t rdr, void
newcapa = nbytes;
if (HCL_UNLIKELY(newcapa <= 0)) newcapa++;
newcapa = HCL_ALIGN(newcapa, HCL_BC_BUFFER_ALIGN);
newptr = hcl_reallocmem(hcl, code->bc.ptr, newcapa);
if (!newptr) goto oops;
newptr = (hcl_oob_t*)hcl_reallocmem(hcl, code->bc.ptr, newcapa);
if (HCL_UNLIKELY(!newptr)) goto oops;
code->bc.ptr = newptr;
code->bc.capa = newcapa;
@ -550,7 +550,7 @@ static int mem_code_writer (hcl_t* hcl, const void* ptr, hcl_oow_t len, void* ct
newcapa = dst->len + len;
newcapa = HCL_ALIGN_POW2(newcapa, 64);
newptr = hcl_reallocmem(hcl, dst->ptr, newcapa);
newptr = (hcl_uint8_t*)hcl_reallocmem(hcl, dst->ptr, newcapa);
if (HCL_UNLIKELY(!newptr)) return -1;
dst->ptr = newptr;