static int init_exec_dds (exec_t* e, qse_mmgr_t* mmgr)
{
/* initializes dynamic data structures */
if (qse_lda_init (&e->cand.set[0], mmgr, 100) <= -1)
{
e->rex->errnum = QSE_REX_ENOMEM;
return -1;
}
if (qse_lda_init (&e->cand.set[1], mmgr, 100) <= -1)
{
e->rex->errnum = QSE_REX_ENOMEM;
qse_lda_fini (&e->cand.set[0]);
return -1;
}
qse_lda_setscale (&e->cand.set[0], QSE_SIZEOF(cand_t));
qse_lda_setscale (&e->cand.set[1], QSE_SIZEOF(cand_t));
qse_lda_setcopier (&e->cand.set[0], QSE_LDA_COPIER_INLINE);
qse_lda_setcopier (&e->cand.set[1], QSE_LDA_COPIER_INLINE);
qse_lda_setfreeer (&e->cand.set[0], refdowngroupstack_incand);
qse_lda_setfreeer (&e->cand.set[1], refdowngroupstack_incand);
qse_lda_setcomper (&e->cand.set[0], comp_cand);
qse_lda_setcomper (&e->cand.set[1], comp_cand);
return 0;
}
static QSE_INLINE __utf8_t* get_utf8_slot (qse_wchar_t uc)
{
#if (QSE_SIZEOF_WCHAR_T == QSE_SIZEOF_MCHAR_T)
/* no utf8 support */
return QSE_NULL; /* invalid character */
#else
__utf8_t* cur, * end;
QSE_ASSERT (QSE_SIZEOF(qse_mchar_t) == 1);
QSE_ASSERT (QSE_SIZEOF(qse_wchar_t) >= 2);
end = utf8_table + QSE_COUNTOF(utf8_table);
cur = utf8_table;
while (cur < end)
{
if (uc >= cur->lower && uc <= cur->upper) return cur;
cur++;
}
return QSE_NULL; /* invalid character */
#endif
}
static qse_rex_node_t* newnode (comp_t* c, qse_rex_node_id_t id)
{
qse_rex_node_t* node;
/* TODO: performance optimization.
* preallocate a large chunk of memory and allocate a node
* from the chunk. increase the chunk if it has been used up.
*/
node = (qse_rex_node_t*)
QSE_MMGR_ALLOC (c->rex->mmgr, QSE_SIZEOF(qse_rex_node_t));
if (node == QSE_NULL)
{
c->rex->errnum = QSE_REX_ENOMEM;
return QSE_NULL;
}
QSE_MEMSET (node, 0, QSE_SIZEOF(*node));
node->id = id;
if (c->start != QSE_NULL)
{
QSE_ASSERT (c->start->id == QSE_REX_NODE_START);
node->link = c->start->u.s.link;
c->start->u.s.link = node;
}
return node;
}
static group_t* dupgroupstackmembers (exec_t* e, group_t* g)
{
group_t* yg, * xg = QSE_NULL;
QSE_ASSERT (g != QSE_NULL);
if (g->next != QSE_NULL)
{
/* TODO: make it non recursive or
* implement stack overflow protection */
xg = dupgroupstackmembers (e, g->next);
if (xg == QSE_NULL) return QSE_NULL;
}
yg = (group_t*) QSE_MMGR_ALLOC (e->rex->mmgr, QSE_SIZEOF(*yg));
if (yg == QSE_NULL)
{
if (xg != QSE_NULL) freegroupstack (xg, e->rex->mmgr);
e->rex->errnum = QSE_REX_ENOMEM;
return QSE_NULL;
}
QSE_MEMCPY (yg, g, QSE_SIZEOF(*yg));
yg->next = xg;
return yg;
}
/* duplidate a group stack excluding the top data element */
static group_t* dupgroupstackpop (exec_t* e, group_t* gs)
{
group_t* dupg, * head;
QSE_ASSERT (gs != QSE_NULL);
QSE_ASSERTX (gs->node == QSE_NULL,
"The head of a group stack must point to QSE_NULL for management purpose.");
QSE_ASSERTX (gs->next != QSE_NULL && gs->next->next != QSE_NULL,
"dupgroupstackpop() needs at least two data elements");
dupg = dupgroupstackmembers (e, gs->next->next);
if (dupg == QSE_NULL) return QSE_NULL;
head = (group_t*) QSE_MMGR_ALLOC (e->rex->mmgr, QSE_SIZEOF(*head));
if (head == QSE_NULL)
{
if (dupg != QSE_NULL) freegroupstackmembers (dupg, e->rex->mmgr);
e->rex->errnum = QSE_REX_ENOMEM;
return QSE_NULL;
}
head->node = QSE_NULL;
head->occ = 0;
head->next = dupg;
return head;
}
int qse_timelocal (const qse_btime_t* bt, qse_ntime_t* nt)
{
/* TODO: qse_timelocal - remove dependency on timelocal */
struct tm tm;
QSE_MEMSET (&tm, 0, QSE_SIZEOF(tm));
tm.tm_sec = bt->sec;
tm.tm_min = bt->min;
tm.tm_hour = bt->hour;
tm.tm_mday = bt->mday;
tm.tm_mon = bt->mon;
tm.tm_year = bt->year;
tm.tm_wday = bt->wday;
tm.tm_yday = bt->yday;
tm.tm_isdst = bt->isdst;
#if defined(HAVE_TIMELOCAL)
nt->sec = timelocal (&tm);
#else
nt->sec = mktime (&tm);
#endif
nt->nsec = 0;
return 0;
}
qse_httpd_task_t* qse_httpd_entaskformat (
qse_httpd_t* httpd,
qse_httpd_client_t* client,
qse_httpd_task_t* pred,
const qse_mchar_t* fmt, ...)
{
qse_httpd_task_t task;
task_format_t data;
va_list ap;
qse_mchar_t* buf;
int bytes_req, l;
va_start (ap, fmt);
bytes_req = qse_mbsxvfmt (QSE_NULL, 0, fmt, ap);
va_end (ap);
buf = (qse_mchar_t*) qse_httpd_allocmem (
httpd, (bytes_req + 1) * QSE_SIZEOF(*buf));
if (buf == QSE_NULL) return QSE_NULL;
va_start (ap, fmt);
l = qse_mbsxvfmt (buf, bytes_req + 1, fmt, ap);
va_end (ap);
if (l != bytes_req)
{
/* something got wrong ... */
qse_httpd_freemem (httpd, buf);
httpd->errnum = QSE_HTTPD_EINTERN;
return QSE_NULL;
}
QSE_MEMSET (&data, 0, QSE_SIZEOF(data));
data.org = buf;
data.ptr = buf;
data.left = l;
QSE_MEMSET (&task, 0, QSE_SIZEOF(task));
task.init = task_init_format;
task.fini = task_fini_format;
task.main = task_main_format;
task.ctx = &data;
return qse_httpd_entask (
httpd, client, pred, &task, QSE_SIZEOF(data));
}
void qse_xli_seterrmsg (
qse_xli_t* xli, qse_xli_errnum_t errnum,
const qse_char_t* errmsg, const qse_xli_loc_t* errloc)
{
xli->errnum = errnum;
qse_strxcpy (xli->errmsg, QSE_COUNTOF(xli->errmsg), errmsg);
if (errloc != QSE_NULL) xli->errloc = *errloc;
else QSE_MEMSET (&xli->errloc, 0, QSE_SIZEOF(xli->errloc));
}
static int task_init_format (
qse_httpd_t* httpd, qse_httpd_client_t* client, qse_httpd_task_t* task)
{
task_format_t* xtn = qse_httpd_gettaskxtn (httpd, task);
QSE_MEMCPY (xtn, task->ctx, QSE_SIZEOF(*xtn));
task->ctx = xtn;
return 0;
}
int qse_tio_attachin (
qse_tio_t* tio, qse_tio_io_impl_t input,
qse_mchar_t* bufptr, qse_size_t bufcapa)
{
qse_mchar_t* xbufptr;
if (input == QSE_NULL || bufcapa < QSE_TIO_MININBUFCAPA)
{
tio->errnum = QSE_TIO_EINVAL;
return -1;
}
if (qse_tio_detachin(tio) <= -1) return -1;
QSE_ASSERT (tio->in.fun == QSE_NULL);
xbufptr = bufptr;
if (xbufptr == QSE_NULL)
{
xbufptr = QSE_MMGR_ALLOC (
tio->mmgr, QSE_SIZEOF(qse_mchar_t) * bufcapa);
if (xbufptr == QSE_NULL)
{
tio->errnum = QSE_TIO_ENOMEM;
return -1;
}
}
tio->errnum = QSE_TIO_ENOERR;
if (input (tio, QSE_TIO_OPEN, QSE_NULL, 0) <= -1)
{
if (tio->errnum == QSE_TIO_ENOERR) tio->errnum = QSE_TIO_EOTHER;
if (xbufptr != bufptr) QSE_MMGR_FREE (tio->mmgr, xbufptr);
return -1;
}
/* if i defined tio->io[2] instead of tio->in and tio-out,
* i would be able to shorten code amount. but fields to initialize
* are not symmetric between input and output.
* so it's just a bit clumsy that i repeat almost the same code
* in qse_tio_attachout().
*/
tio->in.fun = input;
tio->in.buf.ptr = xbufptr;
tio->in.buf.capa = bufcapa;
tio->status &= ~(STATUS_INPUT_ILLSEQ | STATUS_INPUT_EOF);
tio->inbuf_cur = 0;
tio->inbuf_len = 0;
if (xbufptr != bufptr) tio->status |= STATUS_INPUT_DYNBUF;
return 0;
}
qse_httpd_task_t* qse_httpd_entaskdisconnect (
qse_httpd_t* httpd,
qse_httpd_client_t* client,
qse_httpd_task_t* pred)
{
qse_httpd_task_t task;
QSE_MEMSET (&task, 0, QSE_SIZEOF(task));
task.main = task_main_disconnect;
return qse_httpd_entask (httpd, client, pred, &task, 0);
}
int qse_rex_exec (
qse_rex_t* rex, const qse_cstr_t* str,
const qse_cstr_t* substr, qse_cstr_t* matstr)
{
exec_t e;
int n = 0;
if (rex->code == QSE_NULL)
{
rex->errnum = QSE_REX_ENOCOMP;
return -1;
}
QSE_MEMSET (&e, 0, QSE_SIZEOF(e));
e.rex = rex;
e.str.ptr = str->ptr;
e.str.end = str->ptr + str->len;
e.sub.ptr = substr->ptr;
e.sub.end = substr->ptr + substr->len;
if (init_exec_dds (&e, rex->mmgr) <= -1) return -1;
while (e.sub.ptr <= e.sub.end)
{
n = exec (&e);
if (n <= -1)
{
n = -1;
break;
}
if (n >= 1)
{
QSE_ASSERT (e.nmatches > 0);
QSE_ASSERT (e.matchend != QSE_NULL);
if (matstr)
{
matstr->ptr = e.sub.ptr;
matstr->len = e.matchend - e.sub.ptr;
}
break;
}
e.sub.ptr++;
}
fini_exec_dds (&e);
return n;
}
int qse_rex_init (qse_rex_t* rex, qse_mmgr_t* mmgr, qse_rex_node_t* code)
{
QSE_MEMSET (rex, 0, QSE_SIZEOF(*rex));
rex->mmgr = mmgr;
QSE_ASSERT (code == QSE_NULL || code->id == QSE_REX_NODE_START);
/* note that passing a compiled expression to qse_rex_open()
* is to delegate it to this rex object. when this rex object
* is closed, the code delegated is destroyed. */
rex->code = code;
return 0;
}
static int matchtre (
qse_awk_t* awk, qse_tre_t* tre, int opt,
const qse_cstr_t* str, qse_cstr_t* mat,
qse_cstr_t submat[9], qse_awk_errnum_t* errnum)
{
int n;
/*qse_tre_match_t match[10] = { { 0, 0 }, };*/
qse_tre_match_t match[10];
QSE_MEMSET (match, 0, QSE_SIZEOF(match));
n = qse_tre_execx(tre, str->ptr, str->len, match, QSE_COUNTOF(match), opt);
if (n <= -1)
{
if (QSE_TRE_ERRNUM(tre) == QSE_TRE_ENOMATCH) return 0;
#if 0 /* TODO: */
*errnum = (QSE_TRE_ERRNUM(tre) == QSE_TRE_ENOMEM)?
QSE_AWK_ENOMEM: QSE_AWK_EREXMA;
SETERR0 (sed, errnum, loc);
#endif
*errnum = (QSE_TRE_ERRNUM(tre) == QSE_TRE_ENOMEM)?
QSE_AWK_ENOMEM: QSE_AWK_EREXMA;
return -1;
}
QSE_ASSERT (match[0].rm_so != -1);
if (mat)
{
mat->ptr = &str->ptr[match[0].rm_so];
mat->len = match[0].rm_eo - match[0].rm_so;
}
if (submat)
{
int i;
/* you must intialize submat before you pass into this
* function because it can abort filling */
for (i = 1; i < QSE_COUNTOF(match); i++)
{
if (match[i].rm_so != -1)
{
submat[i-1].ptr = &str->ptr[match[i].rm_so];
submat[i-1].len = match[i].rm_eo - match[i].rm_so;
}
}
}
return 1;
}
void qse_xli_seterror (
qse_xli_t* xli, qse_xli_errnum_t errnum,
const qse_cstr_t* errarg, const qse_xli_loc_t* errloc)
{
const qse_char_t* errfmt;
xli->errnum = errnum;
errfmt = qse_xli_geterrstr(xli)(xli,xli->errnum);
QSE_ASSERT (errfmt != QSE_NULL);
qse_strxfncpy (xli->errmsg, QSE_COUNTOF(xli->errmsg), errfmt, errarg);
if (errloc != QSE_NULL) xli->errloc = *errloc;
else QSE_MEMSET (&xli->errloc, 0, QSE_SIZEOF(xli->errloc));
}
rbt_t* qse_rbt_open (mmgr_t* mmgr, size_t xtnsize, int kscale, int vscale)
{
rbt_t* rbt;
rbt = (rbt_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(rbt_t) + xtnsize);
if (rbt == QSE_NULL) return QSE_NULL;
if (qse_rbt_init (rbt, mmgr, kscale, vscale) <= -1)
{
QSE_MMGR_FREE (mmgr, rbt);
return QSE_NULL;
}
QSE_MEMSET (rbt + 1, 0, xtnsize);
return rbt;
}
qse_rex_t* qse_rex_open (qse_mmgr_t* mmgr, qse_size_t xtnsize, qse_rex_node_t* code)
{
qse_rex_t* rex;
rex = (qse_rex_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_rex_t) + xtnsize);
if (rex == QSE_NULL) return QSE_NULL;
if (qse_rex_init (rex, mmgr, code) <= -1)
{
QSE_MMGR_FREE (mmgr, rex);
return QSE_NULL;
}
QSE_MEMSET (QSE_XTN(rex), 0, xtnsize);
return rex;
}
qse_tio_t* qse_tio_open (qse_mmgr_t* mmgr, qse_size_t xtnsize, int flags)
{
qse_tio_t* tio;
tio = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_tio_t) + xtnsize);
if (tio)
{
if (qse_tio_init (tio, mmgr, flags) <= -1)
{
QSE_MMGR_FREE (mmgr, tio);
return QSE_NULL;
}
else QSE_MEMSET (QSE_XTN(tio), 0, xtnsize);
}
return tio;
}
int qse_localtime (const qse_ntime_t* nt, qse_btime_t* bt)
{
struct tm* tm;
time_t t = nt->sec;
/* TODO: remove dependency on localtime/localtime_r */
#if defined(_WIN32)
tm = localtime (&t);
#elif defined(__OS2__)
# if defined(__WATCOMC__)
struct tm btm;
tm = _localtime (&t, &btm);
# else
# error Please support other compilers
# endif
#elif defined(__DOS__)
# if defined(__WATCOMC__)
struct tm btm;
tm = _localtime (&t, &btm);
# else
# error Please support other compilers
# endif
#elif defined(HAVE_LOCALTIME_R)
struct tm btm;
tm = localtime_r (&t, &btm);
#else
/* thread unsafe */
tm = localtime (&t);
#endif
if (tm == QSE_NULL) return -1;
QSE_MEMSET (bt, 0, QSE_SIZEOF(*bt));
bt->sec = tm->tm_sec;
bt->min = tm->tm_min;
bt->hour = tm->tm_hour;
bt->mday = tm->tm_mday;
bt->mon = tm->tm_mon;
bt->year = tm->tm_year;
bt->wday = tm->tm_wday;
bt->yday = tm->tm_yday;
bt->isdst = tm->tm_isdst;
/*bt->offset = tm->tm_offset;*/
return 0;
}
int qse_tio_attachout (
qse_tio_t* tio, qse_tio_io_impl_t output,
qse_mchar_t* bufptr, qse_size_t bufcapa)
{
qse_mchar_t* xbufptr;
if (output == QSE_NULL || bufcapa < QSE_TIO_MINOUTBUFCAPA)
{
tio->errnum = QSE_TIO_EINVAL;
return -1;
}
if (qse_tio_detachout(tio) == -1) return -1;
QSE_ASSERT (tio->out.fun == QSE_NULL);
xbufptr = bufptr;
if (xbufptr == QSE_NULL)
{
xbufptr = QSE_MMGR_ALLOC (
tio->mmgr, QSE_SIZEOF(qse_mchar_t) * bufcapa);
if (xbufptr == QSE_NULL)
{
tio->errnum = QSE_TIO_ENOMEM;
return -1;
}
}
tio->errnum = QSE_TIO_ENOERR;
if (output (tio, QSE_TIO_OPEN, QSE_NULL, 0) <= -1)
{
if (tio->errnum == QSE_TIO_ENOERR) tio->errnum = QSE_TIO_EOTHER;
if (xbufptr != bufptr) QSE_MMGR_FREE (tio->mmgr, xbufptr);
return -1;
}
tio->out.fun = output;
tio->out.buf.ptr = xbufptr;
tio->out.buf.capa = bufcapa;
tio->outbuf_len = 0;
if (xbufptr != bufptr) tio->status |= STATUS_OUTPUT_DYNBUF;
return 0;
}
qse_nwio_t* qse_nwio_open (
qse_mmgr_t* mmgr, qse_size_t xtnsize, const qse_nwad_t* nwad,
int flags, const qse_nwio_tmout_t* tmout)
{
qse_nwio_t* nwio;
nwio = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_nwio_t) + xtnsize);
if (nwio == QSE_NULL) return QSE_NULL;
if (qse_nwio_init (nwio, mmgr, nwad, flags, tmout) <= -1)
{
QSE_MMGR_FREE (mmgr, nwio);
return QSE_NULL;
}
QSE_MEMSET (nwio + 1, 0, xtnsize);
return nwio;
}
static int test1 ()
{
qse_sll_t* s1;
qse_sll_node_t* p;
qse_char_t* x[] =
{
QSE_T("this is so good"),
QSE_T("what the hack"),
QSE_T("do you like it?")
};
int i;
s1 = qse_sll_open (QSE_MMGR_GETDFL(), 0);
if (s1 == QSE_NULL)
{
qse_printf (QSE_T("cannot open a string\n"));
return -1;
}
qse_sll_setcopier (s1, QSE_SLL_COPIER_INLINE);
qse_sll_setscale (s1, QSE_SIZEOF(qse_char_t));
for (i = 0; i < QSE_COUNTOF(x); i++)
{
qse_sll_pushtail (s1, x[i], qse_strlen(x[i]));
}
qse_printf (QSE_T("s1 holding [%d] nodes\n"), QSE_SLL_SIZE(s1));
qse_sll_walk (s1, walk_sll, QSE_NULL);
p = qse_sll_search (s1, QSE_NULL, x[0], qse_strlen(x[0]));
if (p != QSE_NULL)
{
qse_sll_delete (s1, p);
}
qse_printf (QSE_T("s1 holding [%d] nodes\n"), QSE_SLL_SIZE(s1));
qse_sll_walk (s1, walk_sll, QSE_NULL);
qse_sll_close (s1);
return 0;
}
static int collect_into_xarg (const qse_cstr_t* path, void* ctx)
{
xarg_t* xarg = (xarg_t*)ctx;
if (xarg->size <= xarg->capa)
{
qse_char_t** tmp;
tmp = QSE_MMGR_REALLOC (xarg->mmgr, xarg->ptr, QSE_SIZEOF(*tmp) * (xarg->capa + 128));
if (tmp == QSE_NULL) return -1;
xarg->ptr = tmp;
xarg->capa += 128;
}
xarg->ptr[xarg->size] = qse_strdup (path->ptr, xarg->mmgr);
if (xarg->ptr[xarg->size] == QSE_NULL) return -1;
xarg->size++;
return 0;
}
int qse_rbt_init (rbt_t* rbt, mmgr_t* mmgr, int kscale, int vscale)
{
/* do not zero out the extension */
QSE_MEMSET (rbt, 0, SIZEOF(*rbt));
rbt->mmgr = mmgr;
rbt->scale[QSE_RBT_KEY] = (kscale < 1)? 1: kscale;
rbt->scale[QSE_RBT_VAL] = (vscale < 1)? 1: vscale;
rbt->size = 0;
rbt->style = &style[0];
/* self-initializing nil */
QSE_MEMSET(&rbt->xnil, 0, QSE_SIZEOF(rbt->xnil));
rbt->xnil.color = QSE_RBT_BLACK;
rbt->xnil.left = &rbt->xnil;
rbt->xnil.right = &rbt->xnil;
/* root is set to nil initially */
rbt->root = &rbt->xnil;
return 0;
}
static int add_script (const qse_char_t* str, int mem)
{
if (g_script.size >= g_script.capa)
{
qse_sed_iostd_t* tmp;
tmp = QSE_MMGR_REALLOC (
QSE_MMGR_GETDFL(),
g_script.io,
QSE_SIZEOF(*g_script.io) * (g_script.capa + 16 + 1));
if (tmp == QSE_NULL)
{
qse_fprintf (QSE_STDERR, QSE_T("ERROR: out of memory while processing %s\n"), str);
return -1;
}
g_script.io = tmp;
g_script.capa += 16;
}
if (mem)
{
g_script.io[g_script.size].type = QSE_SED_IOSTD_STR;
/* though its type is not qualified to be const,
* u.mem.ptr is actually const when used for input */
g_script.io[g_script.size].u.str.ptr = (qse_char_t*)str;
g_script.io[g_script.size].u.str.len = qse_strlen(str);
}
else
{
g_script.io[g_script.size].type = QSE_SED_IOSTD_FILE;
g_script.io[g_script.size].u.file.path = str;
g_script.io[g_script.size].u.file.cmgr = g_script_cmgr;
}
g_script.size++;
return 0;
}
int qse_tio_init (qse_tio_t* tio, qse_mmgr_t* mmgr, int flags)
{
QSE_MEMSET (tio, 0, QSE_SIZEOF(*tio));
tio->mmgr = mmgr;
tio->cmgr = qse_getdflcmgr();
tio->flags = flags;
/*
tio->input_func = QSE_NULL;
tio->input_arg = QSE_NULL;
tio->output_func = QSE_NULL;
tio->output_arg = QSE_NULL;
tio->status = 0;
tio->inbuf_cur = 0;
tio->inbuf_len = 0;
tio->outbuf_len = 0;
*/
tio->errnum = QSE_TIO_ENOERR;
return 0;
}
static int getc (comp_t* com, int noesc)
{
qse_char_t c;
if (com->ptr >= com->end)
{
com->c.value = QSE_CHAR_EOF;
com->c.escaped = 0;
return 0;
}
com->c.value = *com->ptr++;
com->c.escaped = 0;
if (noesc || com->c.value != QSE_T('\\')) return 0;
CHECK_END (com);
c = *com->ptr++;
if (c == QSE_T('n')) c = QSE_T('\n');
else if (c == QSE_T('r')) c = QSE_T('\r');
else if (c == QSE_T('t')) c = QSE_T('\t');
else if (c == QSE_T('f')) c = QSE_T('\f');
else if (c == QSE_T('b')) c = QSE_T('\b');
else if (c == QSE_T('v')) c = QSE_T('\v');
else if (c == QSE_T('a')) c = QSE_T('\a');
#if 0
/* backrefernce conflicts with octal notation */
else if (c >= QSE_T('0') && c <= QSE_T('7'))
{
qse_char_t cx;
c = c - QSE_T('0');
CHECK_END (com);
cx = *com->ptr++;
if (cx >= QSE_T('0') && cx <= QSE_T('7'))
{
c = c * 8 + cx - QSE_T('0');
CHECK_END (com);
cx = *com->ptr++;
if (cx >= QSE_T('0') && cx <= QSE_T('7'))
{
c = c * 8 + cx - QSE_T('0');
}
}
}
#endif
else if (c == QSE_T('x'))
{
qse_char_t cx;
CHECK_END (com);
cx = *com->ptr++;
if (IS_HEX(cx))
{
c = HEX_TO_NUM(cx);
CHECK_END (com);
cx = *com->ptr++;
if (IS_HEX(cx))
{
c = c * 16 + HEX_TO_NUM(cx);
}
}
}
#if defined(QSE_CHAR_IS_WCHAR)
else if (c == QSE_T('u') && QSE_SIZEOF(qse_char_t) >= 2)
{
qse_char_t cx;
CHECK_END (com);
cx = *com->ptr++;
if (IS_HEX(cx))
{
qse_size_t i;
c = HEX_TO_NUM(cx);
for (i = 0; i < 3; i++)
{
CHECK_END (com);
cx = *com->ptr++;
if (!IS_HEX(cx)) break;
c = c * 16 + HEX_TO_NUM(cx);
}
}
}
else if (c == QSE_T('U') && QSE_SIZEOF(qse_char_t) >= 4)
{
qse_char_t cx;
CHECK_END (com);
cx = *com->ptr++;
if (IS_HEX(cx))
{
qse_size_t i;
c = HEX_TO_NUM(cx);
for (i = 0; i < 7; i++)
{
CHECK_END (com);
cx = *com->ptr++;
if (!IS_HEX(cx)) break;
c = c * 16 + HEX_TO_NUM(cx);
}
}
}
#endif
com->c.value = c;
com->c.escaped = QSE_TRUE;
#if 0
com->c = (com->ptr < com->end)? *com->ptr++: QSE_CHAR_EOF;
if (com->c == QSE_CHAR_EOF)
qse_printf (QSE_T("getc => <EOF>\n"));
else qse_printf (QSE_T("getc => %c\n"), com->c);
#endif
return 0;
}
int qse_mbstouri (const qse_mchar_t* str, qse_muri_t* uri, int flags)
{
const qse_mchar_t* ptr, * colon;
qse_muri_t xuri;
QSE_MEMSET (&xuri, 0, QSE_SIZEOF(xuri));
/* scheme */
xuri.scheme.ptr = str;
while (*str != QSE_MT(':'))
{
if (*str == QSE_MT('\0')) return -1;
str++;
}
xuri.scheme.len = str - (const qse_mchar_t*)xuri.scheme.ptr;
str++; /* skip : */
if (*str != QSE_MT('/')) return -1;
str++; /* skip / */
if (*str != QSE_MT('/')) return -1;
str++; /* skip / */
/* username, password, host, port */
for (colon = QSE_NULL, ptr = str; ; str++)
{
if (flags & QSE_MBSTOURI_NOAUTH)
{
if (colon == QSE_NULL && *str == QSE_MT(':')) colon = str;
else if (*str == QSE_MT('/') || *str == QSE_MT('\0'))
{
if (colon)
{
xuri.host.ptr = ptr;
xuri.host.len = colon - ptr;
xuri.port.ptr = colon + 1;
xuri.port.len = str - colon - 1;
}
else
{
xuri.host.ptr = ptr;
xuri.host.len = str - ptr;
}
break;
}
}
else
{
if (colon == QSE_NULL && *str == QSE_MT(':')) colon = str;
else if (xuri.auth.user.ptr == QSE_NULL && *str == QSE_MT('@'))
{
if (colon)
{
xuri.auth.user.ptr = ptr;
xuri.auth.user.len = colon - ptr;
xuri.auth.pass.ptr = colon + 1;
xuri.auth.pass.len = str - colon - 1;
colon = QSE_NULL;
}
else
{
xuri.auth.user.ptr = ptr;
xuri.auth.user.len = str - ptr;
}
ptr = str + 1;
}
else if (*str == QSE_MT('/') || *str == QSE_MT('\0'))
{
if (colon)
{
xuri.host.ptr = ptr;
xuri.host.len = colon - ptr;
xuri.port.ptr = colon + 1;
xuri.port.len = str - colon - 1;
}
else
{
xuri.host.ptr = ptr;
xuri.host.len = str - ptr;
}
break;
}
}
}
if (*str == QSE_MT('/'))
{
xuri.path.ptr = str;
while (*str != QSE_MT('\0'))
{
if ((!(flags & QSE_MBSTOURI_NOQUERY) && *str == QSE_MT('?')) ||
(!(flags & QSE_MBSTOURI_NOFRAG) && *str == QSE_MT('#'))) break;
str++;
}
xuri.path.len = str - (const qse_mchar_t*)xuri.path.ptr;
if (!(flags & QSE_MBSTOURI_NOQUERY) && *str == QSE_MT('?'))
{
xuri.query.ptr = ++str;
while (*str != QSE_MT('\0'))
{
if (!(flags & QSE_MBSTOURI_NOFRAG) && *str == QSE_MT('#')) break;
str++;
}
xuri.query.len = str - (const qse_mchar_t*)xuri.query.ptr;
}
if (!(flags & QSE_MBSTOURI_NOFRAG) && *str == QSE_MT('#'))
{
xuri.frag.ptr = ++str;
while (*str != QSE_MT('\0')) str++;
xuri.frag.len = str - (const qse_mchar_t*)xuri.frag.ptr;
}
}
QSE_ASSERT (*str == QSE_MT('\0'));
*uri = xuri;
return 0;
}
qse_size_t move (qse_wchar_t* dst, const qse_wchar_t* src, qse_size_t ssz) const
{
// this one doesn't insert terminating null
qse_memmove (dst, src, ssz * QSE_SIZEOF(*dst));
return ssz;
}
/* push 'gn' to the group stack 'gs'.
* if dup is non-zero, the group stack is duplicated and 'gn' is pushed to
* its top */
static group_t* __groupstackpush (
exec_t* e, group_t* gs, qse_rex_node_t* gn, int dup)
{
group_t* head, * elem;
QSE_ASSERT (gn->id == QSE_REX_NODE_GROUP);
if (gs == QSE_NULL)
{
/* gn is the first group pushed. no stack yet.
* create the head to store management info. */
head = (group_t*) QSE_MMGR_ALLOC (e->rex->mmgr, QSE_SIZEOF(*head));
if (head == QSE_NULL)
{
e->rex->errnum = QSE_REX_ENOMEM;
return QSE_NULL;
}
/* the head does not point to any group node. */
head->node = QSE_NULL;
/* the occ field is used for reference counting.
* refupgroupstack and refdowngroupstack update it. */
head->occ = 0;
/* the head links to the first actual group */
head->next = QSE_NULL;
}
else
{
if (dup)
{
/* duplicate existing stack */
head = dupgroupstack (e, gs);
if (head == QSE_NULL) return QSE_NULL;
}
else
{
head = gs;
}
}
/* create a new stack element */
elem = (group_t*) QSE_MMGR_ALLOC (e->rex->mmgr, QSE_SIZEOF(*elem));
if (elem == QSE_NULL)
{
/* rollback */
if (gs == QSE_NULL)
QSE_MMGR_FREE (e->rex->mmgr, head);
else if (dup)
freegroupstack (head, e->rex->mmgr);
e->rex->errnum = QSE_REX_ENOMEM;
return QSE_NULL;
}
/* initialize the element */
elem->node = gn;
elem->occ = 0;
/* make it the top */
elem->next = head->next;
head->next = elem;
return head;
}
