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

enhanced the logfmtv to handle encoding conversion of the format string

Browse Source
This commit is contained in:
hyung-hwan 2018-02-26 15:24:45 +00:00
parent bf49aa1260
commit ef51ee4a1d
17 changed files with 157 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/bigint.c
View File

@ -40,7 +40,7 @@
#define IS_SIGN_DIFF(x,y) (((x) ^ (y)) < 0) #define IS_SIGN_DIFF(x,y) (((x) ^ (y)) < 0)
/* digit character array */ /* digit character array */
static char* _digitc = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; static char _digitc[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
/* exponent table */ /* exponent table */
static hcl_uint8_t _exp_tab[] = static hcl_uint8_t _exp_tab[] =
@ -1114,12 +1114,12 @@ static HCL_INLINE hcl_oow_t multiply_unsigned_array_karatsuba (hcl_t* hcl, const
tmplen[0] = ndigits_xh + ndigits_yh; tmplen[0] = ndigits_xh + ndigits_yh;
tmplen[1] = ndigits_yl + ndigits_yh + 1; tmplen[1] = ndigits_yl + ndigits_yh + 1;
if (tmplen[1] < tmplen[0]) tmplen[1] = tmplen[0]; if (tmplen[1] < tmplen[0]) tmplen[1] = tmplen[0];
tmp[1] = hcl_callocmem (hcl, HCL_SIZEOF(hcl_liw_t) * tmplen[1]); /* TODO: should i use the object memory? */ tmp[1] = (hcl_liw_t*)hcl_callocmem(hcl, HCL_SIZEOF(hcl_liw_t) * tmplen[1]); /* TODO: should i use the object memory? */
if (!tmp[1]) goto oops; if (!tmp[1]) goto oops;
/* make a temporary for (a0 + a1) and (a0 * b0) */ /* make a temporary for (a0 + a1) and (a0 * b0) */
tmplen[0] = ndigits_xl + ndigits_yl + 1; tmplen[0] = ndigits_xl + ndigits_yl + 1;
tmp[0] = hcl_callocmem (hcl, HCL_SIZEOF(hcl_liw_t) * tmplen[0]); tmp[0] = (hcl_liw_t*)hcl_callocmem(hcl, HCL_SIZEOF(hcl_liw_t) * tmplen[0]);
if (!tmp[0]) goto oops; if (!tmp[0]) goto oops;
/* tmp[0] = a0 + a1 */ /* tmp[0] = a0 + a1 */
@ -3619,7 +3619,7 @@ hcl_oop_t hcl_strtoint (hcl_t* hcl, const hcl_ooch_t* str, hcl_oow_t len, int ra
if (outlen > HCL_COUNTOF(hw)) if (outlen > HCL_COUNTOF(hw))
{ {
hwp = hcl_allocmem (hcl, outlen * HCL_SIZEOF(hw[0])); hwp = (hcl_liw_t*)hcl_allocmem(hcl, outlen * HCL_SIZEOF(hw[0]));
if (!hwp) return HCL_NULL; if (!hwp) return HCL_NULL;
} }
else else
@ -3667,7 +3667,7 @@ hcl_oop_t hcl_strtoint (hcl_t* hcl, const hcl_ooch_t* str, hcl_oow_t len, int ra
outlen = (end - str) / safe_ndigits + 1; outlen = (end - str) / safe_ndigits + 1;
if (outlen > HCL_COUNTOF(hw)) if (outlen > HCL_COUNTOF(hw))
{ {
hwp = hcl_allocmem (hcl, outlen * HCL_SIZEOF(hcl_liw_t)); hwp = (hcl_liw_t*)hcl_allocmem(hcl, outlen * HCL_SIZEOF(hcl_liw_t));
if (!hwp) return HCL_NULL; if (!hwp) return HCL_NULL;
} }
else else

4
lib/comp.c
View File

@ -98,7 +98,7 @@ static int add_temporary_variable (hcl_t* hcl, hcl_oop_t name, hcl_oow_t dup_che
hcl_oow_t newcapa; hcl_oow_t newcapa;
newcapa = HCL_ALIGN (hcl->c->tv.capa + 1, TV_BUFFER_ALIGN); /* TODO: set a better resizing policy */ newcapa = HCL_ALIGN (hcl->c->tv.capa + 1, TV_BUFFER_ALIGN); /* TODO: set a better resizing policy */
tmp = hcl_reallocmem (hcl, hcl->c->tv.ptr, newcapa); tmp = (hcl_oop_t*)hcl_reallocmem (hcl, hcl->c->tv.ptr, newcapa);
if (!tmp) return -1; if (!tmp) return -1;
hcl->c->tv.capa = newcapa; hcl->c->tv.capa = newcapa;
@ -495,7 +495,7 @@ static HCL_INLINE int _insert_cframe (hcl_t* hcl, hcl_ooi_t index, int opcode, h
hcl_oow_t newcapa; hcl_oow_t newcapa;
newcapa = HCL_ALIGN (hcl->c->cfs.top + 256, 256); /* TODO: adjust this capacity */ newcapa = HCL_ALIGN (hcl->c->cfs.top + 256, 256); /* TODO: adjust this capacity */
tmp = hcl_reallocmem (hcl, hcl->c->cfs.ptr, newcapa * HCL_SIZEOF(hcl_cframe_t)); tmp = (hcl_cframe_t*)hcl_reallocmem (hcl, hcl->c->cfs.ptr, newcapa * HCL_SIZEOF(hcl_cframe_t));
if (!tmp) if (!tmp)
{ {
hcl->c->cfs.top--; hcl->c->cfs.top--;

6
lib/dic.c
View File

@ -111,7 +111,7 @@ static hcl_oop_cons_t find_or_upsert (hcl_t* hcl, hcl_oop_dic_t dic, hcl_oop_cha
#if defined(SYMBOL_ONLY_KEY) #if defined(SYMBOL_ONLY_KEY)
index = hcl_hashoochars(key->slot, HCL_OBJ_GET_SIZE(key)) % HCL_OBJ_GET_SIZE(dic->bucket); index = hcl_hashoochars(key->slot, HCL_OBJ_GET_SIZE(key)) % HCL_OBJ_GET_SIZE(dic->bucket);
#else #else
if (hcl_hashobj(hcl, key, &index) <= -1) return HCL_NULL; if (hcl_hashobj(hcl, (hcl_oop_t)key, &index) <= -1) return HCL_NULL;
index %= HCL_OBJ_GET_SIZE(dic->bucket); index %= HCL_OBJ_GET_SIZE(dic->bucket);
#endif #endif
@ -136,7 +136,7 @@ static hcl_oop_cons_t find_or_upsert (hcl_t* hcl, hcl_oop_dic_t dic, hcl_oop_cha
ass = (hcl_oop_cons_t)dic->bucket->slot[index]; ass = (hcl_oop_cons_t)dic->bucket->slot[index];
HCL_ASSERT (hcl, HCL_IS_CONS(hcl,ass)); HCL_ASSERT (hcl, HCL_IS_CONS(hcl,ass));
n = hcl_equalobjs(hcl, key, ass->car); n = hcl_equalobjs(hcl, (hcl_oop_t)key, ass->car);
if (n <= -1) return HCL_NULL; if (n <= -1) return HCL_NULL;
if (n >= 1) if (n >= 1)
{ {
@ -197,7 +197,7 @@ static hcl_oop_cons_t find_or_upsert (hcl_t* hcl, hcl_oop_dic_t dic, hcl_oop_cha
/* recalculate the index for the expanded bucket */ /* recalculate the index for the expanded bucket */
index = hcl_hashoochars(key->slot, HCL_OBJ_GET_SIZE(key)) % HCL_OBJ_GET_SIZE(dic->bucket); index = hcl_hashoochars(key->slot, HCL_OBJ_GET_SIZE(key)) % HCL_OBJ_GET_SIZE(dic->bucket);
#else #else
hcl_hashobj(hcl, key, &index); /* this must succeed as i know 'key' is hashable */ hcl_hashobj(hcl, (hcl_oop_t)key, &index); /* this must succeed as i know 'key' is hashable */
index %= HCL_OBJ_GET_SIZE(dic->bucket); index %= HCL_OBJ_GET_SIZE(dic->bucket);
#endif #endif

4
lib/exec.c
View File

@ -165,7 +165,7 @@ static HCL_INLINE int prepare_to_alloc_pid (hcl_t* hcl)
new_capa = HCL_SMOOI_MAX; new_capa = HCL_SMOOI_MAX;
} }
tmp = hcl_reallocmem (hcl, hcl->proc_map, HCL_SIZEOF(hcl_oop_t) * new_capa); tmp = (hcl_oop_t*)hcl_reallocmem (hcl, hcl->proc_map, HCL_SIZEOF(hcl_oop_t) * new_capa);
if (!tmp) return -1; if (!tmp) return -1;
hcl->proc_map_free_first = hcl->proc_map_capa; hcl->proc_map_free_first = hcl->proc_map_capa;
@ -1022,7 +1022,7 @@ static int start_initial_process_and_context (hcl_t* hcl, hcl_ooi_t initial_ip)
ctx->method_or_nargs = HCL_SMOOI_TO_OOP(0); ctx->method_or_nargs = HCL_SMOOI_TO_OOP(0);
/* TODO: XXXXX */ /* TODO: XXXXX */
ctx->ntmprs = HCL_SMOOI_TO_OOP(0); ctx->ntmprs = HCL_SMOOI_TO_OOP(0);
ctx->home = ctx; /* is this correct??? */ ctx->home = (hcl_oop_t)ctx; /* is this correct??? */
/* END XXXXX */ /* END XXXXX */
/* [NOTE] /* [NOTE]

4
lib/gc.c
View File

@ -182,7 +182,7 @@ hcl_oop_t hcl_moveoop (hcl_t* hcl, hcl_oop_t oop)
nbytes_aligned = get_payload_bytes (hcl, oop); nbytes_aligned = get_payload_bytes (hcl, oop);
/* allocate space in the new heap */ /* allocate space in the new heap */
tmp = hcl_allocheapmem (hcl, hcl->newheap, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned); tmp = (hcl_oop_t)hcl_allocheapmem (hcl, hcl->newheap, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned);
/* allocation here must not fail because /* allocation here must not fail because
* i'm allocating the new space in a new heap for * i'm allocating the new space in a new heap for
@ -447,7 +447,7 @@ hcl_oop_t hcl_shallowcopy (hcl_t* hcl, hcl_oop_t oop)
total_bytes = HCL_SIZEOF(hcl_obj_t) + get_payload_bytes(hcl, oop); total_bytes = HCL_SIZEOF(hcl_obj_t) + get_payload_bytes(hcl, oop);
hcl_pushtmp (hcl, &oop); hcl_pushtmp (hcl, &oop);
z = hcl_allocbytes (hcl, total_bytes); z = (hcl_oop_t)hcl_allocbytes (hcl, total_bytes);
hcl_poptmp(hcl); hcl_poptmp(hcl);
HCL_MEMCPY (z, oop, total_bytes); HCL_MEMCPY (z, oop, total_bytes);

71
lib/hcl-prv.h
View File

@ -138,42 +138,43 @@
/* ========================================================================= */ /* ========================================================================= */
/* SOURCE CODE I/O FOR COMPILER */ /* SOURCE CODE I/O FOR COMPILER */
/* ========================================================================= */ /* ========================================================================= */
enum hcl_iotok_type_t
{
HCL_IOTOK_EOF,
HCL_IOTOK_CHARLIT,
HCL_IOTOK_STRLIT,
HCL_IOTOK_NUMLIT,
HCL_IOTOK_RADNUMLIT,
HCL_IOTOK_SMPTRLIT,
HCL_IOTOK_ERRORLIT,
HCL_IOTOK_NIL,
HCL_IOTOK_TRUE,
HCL_IOTOK_FALSE,
HCL_IOTOK_IDENT,
HCL_IOTOK_IDENT_DOTTED,
HCL_IOTOK_DOT,
HCL_IOTOK_LPAREN,
HCL_IOTOK_RPAREN,
HCL_IOTOK_APAREN, /* #( */
HCL_IOTOK_BAPAREN, /* #[ */
HCL_IOTOK_DPAREN, /* #{ */
HCL_IOTOK_LBRACK, /* [ */
HCL_IOTOK_RBRACK,
HCL_IOTOK_LBRACE,
HCL_IOTOK_RBRACE,
HCL_IOTOK_VBAR,
HCL_IOTOK_INCLUDE
};
typedef enum hcl_iotok_type_t hcl_iotok_type_t;
typedef struct hcl_iotok_t hcl_iotok_t; typedef struct hcl_iotok_t hcl_iotok_t;
struct hcl_iotok_t struct hcl_iotok_t
{ {
enum hcl_iotok_type_t type;
{
HCL_IOTOK_EOF,
HCL_IOTOK_CHARLIT,
HCL_IOTOK_STRLIT,
HCL_IOTOK_NUMLIT,
HCL_IOTOK_RADNUMLIT,
HCL_IOTOK_SMPTRLIT,
HCL_IOTOK_ERRORLIT,
HCL_IOTOK_NIL,
HCL_IOTOK_TRUE,
HCL_IOTOK_FALSE,
HCL_IOTOK_IDENT,
HCL_IOTOK_IDENT_DOTTED,
HCL_IOTOK_DOT,
HCL_IOTOK_LPAREN,
HCL_IOTOK_RPAREN,
HCL_IOTOK_APAREN, /* #( */
HCL_IOTOK_BAPAREN, /* #[ */
HCL_IOTOK_DPAREN, /* #{ */
HCL_IOTOK_LBRACK, /* [ */
HCL_IOTOK_RBRACK,
HCL_IOTOK_LBRACE,
HCL_IOTOK_RBRACE,
HCL_IOTOK_VBAR,
HCL_IOTOK_INCLUDE
} type;
hcl_oocs_t name; hcl_oocs_t name;
hcl_oow_t name_capa; hcl_oow_t name_capa;
hcl_ioloc_t loc; hcl_ioloc_t loc;
}; };
@ -638,7 +639,7 @@ enum hcl_bcode_t
typedef hcl_ooi_t (*hcl_outbfmt_t) ( typedef hcl_ooi_t (*hcl_outbfmt_t) (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
const hcl_bch_t* fmt, const hcl_bch_t* fmt,
... ...
); );
@ -1042,21 +1043,21 @@ int hcl_addbuiltinprims (
/* ========================================================================= */ /* ========================================================================= */
hcl_ooi_t hcl_proutbfmt ( hcl_ooi_t hcl_proutbfmt (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
const hcl_bch_t* fmt, const hcl_bch_t* fmt,
... ...
); );
hcl_ooi_t hcl_proutufmt ( hcl_ooi_t hcl_proutufmt (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
const hcl_uch_t* fmt, const hcl_uch_t* fmt,
... ...
); );
int hcl_outfmtobj ( int hcl_outfmtobj (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
hcl_oop_t obj, hcl_oop_t obj,
hcl_outbfmt_t outbfmt hcl_outbfmt_t outbfmt
); );

14
lib/hcl-rbt.h
View File

@ -167,6 +167,14 @@ typedef hcl_rbt_pair_t* (*hcl_rbt_cbserter_t) (
void* ctx /**< callback context */ void* ctx /**< callback context */
); );
enum hcl_rbt_pair_color_t
{
HCL_RBT_RED,
HCL_RBT_BLACK
};
typedef enum hcl_rbt_pair_color_t hcl_rbt_pair_color_t;
/** /**
* The hcl_rbt_pair_t type defines red-black tree pair. A pair is composed * The hcl_rbt_pair_t type defines red-black tree pair. A pair is composed
* of a key and a value. It maintains pointers to the beginning of a key and * of a key and a value. It maintains pointers to the beginning of a key and
@ -188,11 +196,7 @@ struct hcl_rbt_pair_t
} val; } val;
/* management information below */ /* management information below */
enum hcl_rbt_pair_color_t color;
{
HCL_RBT_RED,
HCL_RBT_BLACK
} color;
hcl_rbt_pair_t* parent; hcl_rbt_pair_t* parent;
hcl_rbt_pair_t* child[2]; /* left and right */ hcl_rbt_pair_t* child[2]; /* left and right */
}; };

14
lib/hcl.c
View File

@ -34,7 +34,7 @@ hcl_t* hcl_open (hcl_mmgr_t* mmgr, hcl_oow_t xtnsize, hcl_oow_t heapsize, const
/* if this assertion fails, correct the type definition in hcl.h */ /* if this assertion fails, correct the type definition in hcl.h */
HCL_ASSERT (hcl, HCL_SIZEOF(hcl_oow_t) == HCL_SIZEOF(hcl_oop_t)); HCL_ASSERT (hcl, HCL_SIZEOF(hcl_oow_t) == HCL_SIZEOF(hcl_oop_t));
hcl = HCL_MMGR_ALLOC (mmgr, HCL_SIZEOF(*hcl) + xtnsize); hcl = (hcl_t*)HCL_MMGR_ALLOC(mmgr, HCL_SIZEOF(*hcl) + xtnsize);
if (hcl) if (hcl)
{ {
if (hcl_init(hcl, mmgr, heapsize, vmprim) <= -1) if (hcl_init(hcl, mmgr, heapsize, vmprim) <= -1)
@ -113,7 +113,7 @@ int hcl_init (hcl_t* hcl, hcl_mmgr_t* mmgr, hcl_oow_t heapsz, const hcl_vmprim_t
* routine still function despite some side-effects when * routine still function despite some side-effects when
* reallocation fails */ * reallocation fails */
/* +1 required for consistency with put_oocs and put_ooch in logfmt.c */ /* +1 required for consistency with put_oocs and put_ooch in logfmt.c */
hcl->log.ptr = hcl_allocmem (hcl, (hcl->log.capa + 1) * HCL_SIZEOF(*hcl->log.ptr)); hcl->log.ptr = (hcl_ooch_t*)hcl_allocmem (hcl, (hcl->log.capa + 1) * HCL_SIZEOF(*hcl->log.ptr));
if (!hcl->log.ptr) goto oops; if (!hcl->log.ptr) goto oops;
/*hcl->permheap = hcl_makeheap (hcl, what is the best size???); /*hcl->permheap = hcl_makeheap (hcl, what is the best size???);
@ -154,7 +154,7 @@ static hcl_rbt_walk_t unload_module (hcl_rbt_t* rbt, hcl_rbt_pair_t* pair, void*
hcl_t* hcl = (hcl_t*)ctx; hcl_t* hcl = (hcl_t*)ctx;
hcl_mod_data_t* mdp; hcl_mod_data_t* mdp;
mdp = HCL_RBT_VPTR(pair); mdp = (hcl_mod_data_t*)HCL_RBT_VPTR(pair);
HCL_ASSERT (hcl, mdp != HCL_NULL); HCL_ASSERT (hcl, mdp != HCL_NULL);
mdp->pair = HCL_NULL; /* to prevent hcl_closemod() from calling hcl_rbt_delete() */ mdp->pair = HCL_NULL; /* to prevent hcl_closemod() from calling hcl_rbt_delete() */
@ -283,7 +283,7 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
return 0; return 0;
case HCL_LOG_MASK: case HCL_LOG_MASK:
hcl->option.log_mask = *(const unsigned int*)value; hcl->option.log_mask = *(const int*)value;
return 0; return 0;
case HCL_LOG_MAXCAPA: case HCL_LOG_MAXCAPA:
@ -338,7 +338,7 @@ int hcl_getoption (hcl_t* hcl, hcl_option_t id, void* value)
return 0; return 0;
case HCL_LOG_MASK: case HCL_LOG_MASK:
*(unsigned int*)value = hcl->option.log_mask; *(int*)value = hcl->option.log_mask;
return 0; return 0;
case HCL_LOG_MAXCAPA: case HCL_LOG_MAXCAPA:
@ -367,7 +367,7 @@ hcl_cb_t* hcl_regcb (hcl_t* hcl, hcl_cb_t* tmpl)
{ {
hcl_cb_t* actual; hcl_cb_t* actual;
actual = hcl_allocmem (hcl, HCL_SIZEOF(*actual)); actual = (hcl_cb_t*)hcl_allocmem(hcl, HCL_SIZEOF(*actual));
if (!actual) return HCL_NULL; if (!actual) return HCL_NULL;
*actual = *tmpl; *actual = *tmpl;
@ -556,7 +556,7 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
} }
/* attempt to get hcl_mod_xxx where xxx is the module name*/ /* attempt to get hcl_mod_xxx where xxx is the module name*/
load = hcl->vmprim.dl_getsym(hcl, md.handle, buf); load = (hcl_mod_load_t)hcl->vmprim.dl_getsym(hcl, md.handle, buf);
if (!load) if (!load)
{ {
hcl_seterrbfmt (hcl, hcl_geterrnum(hcl), "unable to get module symbol [%js] in [%.*js]", buf, namelen, name); hcl_seterrbfmt (hcl, hcl_geterrnum(hcl), "unable to get module symbol [%js] in [%.*js]", buf, namelen, name);

14
lib/hcl.h
View File

@ -692,7 +692,7 @@ typedef void* (*hcl_vmprim_dlopen_t) (hcl_t* hcl, const hcl_ooch_t* name, int fl
typedef void (*hcl_vmprim_dlclose_t) (hcl_t* hcl, void* handle); typedef void (*hcl_vmprim_dlclose_t) (hcl_t* hcl, void* handle);
typedef void* (*hcl_vmprim_dlgetsym_t) (hcl_t* hcl, void* handle, const hcl_ooch_t* name); typedef void* (*hcl_vmprim_dlgetsym_t) (hcl_t* hcl, void* handle, const hcl_ooch_t* name);
typedef void (*hcl_log_write_t) (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* msg, hcl_oow_t len); typedef void (*hcl_log_write_t) (hcl_t* hcl, int mask, const hcl_ooch_t* msg, hcl_oow_t len);
typedef void (*hcl_syserrstrb_t) (hcl_t* hcl, int syserr, hcl_bch_t* buf, hcl_oow_t len); typedef void (*hcl_syserrstrb_t) (hcl_t* hcl, int syserr, hcl_bch_t* buf, hcl_oow_t len);
typedef void (*hcl_syserrstru_t) (hcl_t* hcl, int syserr, hcl_uch_t* buf, hcl_oow_t len); typedef void (*hcl_syserrstru_t) (hcl_t* hcl, int syserr, hcl_uch_t* buf, hcl_oow_t len);
@ -885,7 +885,7 @@ typedef void (*hcl_mod_gc_t) (
struct hcl_mod_t struct hcl_mod_t
{ {
/* input */ /* input */
const hcl_ooch_t name[HCL_MOD_NAME_LEN_MAX + 1]; /*const*/ hcl_ooch_t name[HCL_MOD_NAME_LEN_MAX + 1];
/* user-defined data */ /* user-defined data */
hcl_mod_query_t query; hcl_mod_query_t query;
@ -948,7 +948,7 @@ struct hcl_t
struct struct
{ {
int trait; int trait;
unsigned int log_mask; int log_mask;
hcl_oow_t log_maxcapa; hcl_oow_t log_maxcapa;
hcl_oow_t dfl_symtab_size; hcl_oow_t dfl_symtab_size;
hcl_oow_t dfl_sysdic_size; hcl_oow_t dfl_sysdic_size;
@ -1049,7 +1049,7 @@ struct hcl_t
{ {
struct struct
{ {
hcl_uch_t* ptr; hcl_ooch_t* ptr;
hcl_oow_t capa; hcl_oow_t capa;
hcl_oow_t len; hcl_oow_t len;
} xbuf; } xbuf;
@ -1517,7 +1517,7 @@ HCL_EXPORT void hcl_setsynerrufmt (
); );
#if defined(HCL_HAVE_INLINE) #if defined(HCL_HAVE_INLINE)
static HCL_INLINE void hcl_setsynerr (hcl_t* hcl, hcl_synerrnum_t num, const hcl_ioloc_t* loc, const hcl_oocs_t* tgt) static HCL_INLINE void hcl_setsynerr (hcl_t* hcl, hcl_synerrnum_t num, const hcl_ioloc_t* loc, const hcl_oocs_t* tgt)
{ {
hcl_setsynerrbfmt (hcl, num, loc, tgt, HCL_NULL); hcl_setsynerrbfmt (hcl, num, loc, tgt, HCL_NULL);
} }
@ -1584,14 +1584,14 @@ HCL_EXPORT hcl_pfbase_t* hcl_findpfbase (
* ========================================================================= */ * ========================================================================= */
HCL_EXPORT hcl_ooi_t hcl_logbfmt ( HCL_EXPORT hcl_ooi_t hcl_logbfmt (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
const hcl_bch_t* fmt, const hcl_bch_t* fmt,
... ...
); );
HCL_EXPORT hcl_ooi_t hcl_logufmt ( HCL_EXPORT hcl_ooi_t hcl_logufmt (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
const hcl_uch_t* fmt, const hcl_uch_t* fmt,
... ...
); );

40
lib/logfmt.c
View File

@ -130,14 +130,14 @@ static hcl_bch_t bch_nullstr[] = { '(','n','u','l','l', ')','\0' };
typedef int (*hcl_fmtout_putch_t) ( typedef int (*hcl_fmtout_putch_t) (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
hcl_ooch_t c, hcl_ooch_t c,
hcl_oow_t len hcl_oow_t len
); );
typedef int (*hcl_fmtout_putcs_t) ( typedef int (*hcl_fmtout_putcs_t) (
hcl_t* hcl, hcl_t* hcl,
hcl_oow_t mask, int mask,
const hcl_ooch_t* ptr, const hcl_ooch_t* ptr,
hcl_oow_t len hcl_oow_t len
); );
@ -146,7 +146,7 @@ typedef struct hcl_fmtout_t hcl_fmtout_t;
struct hcl_fmtout_t struct hcl_fmtout_t
{ {
hcl_oow_t count; /* out */ hcl_oow_t count; /* out */
hcl_oow_t mask; /* in */ int mask; /* in */
hcl_fmtout_putch_t putch; /* in */ hcl_fmtout_putch_t putch; /* in */
hcl_fmtout_putcs_t putcs; /* in */ hcl_fmtout_putcs_t putcs; /* in */
}; };
@ -183,9 +183,9 @@ static hcl_bch_t* sprintn_upper (hcl_bch_t* nbuf, hcl_uintmax_t num, int base, h
} }
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
static int put_ooch (hcl_t* hcl, hcl_oow_t mask, hcl_ooch_t ch, hcl_oow_t len) static int put_ooch (hcl_t* hcl, int mask, hcl_ooch_t ch, hcl_oow_t len)
{ {
/* this is not equivalent to put_oocs(hcl,mask,&ch, 1); /* this is not equivalent to put_oocs(hcl,mask,&ch,1);
* this function is to emit a single character multiple times */ * this function is to emit a single character multiple times */
hcl_oow_t rem; hcl_oow_t rem;
@ -231,7 +231,7 @@ redo:
} }
/* +1 to handle line ending injection more easily */ /* +1 to handle line ending injection more easily */
tmp = hcl_reallocmem (hcl, hcl->log.ptr, (newcapa + 1) * HCL_SIZEOF(*tmp)); tmp = (hcl_ooch_t*)hcl_reallocmem (hcl, hcl->log.ptr, (newcapa + 1) * HCL_SIZEOF(*tmp));
if (!tmp) if (!tmp)
{ {
make_do: make_do:
@ -278,7 +278,7 @@ redo:
return 1; /* success */ return 1; /* success */
} }
static int put_oocs (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* ptr, hcl_oow_t len) static int put_oocs (hcl_t* hcl, int mask, const hcl_ooch_t* ptr, hcl_oow_t len)
{ {
hcl_oow_t rem; hcl_oow_t rem;
@ -325,7 +325,7 @@ redo:
} }
/* +1 to handle line ending injection more easily */ /* +1 to handle line ending injection more easily */
tmp = hcl_reallocmem (hcl, hcl->log.ptr, (newcapa + 1) * HCL_SIZEOF(*tmp)); tmp = (hcl_ooch_t*)hcl_reallocmem (hcl, hcl->log.ptr, (newcapa + 1) * HCL_SIZEOF(*tmp));
if (!tmp) if (!tmp)
{ {
make_do: make_do:
@ -408,7 +408,7 @@ static int _logufmtv (hcl_t* hcl, const hcl_uch_t* fmt, hcl_fmtout_t* data, va_l
return __logufmtv (hcl, fmt, data, ap, hcl_logbfmt); return __logufmtv (hcl, fmt, data, ap, hcl_logbfmt);
} }
hcl_ooi_t hcl_logbfmt (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...) hcl_ooi_t hcl_logbfmt (hcl_t* hcl, int mask, const hcl_bch_t* fmt, ...)
{ {
int x; int x;
va_list ap; va_list ap;
@ -441,7 +441,7 @@ hcl_ooi_t hcl_logbfmt (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...)
return (x <= -1)? -1: fo.count; return (x <= -1)? -1: fo.count;
} }
hcl_ooi_t hcl_logufmt (hcl_t* hcl, hcl_oow_t mask, const hcl_uch_t* fmt, ...) hcl_ooi_t hcl_logufmt (hcl_t* hcl, int mask, const hcl_uch_t* fmt, ...)
{ {
int x; int x;
va_list ap; va_list ap;
@ -474,7 +474,7 @@ hcl_ooi_t hcl_logufmt (hcl_t* hcl, hcl_oow_t mask, const hcl_uch_t* fmt, ...)
* HELPER FOR PRINTING * HELPER FOR PRINTING
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
static int put_prch (hcl_t* hcl, hcl_oow_t mask, hcl_ooch_t ch, hcl_oow_t len) static int put_prch (hcl_t* hcl, int mask, hcl_ooch_t ch, hcl_oow_t len)
{ {
/* TODO: better error handling, buffering. /* TODO: better error handling, buffering.
* should buffering be done by the printer callback? */ * should buffering be done by the printer callback? */
@ -501,7 +501,7 @@ static int put_prch (hcl_t* hcl, hcl_oow_t mask, hcl_ooch_t ch, hcl_oow_t len)
return 1; /* success */ return 1; /* success */
} }
static int put_prcs (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* ptr, hcl_oow_t len) static int put_prcs (hcl_t* hcl, int mask, const hcl_ooch_t* ptr, hcl_oow_t len)
{ {
/* TODO: better error handling, buffering /* TODO: better error handling, buffering
* should buffering be done by the printer callback? */ * should buffering be done by the printer callback? */
@ -517,7 +517,7 @@ static int put_prcs (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* ptr, hcl_oow_
return 1; /* success */ return 1; /* success */
} }
static hcl_ooi_t __prbfmtv (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...); static hcl_ooi_t __prbfmtv (hcl_t* hcl, int mask, const hcl_bch_t* fmt, ...);
static int _prbfmtv (hcl_t* hcl, const hcl_bch_t* fmt, hcl_fmtout_t* data, va_list ap) static int _prbfmtv (hcl_t* hcl, const hcl_bch_t* fmt, hcl_fmtout_t* data, va_list ap)
{ {
@ -529,7 +529,7 @@ static int _prufmtv (hcl_t* hcl, const hcl_uch_t* fmt, hcl_fmtout_t* data, va_li
return __logufmtv (hcl, fmt, data, ap, __prbfmtv); return __logufmtv (hcl, fmt, data, ap, __prbfmtv);
} }
static hcl_ooi_t __prbfmtv (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...) static hcl_ooi_t __prbfmtv (hcl_t* hcl, int mask, const hcl_bch_t* fmt, ...)
{ {
va_list ap; va_list ap;
hcl_fmtout_t fo; hcl_fmtout_t fo;
@ -545,7 +545,7 @@ static hcl_ooi_t __prbfmtv (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ..
return fo.count; return fo.count;
} }
hcl_ooi_t hcl_proutbfmt (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...) hcl_ooi_t hcl_proutbfmt (hcl_t* hcl, int mask, const hcl_bch_t* fmt, ...)
{ {
int x; int x;
va_list ap; va_list ap;
@ -562,7 +562,7 @@ hcl_ooi_t hcl_proutbfmt (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...)
return (x <= -1)? -1: fo.count; return (x <= -1)? -1: fo.count;
} }
hcl_ooi_t hcl_proutufmt (hcl_t* hcl, hcl_oow_t mask, const hcl_uch_t* fmt, ...) hcl_ooi_t hcl_proutufmt (hcl_t* hcl, int mask, const hcl_uch_t* fmt, ...)
{ {
int x; int x;
va_list ap; va_list ap;
@ -583,7 +583,7 @@ hcl_ooi_t hcl_proutufmt (hcl_t* hcl, hcl_oow_t mask, const hcl_uch_t* fmt, ...)
* ERROR MESSAGE FORMATTING * ERROR MESSAGE FORMATTING
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
static int put_errch (hcl_t* hcl, hcl_oow_t mask, hcl_ooch_t ch, hcl_oow_t len) static int put_errch (hcl_t* hcl, int mask, hcl_ooch_t ch, hcl_oow_t len)
{ {
hcl_oow_t max; hcl_oow_t max;
@ -602,7 +602,7 @@ static int put_errch (hcl_t* hcl, hcl_oow_t mask, hcl_ooch_t ch, hcl_oow_t len)
return 1; /* success */ return 1; /* success */
} }
static int put_errcs (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* ptr, hcl_oow_t len) static int put_errcs (hcl_t* hcl, int mask, const hcl_ooch_t* ptr, hcl_oow_t len)
{ {
hcl_oow_t max; hcl_oow_t max;
@ -619,7 +619,7 @@ static int put_errcs (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* ptr, hcl_oow
} }
static hcl_ooi_t __errbfmtv (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...); static hcl_ooi_t __errbfmtv (hcl_t* hcl, int mask, const hcl_bch_t* fmt, ...);
static int _errbfmtv (hcl_t* hcl, const hcl_bch_t* fmt, hcl_fmtout_t* data, va_list ap) static int _errbfmtv (hcl_t* hcl, const hcl_bch_t* fmt, hcl_fmtout_t* data, va_list ap)
{ {
@ -631,7 +631,7 @@ static int _errufmtv (hcl_t* hcl, const hcl_uch_t* fmt, hcl_fmtout_t* data, va_l
return __logufmtv (hcl, fmt, data, ap, __errbfmtv); return __logufmtv (hcl, fmt, data, ap, __errbfmtv);
} }
static hcl_ooi_t __errbfmtv (hcl_t* hcl, hcl_oow_t mask, const hcl_bch_t* fmt, ...) static hcl_ooi_t __errbfmtv (hcl_t* hcl, int mask, const hcl_bch_t* fmt, ...)
{ {
va_list ap; va_list ap;
hcl_fmtout_t fo; hcl_fmtout_t fo;

32
lib/logfmtv.h
View File

@ -63,7 +63,7 @@
* SUCH DAMAGE. * SUCH DAMAGE.
* *
*/ */
#include <stdio.h>
/* NOTE: data output is aborted if the data limit is reached or /* NOTE: data output is aborted if the data limit is reached or
* I/O error occurs */ * I/O error occurs */
@ -92,9 +92,7 @@
static int logfmtv (hcl_t* hcl, const fmtchar_t* fmt, hcl_fmtout_t* data, va_list ap, hcl_outbfmt_t outbfmt) static int logfmtv (hcl_t* hcl, const fmtchar_t* fmt, hcl_fmtout_t* data, va_list ap, hcl_outbfmt_t outbfmt)
{ {
const fmtchar_t* percent; const fmtchar_t* percent;
#if defined(FMTCHAR_IS_OOCH)
const fmtchar_t* checkpoint; const fmtchar_t* checkpoint;
#endif
hcl_bch_t nbuf[MAXNBUF], bch; hcl_bch_t nbuf[MAXNBUF], bch;
const hcl_bch_t* nbufp; const hcl_bch_t* nbufp;
int n, base, neg, sign; int n, base, neg, sign;
@ -138,26 +136,38 @@ static int logfmtv (hcl_t* hcl, const fmtchar_t* fmt, hcl_fmtout_t* data, va_lis
} }
PUT_OOCS (checkpoint, fmt - checkpoint - 1); PUT_OOCS (checkpoint, fmt - checkpoint - 1);
#else #else
#if defined(HCL_OOCH_IS_UCH)
/* fmtchar is bch. ooch is uch. convert bch to uch */
checkpoint = fmt;
while ((fch = *fmt++) != '%' || stop) while ((fch = *fmt++) != '%' || stop)
{ {
#if defined(HCL_OOCH_IS_UCH) if (fch == '\0') break;
if (fch == '\0') goto done; }
/* ooch is uch. fmtchar is bch */ while (checkpoint < fmt - 1)
/* TODO: convert bch to uch */ {
hcl_oow_t cvlen, bclen;
bclen = fmt - checkpoint - 1;
cvlen = hcl->cmgr->bctouc(checkpoint, bclen, &ch);
if (cvlen == 0 || cvlen > bclen) goto oops;
checkpoint += cvlen;
PUT_OOCH (ch, 1); PUT_OOCH (ch, 1);
}
if (fch == '\0') goto done;
#else #else
while ((fch = *fmt++) != '%' || stop)
{
hcl_bch_t bcsbuf[HCL_MBLEN_MAX + 1]; hcl_bch_t bcsbuf[HCL_MBLEN_MAX + 1];
hcl_oow_t ucslen, bcslen; hcl_oow_t ucslen, bcslen;
if (fch == '\0') goto done; if (fch == '\0') goto done;
/* ooch is bch. fmtchar is uch */ /* fmtchar is uch. ooch is bch. convert uch to bch */
ucslen = 1; ucslen = 1;
bcslen = 1; bcslen = HCL_COUNTOF(bcsbuf);
if (hcl_convutooochars (hcl, &fch, &ucslen, bcsbuf, &bcslen) <= -1) goto oops; if (hcl_convutooochars(hcl, &fch, &ucslen, bcsbuf, &bcslen) <= -1) goto oops;
PUT_OOCS (bcsbuf, bcslen); PUT_OOCS (bcsbuf, bcslen);
#endif
} }
#endif
#endif #endif
percent = fmt - 1; percent = fmt - 1;

36
lib/main.c
View File

@ -193,7 +193,7 @@ static const hcl_bch_t* get_base_name (const hcl_bch_t* path)
static HCL_INLINE hcl_ooi_t open_input (hcl_t* hcl, hcl_ioinarg_t* arg) static HCL_INLINE hcl_ooi_t open_input (hcl_t* hcl, hcl_ioinarg_t* arg)
{ {
xtn_t* xtn = hcl_getxtn(hcl); xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);
bb_t* bb = HCL_NULL; bb_t* bb = HCL_NULL;
/* TOOD: support predefined include directory as well */ /* TOOD: support predefined include directory as well */
@ -214,7 +214,7 @@ static HCL_INLINE hcl_ooi_t open_input (hcl_t* hcl, hcl_ioinarg_t* arg)
fb = get_base_name (fn); fb = get_base_name (fn);
parlen = fb - fn; parlen = fb - fn;
bb = hcl_callocmem (hcl, HCL_SIZEOF(*bb) + (HCL_SIZEOF(hcl_bch_t) * (parlen + bcslen + 1))); bb = (bb_t*)hcl_callocmem (hcl, HCL_SIZEOF(*bb) + (HCL_SIZEOF(hcl_bch_t) * (parlen + bcslen + 1)));
if (!bb) goto oops; if (!bb) goto oops;
bb->fn = (hcl_bch_t*)(bb + 1); bb->fn = (hcl_bch_t*)(bb + 1);
@ -232,7 +232,7 @@ static HCL_INLINE hcl_ooi_t open_input (hcl_t* hcl, hcl_ioinarg_t* arg)
pathlen = hcl_countbcstr (xtn->read_path); pathlen = hcl_countbcstr (xtn->read_path);
bb = hcl_callocmem (hcl, HCL_SIZEOF(*bb) + (HCL_SIZEOF(hcl_bch_t) * (pathlen + 1))); bb = (bb_t*)hcl_callocmem (hcl, HCL_SIZEOF(*bb) + (HCL_SIZEOF(hcl_bch_t) * (pathlen + 1)));
if (!bb) goto oops; if (!bb) goto oops;
bb->fn = (hcl_bch_t*)(bb + 1); bb->fn = (hcl_bch_t*)(bb + 1);
@ -269,7 +269,7 @@ oops:
static HCL_INLINE hcl_ooi_t close_input (hcl_t* hcl, hcl_ioinarg_t* arg) static HCL_INLINE hcl_ooi_t close_input (hcl_t* hcl, hcl_ioinarg_t* arg)
{ {
/*xtn_t* xtn = hcl_getxtn(hcl);*/ /*xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);*/
bb_t* bb; bb_t* bb;
bb = (bb_t*)arg->handle; bb = (bb_t*)arg->handle;
@ -285,7 +285,7 @@ static HCL_INLINE hcl_ooi_t close_input (hcl_t* hcl, hcl_ioinarg_t* arg)
static HCL_INLINE hcl_ooi_t read_input (hcl_t* hcl, hcl_ioinarg_t* arg) static HCL_INLINE hcl_ooi_t read_input (hcl_t* hcl, hcl_ioinarg_t* arg)
{ {
/*xtn_t* xtn = hcl_getxtn(hcl);*/ /*xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);*/
bb_t* bb; bb_t* bb;
hcl_oow_t bcslen, ucslen, remlen; hcl_oow_t bcslen, ucslen, remlen;
int x; int x;
@ -350,7 +350,7 @@ static hcl_ooi_t read_handler (hcl_t* hcl, hcl_iocmd_t cmd, void* arg)
static HCL_INLINE hcl_ooi_t open_output(hcl_t* hcl, hcl_iooutarg_t* arg) static HCL_INLINE hcl_ooi_t open_output(hcl_t* hcl, hcl_iooutarg_t* arg)
{ {
xtn_t* xtn = hcl_getxtn(hcl); xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);
FILE* fp; FILE* fp;
#if defined(__MSDOS__) || defined(_WIN32) || defined(__OS2__) #if defined(__MSDOS__) || defined(_WIN32) || defined(__OS2__)
@ -372,7 +372,7 @@ static HCL_INLINE hcl_ooi_t open_output(hcl_t* hcl, hcl_iooutarg_t* arg)
static HCL_INLINE hcl_ooi_t close_output (hcl_t* hcl, hcl_iooutarg_t* arg) static HCL_INLINE hcl_ooi_t close_output (hcl_t* hcl, hcl_iooutarg_t* arg)
{ {
/*xtn_t* xtn = hcl_getxtn(hcl);*/ /*xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);*/
FILE* fp; FILE* fp;
fp = (FILE*)arg->handle; fp = (FILE*)arg->handle;
@ -386,7 +386,7 @@ static HCL_INLINE hcl_ooi_t close_output (hcl_t* hcl, hcl_iooutarg_t* arg)
static HCL_INLINE hcl_ooi_t write_output (hcl_t* hcl, hcl_iooutarg_t* arg) static HCL_INLINE hcl_ooi_t write_output (hcl_t* hcl, hcl_iooutarg_t* arg)
{ {
/*xtn_t* xtn = hcl_getxtn(hcl);*/ /*xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);*/
hcl_bch_t bcsbuf[1024]; hcl_bch_t bcsbuf[1024];
hcl_oow_t bcslen, ucslen, donelen; hcl_oow_t bcslen, ucslen, donelen;
int x; int x;
@ -462,7 +462,7 @@ static void* dl_open (hcl_t* hcl, const hcl_ooch_t* name, int flags)
if (bufcapa <= HCL_COUNTOF(stabuf)) bufptr = stabuf; if (bufcapa <= HCL_COUNTOF(stabuf)) bufptr = stabuf;
else else
{ {
bufptr = hcl_allocmem(hcl, bufcapa * HCL_SIZEOF(*bufptr)); bufptr = (hcl_bch_t*)hcl_allocmem(hcl, bufcapa * HCL_SIZEOF(*bufptr));
if (!bufptr) return HCL_NULL; if (!bufptr) return HCL_NULL;
} }
@ -608,7 +608,7 @@ static void* dl_getsym (hcl_t* hcl, void* handle, const hcl_ooch_t* name)
if (bcslen >= HCL_COUNTOF(stabuf) - 2) if (bcslen >= HCL_COUNTOF(stabuf) - 2)
{ {
bufcapa = bcslen + 3; bufcapa = bcslen + 3;
bufptr = hcl_allocmem(hcl, bufcapa * HCL_SIZEOF(*bufptr)); bufptr = (hcl_bch_t*)hcl_allocmem(hcl, bufcapa * HCL_SIZEOF(*bufptr));
if (!bufptr) return HCL_NULL; if (!bufptr) return HCL_NULL;
} }
else else
@ -705,7 +705,7 @@ static int write_all (int fd, const char* ptr, hcl_oow_t len)
return 0; return 0;
} }
static void log_write (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* msg, hcl_oow_t len) static void log_write (hcl_t* hcl, int mask, const hcl_ooch_t* msg, hcl_oow_t len)
{ {
#if defined(_WIN32) #if defined(_WIN32)
# error NOT IMPLEMENTED # error NOT IMPLEMENTED
@ -717,7 +717,7 @@ static void log_write (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* msg, hcl_oo
hcl_oow_t ucslen, bcslen, msgidx; hcl_oow_t ucslen, bcslen, msgidx;
int n; int n;
xtn_t* xtn = hcl_getxtn(hcl); xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);
int logfd; int logfd;
if (mask & HCL_LOG_STDERR) if (mask & HCL_LOG_STDERR)
@ -1076,7 +1076,7 @@ static void vm_gettime (hcl_t* hcl, hcl_ntime_t* now)
static void vm_sleep (hcl_t* hcl, const hcl_ntime_t* dur) static void vm_sleep (hcl_t* hcl, const hcl_ntime_t* dur)
{ {
#if defined(_WIN32) #if defined(_WIN32)
xtn_t* xtn = hcl_getxtn(hcl); xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);
if (xtn->waitable_timer) if (xtn->waitable_timer)
{ {
LARGE_INTEGER li; LARGE_INTEGER li;
@ -1150,7 +1150,7 @@ static void vm_sleep (hcl_t* hcl, const hcl_ntime_t* dur)
static void fini_hcl (hcl_t* hcl) static void fini_hcl (hcl_t* hcl)
{ {
xtn_t* xtn = hcl_getxtn(hcl); xtn_t* xtn = (xtn_t*)hcl_getxtn(hcl);
if (xtn->logfd >= 0) if (xtn->logfd >= 0)
{ {
close (xtn->logfd); close (xtn->logfd);
@ -1162,7 +1162,7 @@ static void fini_hcl (hcl_t* hcl)
static int handle_logopt (hcl_t* hcl, const hcl_bch_t* str) static int handle_logopt (hcl_t* hcl, const hcl_bch_t* str)
{ {
xtn_t* xtn = hcl_getxtn (hcl); xtn_t* xtn = (xtn_t*)hcl_getxtn (hcl);
hcl_bch_t* xstr = (hcl_bch_t*)str; hcl_bch_t* xstr = (hcl_bch_t*)str;
hcl_bch_t* cm, * flt; hcl_bch_t* cm, * flt;
@ -1245,7 +1245,7 @@ static int handle_logopt (hcl_t* hcl, const hcl_bch_t* str)
#if defined(HCL_BUILD_DEBUG) #if defined(HCL_BUILD_DEBUG)
static int handle_dbgopt (hcl_t* hcl, const hcl_bch_t* str) static int handle_dbgopt (hcl_t* hcl, const hcl_bch_t* str)
{ {
xtn_t* xtn = hcl_getxtn (hcl); xtn_t* xtn = (xtn_t*)hcl_getxtn (hcl);
const hcl_bch_t* cm, * flt; const hcl_bch_t* cm, * flt;
hcl_oow_t len; hcl_oow_t len;
unsigned int trait, dbgopt = 0; unsigned int trait, dbgopt = 0;
@ -1395,7 +1395,7 @@ static void print_synerr (hcl_t* hcl)
hcl_synerr_t synerr; hcl_synerr_t synerr;
xtn_t* xtn; xtn_t* xtn;
xtn = hcl_getxtn (hcl); xtn = (xtn_t*)hcl_getxtn (hcl);
hcl_getsynerr (hcl, &synerr); hcl_getsynerr (hcl, &synerr);
hcl_logbfmt (hcl,HCL_LOG_STDERR, "ERROR: "); hcl_logbfmt (hcl,HCL_LOG_STDERR, "ERROR: ");
@ -1545,7 +1545,7 @@ int main (int argc, char* argv[])
hcl_setoption (hcl, HCL_LOG_MASK, &trait);*/ hcl_setoption (hcl, HCL_LOG_MASK, &trait);*/
} }
xtn = hcl_getxtn (hcl); xtn = (xtn_t*)hcl_getxtn (hcl);
xtn->logfd = -1; xtn->logfd = -1;
xtn->logfd_istty = 0; xtn->logfd_istty = 0;

14
lib/obj.c
View File

@ -35,7 +35,7 @@ void* hcl_allocbytes (hcl_t* hcl, hcl_oow_t size)
if ((hcl->option.trait & HCL_DEBUG_GC) && !(hcl->option.trait & HCL_NOGC)) hcl_gc (hcl); if ((hcl->option.trait & HCL_DEBUG_GC) && !(hcl->option.trait & HCL_NOGC)) hcl_gc (hcl);
#endif #endif
ptr = hcl_allocheapmem(hcl, hcl->curheap, size); ptr = (hcl_uint8_t*)hcl_allocheapmem(hcl, hcl->curheap, size);
if (!ptr && hcl->errnum == HCL_EOOMEM && !(hcl->option.trait & HCL_NOGC)) if (!ptr && hcl->errnum == HCL_EOOMEM && !(hcl->option.trait & HCL_NOGC))
{ {
hcl_gc (hcl); hcl_gc (hcl);
@ -45,7 +45,7 @@ void* hcl_allocbytes (hcl_t* hcl, hcl_oow_t size)
(hcl_oow_t)(hcl->curheap->limit - hcl->curheap->base), (hcl_oow_t)(hcl->curheap->limit - hcl->curheap->base),
(hcl_oow_t)(hcl->curheap->limit - hcl->curheap->ptr) (hcl_oow_t)(hcl->curheap->limit - hcl->curheap->ptr)
); );
ptr = hcl_allocheapmem (hcl, hcl->curheap, size); ptr = (hcl_uint8_t*)hcl_allocheapmem (hcl, hcl->curheap, size);
/* TODO: grow heap if ptr is still null. */ /* TODO: grow heap if ptr is still null. */
} }
@ -65,7 +65,7 @@ static HCL_INLINE hcl_oop_t alloc_oop_array (hcl_t* hcl, int brand, hcl_oow_t si
if (HCL_UNLIKELY(ngc)) if (HCL_UNLIKELY(ngc))
{ {
hdr = hcl_callocmem(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned); hdr = (hcl_oop_oop_t)hcl_callocmem(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned);
} }
else else
{ {
@ -73,7 +73,7 @@ static HCL_INLINE hcl_oop_t alloc_oop_array (hcl_t* hcl, int brand, hcl_oow_t si
* HCL_SIZEOF(hcl_oop_t) will guarantee the starting address * HCL_SIZEOF(hcl_oop_t) will guarantee the starting address
* of the allocated space to be an even number. * of the allocated space to be an even number.
* see HCL_OOP_IS_NUMERIC() and HCL_OOP_IS_POINTER() */ * see HCL_OOP_IS_NUMERIC() and HCL_OOP_IS_POINTER() */
hdr = hcl_allocbytes(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned); hdr = (hcl_oop_oop_t)hcl_allocbytes(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned);
} }
if (!hdr) return HCL_NULL; if (!hdr) return HCL_NULL;
@ -104,7 +104,7 @@ hcl_oop_t hcl_allocoopobjwithtrailer (hcl_t* hcl, hcl_oow_t size, const hcl_oob_
nbytes = (size + 1) * HCL_SIZEOF(hcl_oop_t) + blen; nbytes = (size + 1) * HCL_SIZEOF(hcl_oop_t) + blen;
nbytes_aligned = HCL_ALIGN(nbytes, HCL_SIZEOF(hcl_oop_t)); nbytes_aligned = HCL_ALIGN(nbytes, HCL_SIZEOF(hcl_oop_t));
hdr = hcl_allocbytes(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned); hdr = (hcl_oop_oop_t)hcl_allocbytes(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned);
if (!hdr) return HCL_NULL; if (!hdr) return HCL_NULL;
hdr->_flags = HCL_OBJ_MAKE_FLAGS(HCL_OBJ_TYPE_OOP, HCL_SIZEOF(hcl_oop_t), 0, 0, 0, 0, 1, 0); hdr->_flags = HCL_OBJ_MAKE_FLAGS(HCL_OBJ_TYPE_OOP, HCL_SIZEOF(hcl_oop_t), 0, 0, 0, 0, 1, 0);
@ -148,9 +148,9 @@ static HCL_INLINE hcl_oop_t alloc_numeric_array (hcl_t* hcl, int brand, const vo
* of the allocated space to be an even number. * of the allocated space to be an even number.
* see HCL_OOP_IS_NUMERIC() and HCL_OOP_IS_POINTER() */ * see HCL_OOP_IS_NUMERIC() and HCL_OOP_IS_POINTER() */
if (HCL_UNLIKELY(ngc)) if (HCL_UNLIKELY(ngc))
hdr = hcl_callocmem(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned); hdr = (hcl_oop_t)hcl_callocmem(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned);
else else
hdr = hcl_allocbytes(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned); hdr = (hcl_oop_t)hcl_allocbytes(hcl, HCL_SIZEOF(hcl_obj_t) + nbytes_aligned);
if (!hdr) return HCL_NULL; if (!hdr) return HCL_NULL;
hdr->_flags = HCL_OBJ_MAKE_FLAGS(type, unit, extra, 0, 0, ngc, 0, 0); hdr->_flags = HCL_OBJ_MAKE_FLAGS(type, unit, extra, 0, 0, ngc, 0, 0);

8
lib/prim.c
View File

@ -56,7 +56,7 @@ hcl_oop_t hcl_makeprim (hcl_t* hcl, hcl_pfimpl_t primimpl, hcl_oow_t minargs, hc
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
static void log_char_object (hcl_t* hcl, hcl_oow_t mask, hcl_oop_char_t msg) static void log_char_object (hcl_t* hcl, int mask, hcl_oop_char_t msg)
{ {
hcl_ooi_t n; hcl_ooi_t n;
hcl_oow_t rem; hcl_oow_t rem;
@ -98,7 +98,7 @@ static hcl_pfrc_t pf_log (hcl_t* hcl, hcl_ooi_t nargs)
{ {
/* TODO: accept log level */ /* TODO: accept log level */
hcl_oop_t msg; hcl_oop_t msg;
hcl_oow_t mask; int mask;
hcl_ooi_t k; hcl_ooi_t k;
/*level = HCL_STACK_GET(hcl, hcl->sp - nargs + 1); /*level = HCL_STACK_GET(hcl, hcl->sp - nargs + 1);
@ -378,7 +378,7 @@ static hcl_pfrc_t pf_integer_rem (hcl_t* hcl, hcl_ooi_t nargs)
static int put_formatted_chars (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t ch, hcl_oow_t len) static int put_formatted_chars (hcl_t* hcl, int mask, const hcl_ooch_t ch, hcl_oow_t len)
{ {
/* TODO: better error handling, buffering. /* TODO: better error handling, buffering.
* should buffering be done by the printer callback? */ * should buffering be done by the printer callback? */
@ -405,7 +405,7 @@ static int put_formatted_chars (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t ch,
return 1; /* success */ return 1; /* success */
} }
static int put_formatted_string (hcl_t* hcl, hcl_oow_t mask, const hcl_ooch_t* ptr, hcl_oow_t len) static int put_formatted_string (hcl_t* hcl, int mask, const hcl_ooch_t* ptr, hcl_oow_t len)
{ {
/* TODO: better error handling, buffering /* TODO: better error handling, buffering
* should be done by the printer callback? */ * should be done by the printer callback? */

6
lib/print.c
View File

@ -57,7 +57,7 @@ static HCL_INLINE int push (hcl_t* hcl, print_stack_t* info)
hcl_oow_t new_capa; hcl_oow_t new_capa;
new_capa = HCL_ALIGN (hcl->p.s.capa + 1, PRINT_STACK_ALIGN); new_capa = HCL_ALIGN (hcl->p.s.capa + 1, PRINT_STACK_ALIGN);
tmp = hcl_reallocmem (hcl, hcl->p.s.ptr, new_capa * HCL_SIZEOF(*info)); tmp = (print_stack_t*)hcl_reallocmem(hcl, hcl->p.s.ptr, new_capa * HCL_SIZEOF(*info));
if (!tmp) return -1; if (!tmp) return -1;
hcl->p.s.ptr = tmp; hcl->p.s.ptr = tmp;
@ -114,7 +114,7 @@ static struct
}; };
static HCL_INLINE int print_single_char (hcl_t* hcl, hcl_oow_t mask, hcl_ooch_t ch, hcl_outbfmt_t outbfmt) static HCL_INLINE int print_single_char (hcl_t* hcl, int mask, hcl_ooch_t ch, hcl_outbfmt_t outbfmt)
{ {
if (ch < ' ') if (ch < ' ')
{ {
@ -168,7 +168,7 @@ static HCL_INLINE int print_single_char (hcl_t* hcl, hcl_oow_t mask, hcl_ooch_t
return 0; return 0;
} }
int hcl_outfmtobj (hcl_t* hcl, hcl_oow_t mask, hcl_oop_t obj, hcl_outbfmt_t outbfmt) int hcl_outfmtobj (hcl_t* hcl, int mask, hcl_oop_t obj, hcl_outbfmt_t outbfmt)
{ {
hcl_oop_t cur; hcl_oop_t cur;
print_stack_t ps; print_stack_t ps;

8
lib/read.c
View File

@ -311,7 +311,7 @@ static int copy_string_to (hcl_t* hcl, const hcl_oocs_t* src, hcl_oocs_t* dst, h
capa = HCL_ALIGN(len, BUFFER_ALIGN); capa = HCL_ALIGN(len, BUFFER_ALIGN);
tmp = hcl_reallocmem (hcl, dst->ptr, HCL_SIZEOF(*tmp) * capa); tmp = (hcl_ooch_t*)hcl_reallocmem (hcl, dst->ptr, HCL_SIZEOF(*tmp) * capa);
if (!tmp) return -1; if (!tmp) return -1;
dst->ptr = tmp; dst->ptr = tmp;
@ -1915,8 +1915,8 @@ static int read_object (hcl_t* hcl)
{ {
static struct static struct
{ {
int closer; int closer;
int synerr; hcl_synerrnum_t synerr;
} req[] = } req[] =
{ {
{ HCL_IOTOK_RPAREN, HCL_SYNERR_RPAREN }, /* XLIST () */ { HCL_IOTOK_RPAREN, HCL_SYNERR_RPAREN }, /* XLIST () */
@ -2268,7 +2268,7 @@ int hcl_attachio (hcl_t* hcl, hcl_ioimpl_t reader, hcl_ioimpl_t printer)
cbp = hcl_regcb (hcl, &cb); cbp = hcl_regcb (hcl, &cb);
if (!cbp) return -1; if (!cbp) return -1;
hcl->c = hcl_callocmem (hcl, HCL_SIZEOF(*hcl->c)); hcl->c = (hcl_compiler_t*)hcl_callocmem (hcl, HCL_SIZEOF(*hcl->c));
if (!hcl->c) if (!hcl->c)
{ {
hcl_deregcb (hcl, cbp); hcl_deregcb (hcl, cbp);

14
lib/utl.c
View File

@ -370,7 +370,7 @@ int hcl_concatoocstrtosbuf (hcl_t* hcl, const hcl_ooch_t* str, int id)
newcapa = HCL_ALIGN(p->len + len, 512); /* TODO: adjust this capacity */ newcapa = HCL_ALIGN(p->len + len, 512); /* TODO: adjust this capacity */
/* +1 to handle line ending injection more easily */ /* +1 to handle line ending injection more easily */
tmp = hcl_reallocmem (hcl, p->ptr, (newcapa + 1) * HCL_SIZEOF(*tmp)); tmp = (hcl_ooch_t*)hcl_reallocmem(hcl, p->ptr, (newcapa + 1) * HCL_SIZEOF(*tmp));
if (!tmp) return -1; if (!tmp) return -1;
p->ptr = tmp; p->ptr = tmp;
@ -802,7 +802,7 @@ HCL_INLINE hcl_uch_t* hcl_dupbtoucharswithheadroom (hcl_t* hcl, hcl_oow_t headro
return HCL_NULL; return HCL_NULL;
} }
ptr = hcl_allocmem (hcl, headroom_bytes + ((outlen + 1) * HCL_SIZEOF(hcl_uch_t))); ptr = (hcl_uch_t*)hcl_allocmem(hcl, headroom_bytes + ((outlen + 1) * HCL_SIZEOF(hcl_uch_t)));
if (!ptr) return HCL_NULL; if (!ptr) return HCL_NULL;
inlen = bcslen; inlen = bcslen;
@ -835,7 +835,7 @@ HCL_INLINE hcl_bch_t* hcl_duputobcharswithheadroom (hcl_t* hcl, hcl_oow_t headro
return HCL_NULL; return HCL_NULL;
} }
ptr = hcl_allocmem (hcl, headroom_bytes + ((outlen + 1) * HCL_SIZEOF(hcl_bch_t))); ptr = (hcl_bch_t*)hcl_allocmem(hcl, headroom_bytes + ((outlen + 1) * HCL_SIZEOF(hcl_bch_t)));
if (!ptr) return HCL_NULL; if (!ptr) return HCL_NULL;
inlen = ucslen; inlen = ucslen;
@ -867,7 +867,7 @@ HCL_INLINE hcl_uch_t* hcl_dupbtoucstrwithheadroom (hcl_t* hcl, hcl_oow_t headroo
} }
outlen++; outlen++;
ptr = hcl_allocmem (hcl, headroom_bytes + (outlen * HCL_SIZEOF(hcl_uch_t))); ptr = (hcl_uch_t*)hcl_allocmem (hcl, headroom_bytes + (outlen * HCL_SIZEOF(hcl_uch_t)));
if (!ptr) return HCL_NULL; if (!ptr) return HCL_NULL;
hcl_convbtoucstr (hcl, bcs, &inlen, ptr, &outlen); hcl_convbtoucstr (hcl, bcs, &inlen, ptr, &outlen);
@ -892,7 +892,7 @@ HCL_INLINE hcl_bch_t* hcl_duputobcstrwithheadroom (hcl_t* hcl, hcl_oow_t headroo
} }
outlen++; outlen++;
ptr = hcl_allocmem (hcl, headroom_bytes + (outlen * HCL_SIZEOF(hcl_bch_t))); ptr = (hcl_bch_t*)hcl_allocmem (hcl, headroom_bytes + (outlen * HCL_SIZEOF(hcl_bch_t)));
if (!ptr) return HCL_NULL; if (!ptr) return HCL_NULL;
ptr = (hcl_bch_t*)((hcl_oob_t*)ptr + headroom_bytes); ptr = (hcl_bch_t*)((hcl_oob_t*)ptr + headroom_bytes);
@ -912,7 +912,7 @@ hcl_uch_t* hcl_dupuchars (hcl_t* hcl, const hcl_uch_t* ucs, hcl_oow_t ucslen)
{ {
hcl_uch_t* ptr; hcl_uch_t* ptr;
ptr = hcl_allocmem (hcl, (ucslen + 1) * HCL_SIZEOF(hcl_uch_t)); ptr = (hcl_uch_t*)hcl_allocmem (hcl, (ucslen + 1) * HCL_SIZEOF(hcl_uch_t));
if (!ptr) return HCL_NULL; if (!ptr) return HCL_NULL;
hcl_copyuchars (ptr, ucs, ucslen); hcl_copyuchars (ptr, ucs, ucslen);
@ -924,7 +924,7 @@ hcl_bch_t* hcl_dupbchars (hcl_t* hcl, const hcl_bch_t* bcs, hcl_oow_t bcslen)
{ {
hcl_bch_t* ptr; hcl_bch_t* ptr;
ptr = hcl_allocmem (hcl, (bcslen + 1) * HCL_SIZEOF(hcl_bch_t)); ptr = (hcl_bch_t*)hcl_allocmem (hcl, (bcslen + 1) * HCL_SIZEOF(hcl_bch_t));
if (!ptr) return HCL_NULL; if (!ptr) return HCL_NULL;
hcl_copybchars (ptr, bcs, bcslen); hcl_copybchars (ptr, bcs, bcslen);