static size_t
unescape_ent(struct buf *ob, const uint8_t *src, size_t size)
{
size_t i = 0;
if (size > 3 && src[0] == '#') {
int codepoint = 0;
if (_isdigit(src[1])) {
for (i = 1; i < size && _isdigit(src[i]); ++i)
codepoint = (codepoint * 10) + (src[i] - '0');
}
else if (src[1] == 'x' || src[1] == 'X') {
for (i = 2; i < size && _isxdigit(src[i]); ++i)
codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
}
if (i < size && src[i] == ';') {
bufput_utf8(ob, codepoint);
return i + 1;
}
}
else {
if (size > MAX_WORD_LENGTH)
size = MAX_WORD_LENGTH;
for (i = MIN_WORD_LENGTH; i < size; ++i) {
if (src[i] == ' ')
break;
if (src[i] == ';') {
const struct html_ent *entity = find_entity((char *)src, i);
if (entity != NULL) {
bufput(ob, entity->utf8, entity->utf8_len);
return i + 1;
}
break;
}
}
}
bufputc(ob, '&');
return 0;
}
int isdigit(int c) {
#if !CAM_DRYOS
return _isdigit(c);
#else
return _ctype(c,_D);
#endif
}
int my_htoi(const char * const s) {
//int neg = 0;
if (s == NULL) return 0;
char* cur = (char*)s;
while(*cur != '\0' && _isspace(*cur)) {
cur++;
}
if (*cur++ == '0' && (*cur == 'x' || *cur == 'X')) {
cur++;
} else {
// backtrack
cur--;
}
int acc = 0;
while(*cur != '\0' && (_isdigit(*cur) || _isvalidchar(*cur))) {
acc = acc * 16 + convert(*cur);
//printf("acc = %x \n", acc);
++cur;
}
if (*cur != '\0') acc = 0;
return acc;
}
static size_t unescape_entity(lanli_buffer *ob, const uint8_t *data, size_t size) {
size_t i = 0;
if (size > 3 && data[0] == '#') {
int codepoint = 0;
if (_isdigit(data[1])) {
for (i = 1; i < size && _isdigit(data[i]); ++i)
codepoint = (codepoint * 10) + (data[i] - '0');
}
else if (data[1] == 'x' || data[1] == 'X') {
for (i = 2; i < size && _isxdigit(data[i]); ++i)
codepoint = (codepoint * 16) + ((data[i] | 32) % 39 - 9);
if (i == 2) return 0;
}
if (i < size && data[i] == ';') {
lanli_buffer_put_utf8(ob, codepoint);
return i + 1;
}
}
else {
if (size > MAX_WORD_LENGTH)
size = MAX_WORD_LENGTH;
for (i = MIN_WORD_LENGTH; i < size; ++i) {
if (data[i] == ' ')
break;
if (data[i] == ';') {
const struct html_entity *entity = find_entity((const char *)data, i);
if (entity != NULL) {
lanli_buffer_put(ob, entity->utf8, entity->size);
return i + 1;
}
break;
}
}
}
lanli_buffer_putc(ob, '&');
return 0;
}
unsigned long _strtoul_t(
const char *nptr,
char **endptr,
register int base
)
{
register const char *s = nptr;
register unsigned long acc;
register int c;
register unsigned long cutoff;
register int neg = 0, any, cutlim;
do {
c = *s++;
} while (_isspace(c));
if (c == '-') {
neg = 1;
c = *s++;
} else if (c == '+')
c = *s++;
if ((base == 0 || base == 16) &&
c == '0' && (*s == 'x' || *s == 'X')) {
c = s[1];
s += 2;
base = 16;
}
if (base == 0)
base = c == '0' ? 8 : 10;
cutoff = neg ? (~((unsigned long)_LONG_MIN)+1) : _LONG_MAX;
cutlim = cutoff % (unsigned long)base;
cutoff /= (unsigned long)base;
for (acc = 0, any = 0;; c = *s++) {
if (_isdigit(c))
c -= '0';
else if (_isalpha(c))
c -= _to_upper(c) & 0xf + 10;
else
break;
if (c >= base)
break;
if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
any = -1;
else {
any = 1;
acc *= base;
acc += c;
}
}
if (any < 0) {
acc = neg ? _LONG_MIN : _LONG_MAX;
} else if (neg)
acc = ~acc+1;
if (endptr != 0)
*endptr = (char *) (any ? s - 1 : nptr);
return (acc);
}
static unsigned int _atou(const char **p) {
unsigned int v = 0;
while (_isdigit(**p)) {
v *= 10;
v += (**p - '0');
(*p)++;
}
return v;
}
void fmt(struct fmtctx *ctx, va_list args) {
int i;
ctx->state = 0;
while (*ctx->str) {
if (*ctx->str != '%') {
ctx->out(ctx->priv, *ctx->str++);
continue;
}
ctx->str++;
ctx->state = 0;
if (*ctx->str == '0') {
ctx->state |= ST_ZEROPAD;
ctx->str++;
}
if (_isdigit(*ctx->str)) {
PACKWID(ctx, _atou(&ctx->str));
ctx->state |= ST_WIDTH;
}
if (*ctx->str == '.') {
ctx->str++;
if (_isdigit(*ctx->str))
PACKPREC(ctx, _atou(&ctx->str));
else if (*ctx->str == '*') {
ctx->str++;
PACKPREC(ctx, va_arg(args, unsigned int));
}
ctx->state |= ST_PREC;
}
if (*ctx->str == 'l') {
ctx->str++;
ctx->state |= (*ctx->str == 'l' ? ST_LONGER : ST_LONG);
}
for (i = 0; fmts[i].f; i++)
if (fmts[i].f == *ctx->str)
fmts[i].func(ctx, *ctx->str, &args);
ctx->str++;
}
}
int _isalnum(
int ch
)
{
int ret = 0;
if (_isalpha(ch) || _isdigit(ch))
ret = ch;
return ret;
}
//check if all the characters are digit or not
static int _isalldigit(char *str)
{
char *p = str;
assert(str && "null string!");
while (*p != '\0')
{
if (_isdigit(*p) == 0)
return 0;
++p;
}
return (p != str) ? 1 : 0;
}
int _isxdigit(
int ch
)
{
int ret = 0;
if (_isdigit(ch) ||
('a' <= ch && ch <= 'f') ||
('A' <= ch && ch <= 'Z'))
ret = ch;
return ret;
}
int _to_xdigit(
int ch
)
{
int ret;
if (_isdigit(ch))
ret = ch - '0';
else if (_isxdigit(ch))
ret = _to_lower(ch) - 'a' + 0xa;
return ret;
}
int minscanf(char *fmt, ...)
{
int c, cnt = 0;
va_list ap;
char *p;
int *intp;
char inputstr[MAXWORD];
char d[MAXWORD];
char *dp, *argsp;
char *sp = inputstr;
while ((c = getchar()) != EOF && c != '\n')
*sp++ = c;
*sp = '\0';
sp = inputstr;
va_start(ap, fmt);
for (p = fmt; *p; p++) {
if (*p != '%') {
continue;
}
switch (*++p) {
case 'd':
intp = va_arg(ap, int *);
dp = d;
while (_isspace(*sp))
sp++;
while (_isdigit(*sp))
*dp++ = *sp++;
*dp = '\0';
*intp = _atoi(d);
cnt++;
break;
case 's':
argsp = va_arg(ap, char *);
while (_isspace(*sp))
sp++;
while (!_isspace(*sp))
*argsp++ = *sp++;
*argsp = '\0';
cnt++;
break;
default:
break;
}
}
va_end(ap);
return cnt;
}
static int convert(const char c) {
if (_isdigit(c)) return (c - '0');
if (_isvalidchar(c)) {
if (_islower(c)) {
// 'a' is 97 => 97 - 87 => 10
return (c - 87);
} else {
// 'A' is 65
return (c - 55);
}
}
return 0;
}
_CODE_ACCESS int atoi(const char *st)
{
int result = 0;
char cp;
int sign;
while (_isspace(*st)) ++st; /* SKIP WHITE SPACE */
if (sign = ((cp = *st) == '-')) cp = *++st;
else if (cp == '+') cp = *++st;
while (_isdigit(cp))
{
result *= 10;
result += cp - '0';
cp = *++st;
}
if (sign) result *= -1;
return result;
}
int _isndigit(
int ch
)
{
return !_isdigit(ch);
}
int _isnnumeric(
int ch
)
{
return !_isdigit(ch);
}
_CODE_ACCESS int iswdigit(wint_t c)
{ return (c == WEOF || (char)c != c) ? 0 : _isdigit((char)c); }
_CODE_ACCESS unsigned long strtoul(const char *st, char **endptr, int base)
{
register unsigned long result = 0;
register char cp;
register const char *fst = st;
int digits = 0;
int minus = 0;
while (_isspace(*fst)) ++fst; /* SKIP WHITE SPACE */
if (base > 36) base = 0;
if ((cp = *fst) == '+') cp = *++fst;
else if ((cp = *fst) == '-') { cp = *++fst; minus = 1; }
/*-------------------------------------------------------------------*/
/* DETERMINE BASE IF ZERO BASE ASKED FOR. */
/*-------------------------------------------------------------------*/
switch (base)
{
case 0 : if (cp != '0') base = 10;
else if ((cp = *++fst) == 'x' || cp == 'X')
if (_isxdigit(fst[1])) { base = 16; cp = *++fst; }
else { base = 10; cp = *--fst; }
else
{
base = 8;
if (cp < '0' || cp > '7') cp = *--fst;
}
break;
case 16 : if (cp == '0' && ((fst[1] == 'x') || (fst[1] == 'X')) &&
_isxdigit(fst[2]))
cp = *(fst += 2);
}
/*-------------------------------------------------------------------*/
/* CONVERT THE NUMBER USING THE SPECIFIED BASE. */
/*-------------------------------------------------------------------*/
for (;; cp = *++fst)
{
register unsigned long addval;
if (!((_isdigit(cp) && (addval = cp - '0') < base) ||
(_isupper(cp) && (addval = cp - 'A' + 10) < base) ||
(_islower(cp) && (addval = cp - 'a' + 10) < base))) break;
if (result == (addval = (result * base + addval))/base) result = addval;
else
{
errno = ERANGE;
if (endptr) *endptr = (char *)st;
return ULONG_MAX;
}
digits++;
}
/*-------------------------------------------------------------------*/
/* MARK THE END OF THE CONVERTED INPUT. */
/*-------------------------------------------------------------------*/
if (endptr) *endptr = (char *)(digits ? fst : st);
return minus ? -result : result;
}
void debug_printf(const char *fmt, ...) {
va_list ap;
enum printf_state state = STATE_COPY;
char buf[64], *p;
char charpad = ' ';
int numpad = 0;
va_start(ap, fmt);
for (; *fmt != '\0'; fmt++) {
if (state == STATE_COPY) {
if (*fmt == '%') {
state = STATE_FORMAT;
numpad = 0;
continue;
} else {
uart_putc(*fmt);
continue;
}
} else if (state == STATE_FORMAT && (*fmt == ' ' || *fmt == '0')) {
state = STATE_PADDING;
charpad = *fmt;
continue;
} else if (state == STATE_PADDING) {
if (_isdigit(*fmt)) {
numpad = numpad*10 + _char2digit(*fmt);
continue;
} else {
state = STATE_FORMAT;
}
}
if (state == STATE_FORMAT) {
if (*fmt == '%') {
p = "%";
numpad = 0;
} else if (*fmt == 'b') {
uint32_t value = va_arg(ap, uint32_t);
p = format32_unsigned(buf, sizeof(buf), value, 2, "01");
numpad -= strlen(p);
} else if (*fmt == 'x') {
uint32_t value = va_arg(ap, uint32_t);
p = format32_unsigned(buf, sizeof(buf), value, 16, "0123456789abcdef");
numpad -= strlen(p);
} else if (*fmt == 'X') {
uint32_t value = va_arg(ap, uint32_t);
p = format32_unsigned(buf, sizeof(buf), value, 16, "0123456789ABCDEF");
numpad -= strlen(p);
} else if (*fmt == 'd') {
int32_t value = va_arg(ap, int32_t);
p = format32_signed(buf, sizeof(buf), value, 10, "0123456789");
numpad -= strlen(p);
} else if (*fmt == 'u') {
uint32_t value = va_arg(ap, uint32_t);
p = format32_unsigned(buf, sizeof(buf), value, 10, "0123456789");
numpad -= strlen(p);
} else if (*fmt == 'p') {
uintptr_t value = va_arg(ap, uintptr_t);
p = format32_unsigned(buf, sizeof(buf), value, 16, "0123456789abcdef");
charpad = '0';
numpad = 8 - strlen(p);
} else if (*fmt == 'c') {
char value = va_arg(ap, int);
buf[0] = value;
buf[1] = '\0';
p = buf;
numpad = 0;
} else if (*fmt == 's') {
char *value = va_arg(ap, char *);
p = value;
numpad = 0;
} else {
void getd(char *t, char *s)
{
while (_isdigit(*s))
*t++ = *s++;
*t = '\0';
}
static unsigned long _strtoxl_asc(
const char *nptr,
char **endptr,
register int base,
int flags
)
{
register const char *n_ptr = nptr;
register char c;
register unsigned long number = 0;
register unsigned digval;
register unsigned long maxval;
c = *n_ptr++;
while (_isspace(*n_ptr))
c = *n_ptr++;
if (c == '-') {
flags |= FL_NEG;
c = *n_ptr++;
}
else if(c == '+')
c = *n_ptr++;
if(base < 0 || base > 36 || base == 1) {
if (endptr)
*endptr = nptr;
return 0L;
} else if(base == 0) {
if (c != '0')
base = 10;
else if (*n_ptr == 'x' || *n_ptr == 'X')
base = 16;
else
base = 8;
} else if (base == 16) {
if (c == '0' && (*n_ptr == 'x' || *n_ptr == 'X')) {
++n_ptr;
c = *n_ptr++;
}
}
maxval = _ULONG_MAX / base;
for (;;) {
if (_isdigit((int)(unsigned char)c))
digval = c - '0';
else if (_isalpha((int)(unsigned char)c))
digval = _to_upper(c) & 0xf + 10;
else
break;
if (digval >= (unsigned)base) break;
flags |= FL_READDIGIT;
if (number < maxval || (number == maxval
&& (unsigned long)digval <= _ULONG_MAX %base)) {
number = number * base + digval;
} else {
flags |= FL_OVERFLOW;
if (endptr == _NULL)
break;
}
c = *n_ptr++;
}
--n_ptr;
if (!(flags & FL_READDIGIT))
{
if (endptr)
n_ptr = nptr;
number = 0L;
}
else if ((flags & FL_OVERFLOW) ||
(!(flags & FL_UNSIGNED) &&
(((flags & FL_NEG) && (number > -_LONG_MIN)) ||
(!(flags & FL_NEG) && (number > _LONG_MAX)))))
{
if (flags & FL_UNSIGNED)
number = _ULONG_MAX;
else if (flags & FL_NEG)
number = (unsigned long)(-_LONG_MIN);
else
number = _LONG_MAX;
}
if (endptr != _NULL)
*endptr = n_ptr;
if (flags & FL_NEG)
number = (unsigned long)(-(long)number);
return number;
}
_CODE_ACCESS long double strtold(const char *st, char **endptr)
{
long double result = 0.0L;
char cp;
const char *fst = st;
int exp = 0; /* EXPONENT */
int count; /* EXPONENT CALCULATION */
int value = 0; /* SUCCESSFUL PARSE */
int sign;
int plus_or_minus = 0; /* READ IN EXPONENT SIGN (+/-) */
while (_isspace(*fst)) ++fst; /* SKIP WHITE SPACE */
if ((sign = ((cp = *fst) == '-')) || (cp == '+')) { ++fst; value = 1; }
/*----------------------------------------------------------------------*/
/* READ IN FRACTIONAL PART OF NUMBER, UNTIL AN 'E' IS REACHED. */
/* COUNT DIGITS AFTER DECIMAL POINT. */
/*----------------------------------------------------------------------*/
for (; _isdigit(cp = *fst); ++fst)
{
result = result * 10 + digits[cp - '0'];
value = 1;
}
if (cp == '.') {
while (_isdigit(cp = *++fst))
{
result = result * 10 + digits[cp - '0'];
value = 1;
--exp;
}
}
if (sign) result = -result; /* IF NEGATIVE NUMBER, REVERSE SIGN */
/*----------------------------------------------------------------------*/
/* READ IN EXPLICIT EXPONENT AND CALCULATE REAL EXPONENT. */
/* IF EXPONENT IS BOGUS (i.e. "1.234empty" or "1.234e+mpty") RESTORE */
/* BOGUS EXPONENT BACK ONTO RETURNED STRING (endptr). */
/*----------------------------------------------------------------------*/
if (value && _toupper(*fst) == 'E')
{
if ((sign = ((cp = *++fst) == '-')) || (cp == '+'))
{
cp = *++fst;
plus_or_minus = 1;
}
if (!_isdigit(cp))
{
if (plus_or_minus) *--fst;
*--fst;
goto skip_loop;
}
for (count = 0; _isdigit(cp); cp = *++fst)
{
if ((INT_MAX - abs(exp) - (cp - '0')) / 10 > count)
{
count *= 10;
count += cp - '0';
} else
{
count = INT_MAX - exp;
break;
}
}
skip_loop:
if (sign) exp -= count;
else exp += count;
}
/*----------------------------------------------------------------------*/
/* ADJUST NUMBER BY POWERS OF TEN SPECIFIED BY FORMAT AND EXPONENT. */
/*----------------------------------------------------------------------*/
if (result != 0.0)
{
if (exp > LDBL_MAX_10_EXP)
{ errno = ERANGE; result = (result < 0) ? -HUGE_VALL : HUGE_VALL; }
else if (exp < LDBL_MIN_10_EXP)
{ errno = ERANGE; result = 0.0; }
else if (exp < 0) {
for (count = 0, exp = -exp; exp; count++, exp >>= 1)
{ if (exp & 1) result /= powerof10[count]; }
}
else {
for (count = 0; exp; count++, exp >>= 1)
{ if (exp & 1) result *= powerof10[count]; }
}
}
int isdigit(int c) {
return _isdigit(c);
}
BOOL process_costume(const CHAR *target, CHAR *source, const CHAR *format)
{
pcostumex variables, selected, temp, last_var;
pcostumestrx strvariables, strselected, strtemp, strlast_var;
PCHAR pointer;
char *_temp;
int count, value;
BOOL ifcon;
CHAR *srcptr;
pointer = format;
srcptr = source;
ifcon = FALSE;
last_var = variables = costume_init();
strlast_var = strvariables = costumestr_init();
selected = NULL, strselected = NULL;
for (; *pointer != _COTM_OPEN && *pointer; pointer++)
;
if (*pointer == '\0')
return _CTOM_ERROR_NOT_EXIST_FORAMT;
pointer++;
do {
switch (*pointer++)
{
case _COTM_CLOSE:
costume_release(variables);
return _CTOM_SUCCESS; // end
case _COTM_FUNCTION: // function call @var=%func%
if (selected == NULL)
return _CTOM_ERROR_FUNCTIONCALL_BEFOR_LVALUE;
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; *pointer && *pointer != _COTM_FUNCTION; pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
pointer++; // *pointer is pointer to '%'
if(ifcon == FALSE){
// no-operate error
selected->data = _costume_process_function(variables, _temp, target);
selected = NULL; // abort selected variable
}
break;
case _COTM_VARIABLE: // @asdf, @asdf=
temp = costume_init();
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL != (selected = _costume_find_variable(variables, _temp)))
if(ifcon == FALSE){
return _CTOM_ERROR_ALREADY_EXIST_VARIABLE;
} else;
if(ifcon == FALSE){
temp->name = _temp;
last_var->_Next = temp;
last_var = temp;
}
if(*pointer == _COTM_LVALUE) {
selected = temp;
pointer++;
}
break;
case _COTM_STRVARIABLE: // $asdf, $asdf="~~~"
strtemp = costumestr_init();
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL != (strselected = _costume_find_strvariable(strvariables, _temp)))
if(ifcon == FALSE){
return _CTOM_ERROR_ALREADY_EXIST_VARIABLE;
} else;
if(ifcon == FALSE){
strtemp->name = _temp;
strlast_var->_Next = strtemp;
strlast_var = strtemp;
}
if(*pointer == _COTM_LVALUE) {
strselected = strtemp;
pointer++;
}
break;
case _COTM_IF:
if (*pointer++ != _COTM_BRET_OPEN)
return _CTOM_ERROR_NOT_FOUND_IF_SCOPE;
value = _costume_if(variables, pointer);
if (value)
ifcon = FALSE;
else
ifcon = TRUE;
pointer = _costume_ict;
if (*pointer == _COTM_BRET_CLOSE)
pointer++;
else
return _CTOM_ERROR_NOT_FOUND_SCOPE_CLOSE;
break;
case _COTM_ELSE:
if (ifcon == FALSE)
ifcon = TRUE;
else
ifcon = FALSE;
break;
case _COTM_DELIMITER:
ifcon = FALSE;
break;
case _COTM_SHARP:
switch(*pointer++)
{
case '#': *srcptr++ = '0'; *srcptr++ = 'x'; break;
}
break;
case _COTM_OPTIONS: // add function
switch(*pointer++)
{
case 'n': *srcptr++ = '\n'; break;
case 'r': *srcptr++ = '\r'; break;
case 't': *srcptr++ = '\t'; break;
case 'f': *srcptr++ = '\f'; break;
default: *srcptr++ = *(pointer-1); break;
}
break;
case _COTM_CONNECTION:
switch(*pointer++)
{
case _COTM_VARIABLE:
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL == (selected = _costume_find_variable(variables, _temp)))
return _CTOM_ERROR_NOT_FOUND_VARIABLE;
free(_temp);
if(ifcon == FALSE){
_temp = __itoa(selected->data);
for (; *_temp; _temp++)
*srcptr++ = *_temp;
}
selected = NULL;
break;
case _COTM_STRVARIABLE:
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL == (strselected = _costume_find_strvariable(strvariables, _temp)))
return _CTOM_ERROR_NOT_FOUND_VARIABLE;
free(_temp);
if(ifcon == FALSE){
_temp = strselected->data;
for (; *_temp; _temp++)
*srcptr++ = *_temp;
}
strselected = NULL;
break;
default:
return _CTOM_ERROR_NOT_EXIST_FORAMT;
}
break;
default:
if(selected != NULL || strselected != NULL) {
pointer--; // for 'pointer++'
if(*pointer == _COTM_STRDELIMITER) {
if (strselected == NULL)
return _CTOM_ERROR_STRINGPTR_BEFOR_LVALUE;
pointer++;
_temp = (char *)malloc(sizeof(char) * 256);
for (count = 0; *pointer != _COTM_STRDELIMITER; pointer++, count++)
if(*pointer == _COTM_OPTIONS) {
pointer++;
_temp[count] = *pointer;
} else {
_temp[count] = *pointer;
}
_temp[count] = 0;
pointer++;
if(ifcon == FALSE){
strselected->data = _temp;
strselected = NULL;
}
break;
} else if(*pointer == _COTM_PAREN_OPEN) {
if (strselected == NULL)
return _CTOM_ERROR_STRINGPTR_BEFOR_LVALUE;
pointer++;
_temp = _costume_get_string(strvariables, variables, target, pointer);
pointer = ++_costume_ict;
if(ifcon == FALSE){
strselected->data = _temp;
}
break;
} else {
if (selected == NULL)
return _CTOM_ERROR_INTEGERPTR_BEFOR_LVALUE;
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isdigit(*pointer); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if(ifcon == FALSE){
selected->data = _atoi(_temp);
selected = NULL;
}
break;
}
} else
return _CTOM_ERROR_NOT_FOUND_OPTION;
}
} while (*pointer);
return _CTOM_SUCCESS;
}
size_t
houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size)
{
size_t i = 0;
if (size >= 3 && src[0] == '#') {
int codepoint = 0;
int num_digits = 0;
if (_isdigit(src[1])) {
for (i = 1; i < size && _isdigit(src[i]); ++i) {
codepoint = (codepoint * 10) + (src[i] - '0');
if (codepoint >= 0x110000) {
// Keep counting digits but
// avoid integer overflow.
codepoint = 0x110000;
}
}
num_digits = i - 1;
}
else if (src[1] == 'x' || src[1] == 'X') {
for (i = 2; i < size && _isxdigit(src[i]); ++i) {
codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
if (codepoint >= 0x110000) {
// Keep counting digits but
// avoid integer overflow.
codepoint = 0x110000;
}
}
num_digits = i - 2;
}
if (num_digits >= 1 && num_digits <= 8 &&
i < size && src[i] == ';') {
if (codepoint == 0 ||
(codepoint >= 0xD800 && codepoint < 0xE000) ||
codepoint >= 0x110000) {
codepoint = 0xFFFD;
}
utf8proc_encode_char(codepoint, ob);
return i + 1;
}
}
else {
if (size > MAX_WORD_LENGTH)
size = MAX_WORD_LENGTH;
for (i = MIN_WORD_LENGTH; i < size; ++i) {
if (src[i] == ' ')
break;
if (src[i] == ';') {
const struct html_ent *entity = find_entity((char *)src, i);
if (entity != NULL) {
int len = 0;
while (len < 4 && entity->utf8[len] != '\0') {
++len;
}
cmark_strbuf_put(ob, entity->utf8, len);
return i + 1;
}
break;
}
}
}
return 0;
}
int console_putchar(int c)
{
static short saved_x = 0;
static short saved_y = 0;
static int esc_seq = 0;
static int esc_num = 0;
static int prefix_pit = 0;
static int esc_arg[MAX_ESC_ARGS + 1];
c &= 0xff;
if (esc_seq == 1) {
if (c == '[') {
esc_seq++;
esc_num = 0;
prefix_pit = 0;
} else
esc_seq = 0;
return 0;
} else if (esc_seq) {
if (_isdigit(c)) {
if (!esc_num) {
esc_num = (esc_num + 1) % MAX_ESC_ARGS;
if (esc_num == 0) esc_num++;
esc_arg[esc_num] = 0;
}
esc_arg[esc_num] = esc_arg[esc_num] * 10 + (c - '0');
return 0;
} else {
if (c == ';') {
esc_num = (esc_num + 1) % MAX_ESC_ARGS;
if (esc_num == 0) esc_num++;
esc_arg[esc_num] = 0;
return 0;
}
switch (c) {
case '?':
if (prefix_pit)
break;
prefix_pit = 1;
return 0;
case 'h':
if (prefix_pit && esc_arg[1] == 25)
screen_cursor_enable(1);
break;
case 'l':
if (prefix_pit && esc_arg[1] == 25)
screen_cursor_enable(0);
break;
case 'm':
set_attributes(esc_num, esc_arg);
break;
case 'H':
case 'f':
if (esc_num > 1) {
con_y = esc_arg[1] - 1;
con_x = esc_arg[2] - 1;
}
break;
case 'A':
con_y -= (esc_num >= 1)?esc_arg[1]:1;
break;
case 'B':
con_y += (esc_num >= 1)?esc_arg[1]:1;
break;
case 'C':
con_x += (esc_num >= 1)?esc_arg[1]:1;
break;
case 'D':
con_x -= (esc_num >= 1)?esc_arg[1]:1;
break;
case 'J':
if (esc_num >= 1) {
con_x = 0;
con_y = 0;
screen_clear();
}
break;
case 'K':
break;
case 's':
saved_x = con_x;
saved_y = con_y;
break;
case 'u':
con_x = saved_x;
con_y = saved_y;
break;
}
esc_seq = 0;
}
if (con_x < 0) con_x = 0;
if (con_x >= con_width) con_x = con_width - 1;
if (con_y < 0) con_y = 0;
if (con_y >= con_height) con_y = con_height - 1;
} else {
if (c == '\n') {
con_y++;
/* con_x = 0; */
} else if (c == '\r')
con_x = 0;
else if (c == '\t')
con_x += CON_TAB_WIDTH;
else if (c == 0x1b) {
esc_seq = 1;
return 0;
} else
screen_putchar(c, con_x++, con_y);
}
if (con_x >= con_width) {
con_x = 0;
con_y++;
}
if (con_y == con_height) {
con_y--;
/* vertical scroll */
screen_scroll_up();
}
screen_cursor(con_x, con_y);
return 0;
}
_CODE_ACCESS long long strtoll(const char *st, char **endptr, int base)
{
register unsigned long long result = 0;
register unsigned int uns_base;
register char cp;
register const char *fst = st;
int digits = 0;
unsigned long long sign = 0;
unsigned long long max_prev_result;
unsigned long long max_curr_addval;
unsigned long long range_limit;
while (_isspace(*fst)) ++fst; /* SKIP WHITE SPACE */
if ((cp = *fst) == '-')
{
sign = 1;
cp = *++fst;
}
else if (cp == '+') cp = *++fst;
if (base > 36) base = 0;
/*-------------------------------------------------------------------*/
/* DETERMINE BASE IF ZERO BASE ASKED FOR. */
/*-------------------------------------------------------------------*/
switch (base)
{
case 0 : if (cp != '0') base = 10;
else if ((cp = *++fst) == 'x' || cp == 'X')
if (_isxdigit(fst[1])) { base = 16; cp = *++fst; }
else { base = 10; cp = *--fst; }
else
{
base = 8;
if (cp < '0' || cp > '7') cp = *--fst;
}
break;
case 16 : if (cp == '0' && ((fst[1] == 'x') || (fst[1] == 'X')) &&
_isxdigit(fst[2]))
cp = *(fst += 2);
}
/*-------------------------------------------------------------------*/
/* DETERMINE VALUES NEEDED TO DETECT RANGE ERROR. THE MAX UNSIGNED */
/* VALUE THAT IS IN RANGE IS BASED ON THE SIGN OF THE INPUT STRING: */
/* sign == 1 - RESULT WILL BE NEGATIVE, SO MUST BE <= LLONG_MAX+1 */
/* sign == 0 - RESULT WILL BE POSITIVE, SO MUST BE <= LLONG_MAX */
/* SO range_limit is LLONG_MAX + sign. */
/* */
/* ALSO NEED max_prev_result AND max_curr_addval WHERE: */
/* max_prev_result * uns_base + max_curr_addval == range_limit */
/* */
/* THIS ALLOWS US TO TEST FOR RANGE ERROR BEFORE WE COMPUTE THE NEXT */
/* RESULT. WE HAVE TWO CASES: */
/* - PREVIOUS result IS GREATER THAN max_prev_result, SO NEXT */
/* RESULT MUST BE OUT OF RANGE. */
/* - PREVIOUS result IS EQUAL TO max_prev_result, SO NEXT RESULT */
/* IS OUT OF RANGE IF addval > max_curr_addval. */
/*-------------------------------------------------------------------*/
uns_base = (unsigned int) base;
range_limit = (unsigned long long)LLONG_MAX + sign;
max_prev_result = range_limit / uns_base;
max_curr_addval = range_limit % uns_base;
/*-------------------------------------------------------------------*/
/* CONVERT THE NUMBER USING THE SPECIFIED BASE. */
/*-------------------------------------------------------------------*/
for (;; cp = *++fst)
{
register unsigned long long addval;
if (!((_isdigit(cp) && (addval = cp - '0') < uns_base) ||
(_isupper(cp) && (addval = cp - 'A' + 10) < uns_base) ||
(_islower(cp) && (addval = cp - 'a' + 10) < uns_base))) break;
/*--------------------------------------------------------------*/
/* CHECK OVERFLOW STATUS BEFORE COMPUTATION. */
/* result CONTAINS THE RESULT OF THE PREVIOUS COMPUTATION */
/*--------------------------------------------------------------*/
if (result > max_prev_result ||
(result == max_prev_result && addval > max_curr_addval))
{
/* SET ERRNO */
errno = ERANGE;
if (endptr) *endptr = (char *)st;
return sign ? LLONG_MIN : LLONG_MAX;
}
/*--------------------------------------------------------------*/
/* COMPUTE NEXT RESULT. */
/*--------------------------------------------------------------*/
result = result * uns_base + addval;
digits++;
}
/*-------------------------------------------------------------------*/
/* MARK THE END OF THE CONVERTED INPUT. NEGATE THE RESULT IF A */
/* MINUS SIGN WAS SEEN. */
/*-------------------------------------------------------------------*/
if (endptr) *endptr = (char *)(digits ? fst : st);
if (sign)
return (long long)-result;
return (long long)result;
}
