extended hcl_attacio() to access a new input stream handler under the name of scanner.
renamed hcl_ioinarg_t to hcl_iosrarg_t took back hcl_ioinarg_t for the new input stream handling
This commit is contained in:
parent
2bd78d2bfc
commit
b340f09ecc
@ -527,7 +527,7 @@ static int feed_loop (hcl_t* hcl, xtn_t* xtn, int cflags, int verbose)
|
||||
hcl_ooch_t* ptr;
|
||||
hcl_oow_t xlen;
|
||||
|
||||
ptr = hcl_readbaseinraw(hcl, &xlen);
|
||||
ptr = hcl_readbasesrraw(hcl, &xlen);
|
||||
if (HCL_UNLIKELY(!ptr)) goto oops;
|
||||
if (xlen <= 0) break;
|
||||
if (hcl_feed(hcl, ptr, xlen) <= -1) goto feed_error;
|
||||
|
||||
@ -646,10 +646,10 @@ struct hcl_compiler_t
|
||||
hcl_ioimpl_t reader;
|
||||
|
||||
/* static input data buffer */
|
||||
hcl_ioinarg_t inarg;
|
||||
hcl_iosrarg_t srarg;
|
||||
|
||||
/* pointer to the current input data. initially, it points to &inarg */
|
||||
hcl_ioinarg_t* curinp;
|
||||
hcl_iosrarg_t* curinp;
|
||||
|
||||
/* information about the last meaningful character read.
|
||||
* this is a copy of curinp->lxc if no ungetting is performed.
|
||||
@ -664,7 +664,7 @@ struct hcl_compiler_t
|
||||
|
||||
/* the last token read */
|
||||
hcl_iotok_t tok;
|
||||
hcl_iolink_t* io_names;
|
||||
hcl_iolink_t* sr_names;
|
||||
|
||||
hcl_synerr_t synerr;
|
||||
|
||||
|
||||
18
lib/hcl-s.c
18
lib/hcl-s.c
@ -316,7 +316,7 @@ static const hcl_bch_t* get_base_name (const hcl_bch_t* path)
|
||||
}
|
||||
|
||||
|
||||
static HCL_INLINE int open_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
static HCL_INLINE int open_input (hcl_t* hcl, hcl_iosrarg_t* arg)
|
||||
{
|
||||
worker_hcl_xtn_t* xtn = (worker_hcl_xtn_t*)hcl_getxtn(hcl);
|
||||
bb_t* bb = HCL_NULL;
|
||||
@ -412,7 +412,7 @@ oops:
|
||||
return -1;
|
||||
}
|
||||
|
||||
static HCL_INLINE int close_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
static HCL_INLINE int close_input (hcl_t* hcl, hcl_iosrarg_t* arg)
|
||||
{
|
||||
worker_hcl_xtn_t* xtn = (worker_hcl_xtn_t*)hcl_getxtn(hcl);
|
||||
bb_t* bb;
|
||||
@ -427,7 +427,7 @@ static HCL_INLINE int close_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HCL_INLINE int read_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
static HCL_INLINE int read_input (hcl_t* hcl, hcl_iosrarg_t* arg)
|
||||
{
|
||||
worker_hcl_xtn_t* xtn = (worker_hcl_xtn_t*)hcl_getxtn(hcl);
|
||||
bb_t* bb;
|
||||
@ -545,13 +545,13 @@ static int read_handler (hcl_t* hcl, hcl_iocmd_t cmd, void* arg)
|
||||
switch (cmd)
|
||||
{
|
||||
case HCL_IO_OPEN:
|
||||
return open_input(hcl, (hcl_ioinarg_t*)arg);
|
||||
return open_input(hcl, (hcl_iosrarg_t*)arg);
|
||||
|
||||
case HCL_IO_CLOSE:
|
||||
return close_input(hcl, (hcl_ioinarg_t*)arg);
|
||||
return close_input(hcl, (hcl_iosrarg_t*)arg);
|
||||
|
||||
case HCL_IO_READ:
|
||||
return read_input(hcl, (hcl_ioinarg_t*)arg);
|
||||
return read_input(hcl, (hcl_iosrarg_t*)arg);
|
||||
|
||||
default:
|
||||
hcl_seterrnum (hcl, HCL_EINTERN);
|
||||
@ -700,7 +700,7 @@ hcl_server_proto_t* hcl_server_proto_open (hcl_oow_t xtnsize, hcl_server_worker_
|
||||
if (hcl_ignite(proto->hcl, worker->server->cfg.actor_heap_size) <= -1) goto oops;
|
||||
if (hcl_addbuiltinprims(proto->hcl) <= -1) goto oops;
|
||||
|
||||
if (hcl_attachio(proto->hcl, read_handler, print_handler) <= -1) goto oops;
|
||||
if (hcl_attachio(proto->hcl, read_handler, HCL_NULL, print_handler) <= -1) goto oops;
|
||||
return proto;
|
||||
|
||||
oops:
|
||||
@ -943,7 +943,7 @@ static HCL_INLINE int read_char (hcl_server_proto_t* proto)
|
||||
return 0;
|
||||
}
|
||||
|
||||
proto->lxc = hcl_readbaseinchar(proto->hcl);
|
||||
proto->lxc = hcl_readbasesrchar(proto->hcl);
|
||||
if (!proto->lxc) return -1;
|
||||
return 0;
|
||||
}
|
||||
@ -1406,7 +1406,7 @@ int hcl_server_proto_handle_request (hcl_server_proto_t* proto)
|
||||
|
||||
if (proto->req.state == HCL_SERVER_PROTO_REQ_IN_TOP_LEVEL)
|
||||
{
|
||||
hcl_setbaseinloc (proto->hcl, 1, 1);
|
||||
hcl_setbasesrloc (proto->hcl, 1, 1);
|
||||
hcl_reset(proto->hcl);
|
||||
}
|
||||
|
||||
|
||||
53
lib/hcl.h
53
lib/hcl.h
@ -854,7 +854,7 @@ struct hcl_class_t
|
||||
{
|
||||
HCL_OBJ_HEADER;
|
||||
|
||||
hcl_oop_t mdic; /* method dictioanry. nil or a dictionary object */
|
||||
hcl_oop_t mdic; /* method dictionary. nil or a dictionary object */
|
||||
|
||||
hcl_oop_t superclass;
|
||||
hcl_oop_t nivars; /* smooi. */
|
||||
@ -1217,8 +1217,8 @@ struct hcl_iolxc_t
|
||||
};
|
||||
typedef struct hcl_iolxc_t hcl_iolxc_t;
|
||||
|
||||
typedef struct hcl_ioinarg_t hcl_ioinarg_t;
|
||||
struct hcl_ioinarg_t
|
||||
typedef struct hcl_iosrarg_t hcl_iosrarg_t;
|
||||
struct hcl_iosrarg_t
|
||||
{
|
||||
/**
|
||||
* [IN] I/O object name.
|
||||
@ -1249,7 +1249,7 @@ struct hcl_ioinarg_t
|
||||
* [IN] points to the data of the includer. It is #HCL_NULL for the
|
||||
* main stream.
|
||||
*/
|
||||
hcl_ioinarg_t* includer;
|
||||
hcl_iosrarg_t* includer;
|
||||
|
||||
/*-----------------------------------------------------------------*/
|
||||
/*----------- from here down, internal use only -------------------*/
|
||||
@ -1267,12 +1267,34 @@ struct hcl_ioinarg_t
|
||||
/*-----------------------------------------------------------------*/
|
||||
};
|
||||
|
||||
typedef struct hcl_ioinarg_t hcl_ioinarg_t;
|
||||
struct hcl_ioinarg_t
|
||||
{
|
||||
/**
|
||||
* [OUT] I/O handle set by a handler.
|
||||
* The stream handler can set this field when it opens a stream.
|
||||
* All subsequent operations on the stream see this field as set
|
||||
* during opening.
|
||||
*/
|
||||
void* handle;
|
||||
|
||||
/**
|
||||
* [OUT] place data here for #HCL_IO_READ
|
||||
*/
|
||||
hcl_ooch_t buf[2048]; /* TODO: resize this if necessary */
|
||||
|
||||
/**
|
||||
* [OUT] place the number of characters read here for #HCL_IO_READ
|
||||
*/
|
||||
hcl_oow_t xlen;
|
||||
};
|
||||
|
||||
typedef struct hcl_iooutarg_t hcl_iooutarg_t;
|
||||
struct hcl_iooutarg_t
|
||||
{
|
||||
/**
|
||||
* [OUT] I/O handle set by a handler.
|
||||
* The source stream handler can set this field when it opens a stream.
|
||||
* The stream handler can set this field when it opens a stream.
|
||||
* All subsequent operations on the stream see this field as set
|
||||
* during opening.
|
||||
*/
|
||||
@ -1302,7 +1324,7 @@ struct hcl_iooutarg_t
|
||||
typedef int (*hcl_ioimpl_t) (
|
||||
hcl_t* hcl,
|
||||
hcl_iocmd_t cmd,
|
||||
void* arg /* hcl_ioinarg_t* or hcl_iooutarg_t* */
|
||||
void* arg /* hcl_iosrarg_t* or hcl_iooutarg_t* */
|
||||
);
|
||||
|
||||
/* =========================================================================
|
||||
@ -1723,6 +1745,10 @@ struct hcl_t
|
||||
|
||||
struct
|
||||
{
|
||||
/* input handler */
|
||||
hcl_ioimpl_t scanner;
|
||||
hcl_ioinarg_t inarg;
|
||||
|
||||
/* output handler */
|
||||
hcl_ioimpl_t printer;
|
||||
hcl_iooutarg_t outarg;
|
||||
@ -2165,29 +2191,30 @@ HCL_EXPORT void hcl_abort (
|
||||
# define hcl_switchprocess(hcl) ((hcl)->switch_proc = 1)
|
||||
#endif
|
||||
|
||||
HCL_EXPORT void hcl_setbaseinloc (
|
||||
HCL_EXPORT void hcl_setbasesrloc (
|
||||
hcl_t* hcl,
|
||||
hcl_oow_t line,
|
||||
hcl_oow_t colm
|
||||
);
|
||||
|
||||
/* if you should read charcters from the input stream before hcl_read(),
|
||||
* you can call hcl_readbaseinchar() */
|
||||
HCL_EXPORT hcl_iolxc_t* hcl_readbaseinchar (
|
||||
* you can call hcl_readbasesrchar() */
|
||||
HCL_EXPORT hcl_iolxc_t* hcl_readbasesrchar (
|
||||
hcl_t* hcl
|
||||
);
|
||||
|
||||
/* TODO: don't expose hcl_readbaseinraw()
|
||||
/* TODO: don't expose hcl_readbasesrraw()
|
||||
* find a better way not to use them */
|
||||
HCL_EXPORT hcl_ooch_t* hcl_readbaseinraw (
|
||||
HCL_EXPORT hcl_ooch_t* hcl_readbasesrraw (
|
||||
hcl_t* hcl,
|
||||
hcl_oow_t* xlen
|
||||
);
|
||||
|
||||
HCL_EXPORT int hcl_attachio (
|
||||
hcl_t* hcl,
|
||||
hcl_ioimpl_t reader,
|
||||
hcl_ioimpl_t printer
|
||||
hcl_ioimpl_t reader, /* source stream heandler */
|
||||
hcl_ioimpl_t scanner, /* runtime input stream handler */
|
||||
hcl_ioimpl_t printer /* runtime output stream handler */
|
||||
);
|
||||
|
||||
HCL_EXPORT int hcl_attachiostdwithbcstr (
|
||||
|
||||
240
lib/read.c
240
lib/read.c
@ -452,7 +452,7 @@ static int get_directive_token_type (hcl_t* hcl, hcl_iotok_type_t* tok_type)
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int _get_char (hcl_t* hcl, hcl_ioinarg_t* inp)
|
||||
static int _get_char (hcl_t* hcl, hcl_iosrarg_t* inp)
|
||||
{
|
||||
hcl_ooci_t lc;
|
||||
|
||||
@ -1393,50 +1393,78 @@ retry:
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void clear_io_names (hcl_t* hcl)
|
||||
static int is_sr_name_in_use (hcl_t* hcl, const hcl_ooch_t* sr_name)
|
||||
{
|
||||
/* [NOTE]
|
||||
* this is very error prone. if there are changes in refernece
|
||||
* points of this sr_name in the source code, this function also
|
||||
* must be modifed. */
|
||||
hcl_iosrarg_t* cur;
|
||||
|
||||
if (hcl->c->synerr.loc.file == sr_name) return 1;
|
||||
|
||||
cur = hcl->c->curinp;
|
||||
while (cur)
|
||||
{
|
||||
if (cur->lxc.l.file == sr_name) return 1;
|
||||
cur = cur->includer;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void clear_sr_names (hcl_t* hcl)
|
||||
{
|
||||
hcl_iolink_t* cur;
|
||||
|
||||
HCL_ASSERT (hcl, hcl->c != HCL_NULL);
|
||||
|
||||
while (hcl->c->io_names)
|
||||
while (hcl->c->sr_names)
|
||||
{
|
||||
cur = hcl->c->io_names;
|
||||
hcl->c->io_names = cur->link;
|
||||
cur = hcl->c->sr_names;
|
||||
hcl->c->sr_names = cur->link;
|
||||
hcl_freemem (hcl, cur);
|
||||
}
|
||||
}
|
||||
|
||||
static const hcl_ooch_t* add_io_name (hcl_t* hcl, const hcl_oocs_t* name)
|
||||
static const hcl_ooch_t* add_sr_name (hcl_t* hcl, const hcl_oocs_t* name)
|
||||
{
|
||||
hcl_iolink_t* link;
|
||||
hcl_ooch_t* ptr;
|
||||
hcl_ooch_t* nptr;
|
||||
|
||||
/* TODO: make search faster */
|
||||
link = hcl->c->sr_names;
|
||||
while (link)
|
||||
{
|
||||
nptr = (hcl_ooch_t*)(link + 1);
|
||||
if (hcl_comp_oochars_oocstr(name->ptr, name->len, nptr) == 0) return nptr;
|
||||
link = link->link;
|
||||
}
|
||||
|
||||
link = (hcl_iolink_t*)hcl_callocmem (hcl, HCL_SIZEOF(*link) + HCL_SIZEOF(hcl_ooch_t) * (name->len + 1));
|
||||
if (HCL_UNLIKELY(!link)) return HCL_NULL;
|
||||
|
||||
ptr = (hcl_ooch_t*)(link + 1);
|
||||
nptr = (hcl_ooch_t*)(link + 1);
|
||||
|
||||
hcl_copy_oochars (ptr, name->ptr, name->len);
|
||||
ptr[name->len] = '\0';
|
||||
hcl_copy_oochars (nptr, name->ptr, name->len);
|
||||
nptr[name->len] = '\0';
|
||||
|
||||
link->link = hcl->c->io_names;
|
||||
hcl->c->io_names = link;
|
||||
link->link = hcl->c->sr_names;
|
||||
hcl->c->sr_names = link;
|
||||
|
||||
return ptr;
|
||||
return nptr;
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
static int begin_include (hcl_t* hcl)
|
||||
{
|
||||
hcl_ioinarg_t* arg;
|
||||
hcl_iosrarg_t* arg;
|
||||
const hcl_ooch_t* io_name;
|
||||
|
||||
io_name = add_io_name(hcl, TOKEN_NAME(hcl));
|
||||
io_name = add_sr_name(hcl, TOKEN_NAME(hcl));
|
||||
if (HCL_UNLIKELY(!io_name)) return -1;
|
||||
|
||||
arg = (hcl_ioinarg_t*)hcl_callocmem(hcl, HCL_SIZEOF(*arg));
|
||||
arg = (hcl_iosrarg_t*)hcl_callocmem(hcl, HCL_SIZEOF(*arg));
|
||||
if (HCL_UNLIKELY(!arg)) goto oops;
|
||||
|
||||
arg->name = io_name;
|
||||
@ -1487,9 +1515,9 @@ oops:
|
||||
static int end_include (hcl_t* hcl)
|
||||
{
|
||||
int x;
|
||||
hcl_ioinarg_t* cur;
|
||||
hcl_iosrarg_t* cur;
|
||||
|
||||
if (hcl->c->curinp == &hcl->c->inarg) return 0; /* no include */
|
||||
if (hcl->c->curinp == &hcl->c->srarg) return 0; /* no include */
|
||||
|
||||
/* if it is an included file, close it and
|
||||
* retry to read a character from an outer file */
|
||||
@ -2180,6 +2208,7 @@ oops:
|
||||
while (hcl->c->r.st)
|
||||
{
|
||||
hcl_rstl_t* rstl;
|
||||
|
||||
rstl = hcl->c->r.st;
|
||||
hcl->c->r.st = rstl->prev;
|
||||
if (rstl->head) hcl_freecnode (hcl, rstl->head);
|
||||
@ -2237,13 +2266,13 @@ static void init_feed (hcl_t* hcl)
|
||||
|
||||
static int feed_begin_include (hcl_t* hcl)
|
||||
{
|
||||
hcl_ioinarg_t* arg;
|
||||
hcl_iosrarg_t* arg;
|
||||
const hcl_ooch_t* io_name;
|
||||
|
||||
io_name = add_io_name(hcl, TOKEN_NAME(hcl));
|
||||
io_name = add_sr_name(hcl, TOKEN_NAME(hcl));
|
||||
if (HCL_UNLIKELY(!io_name)) return -1;
|
||||
|
||||
arg = (hcl_ioinarg_t*)hcl_callocmem(hcl, HCL_SIZEOF(*arg));
|
||||
arg = (hcl_iosrarg_t*)hcl_callocmem(hcl, HCL_SIZEOF(*arg));
|
||||
if (HCL_UNLIKELY(!arg)) goto oops;
|
||||
|
||||
arg->name = io_name;
|
||||
@ -2259,11 +2288,11 @@ static int feed_begin_include (hcl_t* hcl)
|
||||
goto oops;
|
||||
}
|
||||
|
||||
if (arg->includer == &hcl->c->inarg) /* top-level include */
|
||||
if (arg->includer == &hcl->c->srarg) /* top-level include */
|
||||
{
|
||||
/* TODO: remove hcl_readbaseinchar() and clean up this part.
|
||||
* hcl_readbaseinchar(), if called in the middle of feeds,
|
||||
* updates hcl->c->inarg's line and colm. so use a separate
|
||||
/* TODO: remove hcl_readbasesrchar() and clean up this part.
|
||||
* hcl_readbasesrchar(), if called in the middle of feeds,
|
||||
* updates hcl->c->srarg's line and colm. so use a separate
|
||||
* field to store the current feed location for now */
|
||||
hcl->c->feed.lx._oloc = hcl->c->feed.lx.loc;
|
||||
}
|
||||
@ -2291,9 +2320,9 @@ oops:
|
||||
static int feed_end_include (hcl_t* hcl)
|
||||
{
|
||||
int x;
|
||||
hcl_ioinarg_t* cur;
|
||||
hcl_iosrarg_t* cur;
|
||||
|
||||
if (hcl->c->curinp == &hcl->c->inarg) return 0; /* no include */
|
||||
if (hcl->c->curinp == &hcl->c->srarg) return 0; /* no include */
|
||||
|
||||
/* if it is an included file, close it and
|
||||
* retry to read a character from an outer file */
|
||||
@ -2307,7 +2336,7 @@ static int feed_end_include (hcl_t* hcl)
|
||||
cur = hcl->c->curinp;
|
||||
hcl->c->curinp = hcl->c->curinp->includer;
|
||||
|
||||
if (hcl->c->curinp == &hcl->c->inarg)
|
||||
if (hcl->c->curinp == &hcl->c->srarg)
|
||||
{
|
||||
hcl->c->feed.lx.loc = hcl->c->feed.lx._oloc;
|
||||
}
|
||||
@ -2332,6 +2361,19 @@ static int feed_end_include (hcl_t* hcl)
|
||||
return 1; /* ended the included file successfully */
|
||||
}
|
||||
|
||||
static void feed_clean_up_reader_stack (hcl_t* hcl)
|
||||
{
|
||||
/* clean up the reader stack for a list */
|
||||
while (hcl->c->r.st)
|
||||
{
|
||||
hcl_rstl_t* rstl;
|
||||
rstl = hcl->c->r.st;
|
||||
hcl->c->r.st = rstl->prev;
|
||||
if (rstl->head) hcl_freecnode (hcl, rstl->head);
|
||||
hcl_freemem (hcl, rstl);
|
||||
}
|
||||
}
|
||||
|
||||
static int feed_process_token (hcl_t* hcl)
|
||||
{
|
||||
hcl_frd_t* frd = &hcl->c->feed.rd;
|
||||
@ -2730,19 +2772,10 @@ oops:
|
||||
}
|
||||
|
||||
/* clean up the reader stack for a list */
|
||||
while (hcl->c->r.st)
|
||||
{
|
||||
hcl_rstl_t* rstl;
|
||||
rstl = hcl->c->r.st;
|
||||
hcl->c->r.st = rstl->prev;
|
||||
if (rstl->head) hcl_freecnode (hcl, rstl->head);
|
||||
hcl_freemem (hcl, rstl);
|
||||
}
|
||||
|
||||
feed_clean_up_reader_stack (hcl);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
||||
struct delim_token_t
|
||||
@ -3716,7 +3749,7 @@ static int feed_from_includee (hcl_t* hcl)
|
||||
{
|
||||
int x;
|
||||
|
||||
HCL_ASSERT (hcl, hcl->c->curinp != HCL_NULL && hcl->c->curinp != &hcl->c->inarg);
|
||||
HCL_ASSERT (hcl, hcl->c->curinp != HCL_NULL && hcl->c->curinp != &hcl->c->srarg);
|
||||
|
||||
do
|
||||
{
|
||||
@ -3757,7 +3790,7 @@ static int feed_from_includee (hcl_t* hcl)
|
||||
if (feed_begin_include(hcl) <= -1) return -1;
|
||||
}
|
||||
}
|
||||
while (hcl->c->curinp != &hcl->c->inarg);
|
||||
while (hcl->c->curinp != &hcl->c->srarg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -3792,7 +3825,7 @@ int hcl_feed (hcl_t* hcl, const hcl_ooch_t* data, hcl_oow_t len)
|
||||
for (i = 0; i < len; )
|
||||
{
|
||||
x = feed_char(hcl, data[i]);
|
||||
if (x <= -1) return -1; /* TODO: return the number of processed characters via an argument? */
|
||||
if (x <= -1) goto oops; /* TODO: return the number of processed characters via an argument? */
|
||||
|
||||
if (x > 0)
|
||||
{
|
||||
@ -3803,14 +3836,14 @@ int hcl_feed (hcl_t* hcl, const hcl_ooch_t* data, hcl_oow_t len)
|
||||
|
||||
if (hcl->c->feed.rd.do_include_file)
|
||||
{
|
||||
if (feed_begin_include(hcl) <= -1) return -1;
|
||||
if (feed_begin_include(hcl) <= -1) goto oops;
|
||||
hcl->c->feed.rd.do_include_file = 0;
|
||||
}
|
||||
|
||||
if (hcl->c->curinp && hcl->c->curinp != &hcl->c->inarg && feed_from_includee(hcl) <= -1)
|
||||
if (hcl->c->curinp && hcl->c->curinp != &hcl->c->srarg && feed_from_includee(hcl) <= -1)
|
||||
{
|
||||
/* TODO: return the number of processed characters via an argument? */
|
||||
return -1;
|
||||
goto oops;
|
||||
}
|
||||
|
||||
/* feed data[i] again if not consumed */
|
||||
@ -3832,7 +3865,7 @@ int hcl_feed (hcl_t* hcl, const hcl_ooch_t* data, hcl_oow_t len)
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
goto oops;
|
||||
}
|
||||
}
|
||||
i += x;
|
||||
@ -3840,6 +3873,10 @@ int hcl_feed (hcl_t* hcl, const hcl_ooch_t* data, hcl_oow_t len)
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
oops:
|
||||
feed_clean_up_reader_stack (hcl);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
@ -3926,7 +3963,7 @@ static void fini_compiler_cb (hcl_t* hcl)
|
||||
hcl->c->fnblk.depth = -1;
|
||||
}
|
||||
|
||||
clear_io_names (hcl);
|
||||
clear_sr_names (hcl);
|
||||
if (hcl->c->tok.name.ptr) hcl_freemem (hcl, hcl->c->tok.name.ptr);
|
||||
|
||||
hcl_detachio (hcl);
|
||||
@ -3984,60 +4021,84 @@ static int init_compiler (hcl_t* hcl)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int hcl_attachio (hcl_t* hcl, hcl_ioimpl_t reader, hcl_ioimpl_t printer)
|
||||
int hcl_attachio (hcl_t* hcl, hcl_ioimpl_t reader, hcl_ioimpl_t scanner, hcl_ioimpl_t printer)
|
||||
{
|
||||
int n;
|
||||
int inited_compiler = 0;
|
||||
hcl_iosrarg_t new_srarg;
|
||||
hcl_ioinarg_t new_inarg;
|
||||
hcl_iooutarg_t new_outarg;
|
||||
|
||||
if (!reader || !printer)
|
||||
if (reader)
|
||||
{
|
||||
hcl_seterrbfmt (hcl, HCL_EINVAL, "reader and/or printer not supplied");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!hcl->c)
|
||||
{
|
||||
if (init_compiler(hcl) <= -1) return -1;
|
||||
inited_compiler = 1;
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* Some IO names could have been stored in earlier calls to this function.
|
||||
* I clear such names before i begin this function. i don't clear them
|
||||
* at the end of this function because they may be referenced as an error
|
||||
* location */
|
||||
clear_io_names (hcl);
|
||||
#endif
|
||||
|
||||
if (reader)
|
||||
{
|
||||
/* The name field and the includer field are HCL_NULL
|
||||
* for the main stream */
|
||||
HCL_MEMSET (&new_inarg, 0, HCL_SIZEOF(new_inarg));
|
||||
new_inarg.line = 1;
|
||||
new_inarg.colm = 1;
|
||||
HCL_MEMSET (&new_srarg, 0, HCL_SIZEOF(new_srarg));
|
||||
new_srarg.line = 1;
|
||||
new_srarg.colm = 1;
|
||||
|
||||
/* open the top-level source input stream */
|
||||
n = reader(hcl, HCL_IO_OPEN, &new_inarg);
|
||||
n = reader(hcl, HCL_IO_OPEN, &new_srarg);
|
||||
if (n <= -1) goto oops;
|
||||
}
|
||||
|
||||
if (scanner)
|
||||
{
|
||||
HCL_MEMSET (&new_inarg, 0, HCL_SIZEOF(new_inarg));
|
||||
n = scanner(hcl, HCL_IO_OPEN, &new_inarg);
|
||||
if (n <= -1)
|
||||
{
|
||||
reader (hcl, HCL_IO_CLOSE, &new_srarg);
|
||||
goto oops;
|
||||
}
|
||||
}
|
||||
|
||||
if (printer)
|
||||
{
|
||||
/* open the new output stream */
|
||||
HCL_MEMSET (&new_outarg, 0, HCL_SIZEOF(new_outarg));
|
||||
n = printer(hcl, HCL_IO_OPEN, &new_outarg);
|
||||
if (n <= -1)
|
||||
{
|
||||
reader (hcl, HCL_IO_CLOSE, &new_inarg);
|
||||
if (scanner) scanner (hcl, HCL_IO_CLOSE, &new_inarg);
|
||||
if (reader) reader (hcl, HCL_IO_CLOSE, &new_srarg);
|
||||
goto oops;
|
||||
}
|
||||
}
|
||||
|
||||
if (reader)
|
||||
{
|
||||
if (hcl->c->reader)
|
||||
{
|
||||
/* close the old source input stream */
|
||||
hcl->c->reader (hcl, HCL_IO_CLOSE, &hcl->c->inarg);
|
||||
hcl->c->reader (hcl, HCL_IO_CLOSE, &hcl->c->srarg);
|
||||
}
|
||||
hcl->c->reader = reader;
|
||||
hcl->c->inarg = new_inarg;
|
||||
hcl->c->srarg = new_srarg;
|
||||
}
|
||||
|
||||
if (scanner)
|
||||
{
|
||||
if (hcl->io.scanner)
|
||||
{
|
||||
/* close the old input stream */
|
||||
hcl->io.scanner (hcl, HCL_IO_CLOSE, &hcl->io.inarg);
|
||||
}
|
||||
hcl->io.scanner = scanner;
|
||||
hcl->io.inarg = new_inarg;
|
||||
}
|
||||
|
||||
if (printer)
|
||||
{
|
||||
if (hcl->io.printer)
|
||||
{
|
||||
/* close the old output stream */
|
||||
@ -4045,14 +4106,19 @@ int hcl_attachio (hcl_t* hcl, hcl_ioimpl_t reader, hcl_ioimpl_t printer)
|
||||
}
|
||||
hcl->io.printer = printer;
|
||||
hcl->io.outarg = new_outarg;
|
||||
}
|
||||
|
||||
if (reader)
|
||||
{
|
||||
/* clear unneeded source stream names */
|
||||
/*clear_sr_names (hcl, 0); */
|
||||
|
||||
/* initialize some other key fields */
|
||||
hcl->c->nungots = 0;
|
||||
|
||||
/* the source stream is open. set it as the current input stream */
|
||||
hcl->c->curinp = &hcl->c->inarg;
|
||||
hcl->c->curinp = &hcl->c->srarg;
|
||||
}
|
||||
|
||||
clear_io_names (hcl);
|
||||
return 0;
|
||||
|
||||
oops:
|
||||
@ -4075,9 +4141,9 @@ void hcl_detachio (hcl_t* hcl)
|
||||
{
|
||||
if (hcl->c->reader)
|
||||
{
|
||||
while (hcl->c->curinp != &hcl->c->inarg)
|
||||
while (hcl->c->curinp != &hcl->c->srarg)
|
||||
{
|
||||
hcl_ioinarg_t* prev;
|
||||
hcl_iosrarg_t* prev;
|
||||
|
||||
/* nothing much to do about a close error */
|
||||
hcl->c->reader (hcl, HCL_IO_CLOSE, hcl->c->curinp);
|
||||
@ -4094,6 +4160,12 @@ void hcl_detachio (hcl_t* hcl)
|
||||
|
||||
}
|
||||
|
||||
if (hcl->io.scanner)
|
||||
{
|
||||
hcl->io.scanner (hcl, HCL_IO_CLOSE, &hcl->io.inarg);
|
||||
hcl->io.scanner = HCL_NULL; /* ready for another attachment */
|
||||
}
|
||||
|
||||
if (hcl->io.printer)
|
||||
{
|
||||
hcl->io.printer (hcl, HCL_IO_CLOSE, &hcl->io.outarg);
|
||||
@ -4101,33 +4173,31 @@ void hcl_detachio (hcl_t* hcl)
|
||||
}
|
||||
}
|
||||
|
||||
void hcl_setbaseinloc (hcl_t* hcl, hcl_oow_t line, hcl_oow_t colm)
|
||||
void hcl_setbasesrloc (hcl_t* hcl, hcl_oow_t line, hcl_oow_t colm)
|
||||
{
|
||||
hcl->c->inarg.line = line;
|
||||
hcl->c->inarg.colm = colm;
|
||||
hcl->c->srarg.line = line;
|
||||
hcl->c->srarg.colm = colm;
|
||||
}
|
||||
|
||||
hcl_iolxc_t* hcl_readbaseinchar (hcl_t* hcl)
|
||||
hcl_iolxc_t* hcl_readbasesrchar (hcl_t* hcl)
|
||||
{
|
||||
/* read a character using the base input stream. the caller must care extra
|
||||
* care when using this function. this function reads the main stream regardless
|
||||
* of the inclusion status and ignores the ungot characters. */
|
||||
int n = _get_char(hcl, &hcl->c->inarg);
|
||||
int n = _get_char(hcl, &hcl->c->srarg);
|
||||
if (n <= -1) return HCL_NULL;
|
||||
return &hcl->c->inarg.lxc;
|
||||
return &hcl->c->srarg.lxc;
|
||||
}
|
||||
|
||||
|
||||
hcl_ooch_t* hcl_readbaseinraw (hcl_t* hcl, hcl_oow_t* xlen)
|
||||
hcl_ooch_t* hcl_readbasesrraw (hcl_t* hcl, hcl_oow_t* xlen)
|
||||
{
|
||||
/* this function provides the raw input interface to the attached source
|
||||
* input handler. it doesn't increment line/column number, nor does it
|
||||
* care about ungot characters. it must be used with extra care */
|
||||
|
||||
HCL_ASSERT (hcl, hcl->c != HCL_NULL); // call hio_attachio() or hio_attachiostd() first
|
||||
HCL_ASSERT (hcl, hcl->c != HCL_NULL); /* call hio_attachio() or hio_attachiostd() with proper arguments first */
|
||||
|
||||
if (hcl->c->reader(hcl, HCL_IO_READ, &hcl->c->inarg) <= -1) return HCL_NULL;
|
||||
*xlen = hcl->c->inarg.xlen;
|
||||
return hcl->c->inarg.buf;
|
||||
if (hcl->c->reader(hcl, HCL_IO_READ, &hcl->c->srarg) <= -1) return HCL_NULL;
|
||||
*xlen = hcl->c->srarg.xlen;
|
||||
return hcl->c->srarg.buf;
|
||||
}
|
||||
|
||||
|
||||
34
lib/std.c
34
lib/std.c
@ -3195,7 +3195,7 @@ static const hcl_bch_t* get_base_name (const hcl_bch_t* path)
|
||||
return (last == HCL_NULL)? path: (last + 1);
|
||||
}
|
||||
|
||||
static HCL_INLINE int open_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
static HCL_INLINE int open_sr_stream (hcl_t* hcl, hcl_iosrarg_t* arg)
|
||||
{
|
||||
xtn_t* xtn = GET_XTN(hcl);
|
||||
bb_t* bb = HCL_NULL;
|
||||
@ -3277,7 +3277,7 @@ static HCL_INLINE int open_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
arg->name = hcl_dupbtooocstr(hcl, bb->fn, HCL_NULL);
|
||||
/* ignore duplication failure */
|
||||
/* TODO: change the type of arg->name from const hcl_ooch_t* to hcl_ooch_t*.
|
||||
* change its specification from [IN] only to [INOUT] in hcl_ioinarg_t. */
|
||||
* change its specification from [IN] only to [INOUT] in hcl_iosrarg_t. */
|
||||
/* END HACK */
|
||||
}
|
||||
|
||||
@ -3293,7 +3293,7 @@ oops:
|
||||
return -1;
|
||||
}
|
||||
|
||||
static HCL_INLINE int close_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
static HCL_INLINE int close_sr_stream (hcl_t* hcl, hcl_iosrarg_t* arg)
|
||||
{
|
||||
/*xtn_t* xtn = GET_XTN(hcl);*/
|
||||
bb_t* bb;
|
||||
@ -3316,7 +3316,7 @@ static HCL_INLINE int close_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HCL_INLINE int read_input (hcl_t* hcl, hcl_ioinarg_t* arg)
|
||||
static HCL_INLINE int read_sr_stream (hcl_t* hcl, hcl_iosrarg_t* arg)
|
||||
{
|
||||
/*xtn_t* xtn = GET_XTN(hcl);*/
|
||||
bb_t* bb;
|
||||
@ -3371,13 +3371,13 @@ static int read_handler (hcl_t* hcl, hcl_iocmd_t cmd, void* arg)
|
||||
switch (cmd)
|
||||
{
|
||||
case HCL_IO_OPEN:
|
||||
return open_input(hcl, (hcl_ioinarg_t*)arg);
|
||||
return open_sr_stream(hcl, (hcl_iosrarg_t*)arg);
|
||||
|
||||
case HCL_IO_CLOSE:
|
||||
return close_input(hcl, (hcl_ioinarg_t*)arg);
|
||||
return close_sr_stream(hcl, (hcl_iosrarg_t*)arg);
|
||||
|
||||
case HCL_IO_READ:
|
||||
return read_input(hcl, (hcl_ioinarg_t*)arg);
|
||||
return read_sr_stream(hcl, (hcl_iosrarg_t*)arg);
|
||||
|
||||
case HCL_IO_FLUSH:
|
||||
/* no effect on an input stream */
|
||||
@ -3389,7 +3389,7 @@ static int read_handler (hcl_t* hcl, hcl_iocmd_t cmd, void* arg)
|
||||
}
|
||||
}
|
||||
|
||||
static HCL_INLINE int open_output (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
static HCL_INLINE int open_out_stream (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
{
|
||||
xtn_t* xtn = GET_XTN(hcl);
|
||||
FILE* fp;
|
||||
@ -3413,7 +3413,7 @@ static HCL_INLINE int open_output (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HCL_INLINE int close_output (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
static HCL_INLINE int close_out_stream (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
{
|
||||
/*xtn_t* xtn = GET_XTN(hcl);*/
|
||||
FILE* fp;
|
||||
@ -3425,7 +3425,7 @@ static HCL_INLINE int close_output (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HCL_INLINE int write_output (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
static HCL_INLINE int write_out_stream (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
{
|
||||
/*xtn_t* xtn = GET_XTN(hcl);*/
|
||||
hcl_bch_t bcsbuf[1024];
|
||||
@ -3463,7 +3463,7 @@ static HCL_INLINE int write_output (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HCL_INLINE int flush_output (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
static HCL_INLINE int flush_out_stream (hcl_t* hcl, hcl_iooutarg_t* arg)
|
||||
{
|
||||
FILE* fp;
|
||||
|
||||
@ -3479,16 +3479,16 @@ static int print_handler (hcl_t* hcl, hcl_iocmd_t cmd, void* arg)
|
||||
switch (cmd)
|
||||
{
|
||||
case HCL_IO_OPEN:
|
||||
return open_output(hcl, (hcl_iooutarg_t*)arg);
|
||||
return open_out_stream(hcl, (hcl_iooutarg_t*)arg);
|
||||
|
||||
case HCL_IO_CLOSE:
|
||||
return close_output(hcl, (hcl_iooutarg_t*)arg);
|
||||
return close_out_stream(hcl, (hcl_iooutarg_t*)arg);
|
||||
|
||||
case HCL_IO_WRITE:
|
||||
return write_output(hcl, (hcl_iooutarg_t*)arg);
|
||||
return write_out_stream(hcl, (hcl_iooutarg_t*)arg);
|
||||
|
||||
case HCL_IO_FLUSH:
|
||||
return flush_output(hcl, (hcl_iooutarg_t*)arg);
|
||||
return flush_out_stream(hcl, (hcl_iooutarg_t*)arg);
|
||||
|
||||
default:
|
||||
hcl_seterrnum (hcl, HCL_EINTERN);
|
||||
@ -3507,7 +3507,7 @@ int hcl_attachiostdwithbcstr (hcl_t* hcl, const hcl_bch_t* read_file, const hcl_
|
||||
xtn->read_path = read_file;
|
||||
xtn->print_path = print_file;
|
||||
|
||||
n = hcl_attachio(hcl, read_handler, print_handler);
|
||||
n = hcl_attachio(hcl, read_handler, HCL_NULL, print_handler);
|
||||
|
||||
xtn->read_path = HCL_NULL;
|
||||
xtn->print_path = HCL_NULL;
|
||||
@ -3534,7 +3534,7 @@ int hcl_attachiostdwithucstr (hcl_t* hcl, const hcl_uch_t* read_file, const hcl_
|
||||
return -1;
|
||||
}
|
||||
|
||||
n = hcl_attachio(hcl, read_handler, print_handler);
|
||||
n = hcl_attachio(hcl, read_handler, HCL_NULL, print_handler);
|
||||
|
||||
hcl_freemem (hcl, xtn->read_path);
|
||||
hcl_freemem (hcl, xtn->print_path);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user