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