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