bool JstrChecker::IS_SCALAR(const wstring &str, ScalarCat &cat, wstring &vstr, Number &vnmbr, bool &vbln) { if (IS_STRING(str, vstr)) { cat = ScalarCat::SC_STRING; return true; } if (IS_NUMBER(str, vnmbr)) { cat = ScalarCat::SC_NUMBER; return true; } if (IS_BOOLEAN(str, vbln)) { cat = ScalarCat::SC_BOOLEAN; return true; } if (IS_NULL(str)) { cat = ScalarCat::SC_NULL; return true; } return false; }
/* try to match a number */ token_t lex_nextNumber(LexState* ls, char c0) { uint16_t number = 0; int cx = c0; uint8_t i; for (i=0; i<7; i++) { if (IS_NUMBER(cx)) { number *= 10; number += cx - '0'; cx = fgetc(ls->src); } else { ungetc(cx, ls->src); break; } } ls->kf.number = number; return TK_NUMBER; }
static void gst_asm_scan_number (GstASMScan * scan) { gchar ch; gint i = 0; gboolean have_float = FALSE; ch = THIS_CHAR (scan); /* real strips all spaces that are not inside quotes for numbers */ while ((IS_NUMBER (ch) || IS_SPACE (ch))) { if (i < (MAX_RULE_LENGTH - 1) && !IS_SPACE (ch)) scan->val[i++] = ch; if (ch == '.') have_float = TRUE; ch = NEXT_CHAR (scan); } scan->val[i] = '\0'; if (have_float) scan->token = GST_ASM_TOKEN_FLOAT; else scan->token = GST_ASM_TOKEN_INT; }
/* try to match the next word. Returns a keyword if the next word is a keyword */ token_t lex_nextWord(LexState* ls, char c0) { int cx = c0, i = 0; if (!IS_LETTER(cx)) { ungetc(cx, ls->src); return lex_error(ls, ERR_UNEXPECTED_INPUT); } ls->kf.name = (char*) (ls->kf.name ? realloc(ls->kf.name, NAME_SIZE_INIT) : malloc(NAME_SIZE_INIT)); if (!ls->kf.name) { ls->error = ERR_OUT_OF_MEMORY; ls->kf.name_size = 0; return TK_NONE; } ls->kf.name_size = NAME_SIZE_INIT; do { ls->kf.name[i++] = cx; if (i >= ls->kf.name_size) { ls->kf.name = (char*)realloc(ls->kf.name, i+1); ls->kf.name_size = i+1; } cx = fgetc(ls->src); } while (cx != EOF && (IS_LETTER(cx) || IS_NUMBER(cx))); ungetc(cx, ls->src); ls->kf.name[i] = 0; int kw; for (kw=TOK_FIRST_KW; kw<=TOK_LAST_KW; kw++) if (strlen(lex_getKeywordString(kw)) == i && strncmp(ls->kf.name, lex_getKeywordString(kw), i) == 0) return kw; return TK_NAME; }
static enum Status next_status(enum Status current_status, char ch) { enum Status next_status; if ('\n' == ch) return STATUS_PUNCTUATION; else if (STATUS_COMMENTS == current_status) return STATUS_COMMENTS; if (IS_LETTER(ch)) next_status = STATUS_LETTER; else if ('.' == ch) next_status = STATUS_PRAGMA; else if (IS_PUNCTUATION(ch)) next_status = STATUS_PUNCTUATION; else if (IS_NUMBER(ch)) next_status = STATUS_NUMBER; else if (IS_BLANK(ch)) next_status = STATUS_BLANK; else if (IS_COMMENTS(ch)) next_status = STATUS_COMMENTS; else next_status = STATUS_INVALID; return next_status; }
static int def_is_number(const CONF *conf, char c) { return IS_NUMBER(conf, c); }
char *r_bin_demangle_swift(const char *s, int syscmd) { #define STRCAT_BOUNDS(x) if ((x + 2 + strlen (out)) > sizeof (out)) break; char out[1024]; int i, len, is_generic = 0; int is_first = 1; int is_last = 0; int retmode = 0; if (!strncmp (s, "imp.", 4)) s = s + 4; if (!strncmp (s, "reloc.", 6)) s = s + 6; if (*s != 'T' && strncmp (s, "_T", 2) && strncmp (s, "__T", 3)) { return NULL; } if (!strncmp (s, "__", 2)) s = s + 2; #if 0 const char *element[] = { "module", "class", "method", NULL }; #endif const char *attr = NULL; const char *attr2 = NULL; const char *q, *p = s; const char *q_end = p + strlen (p); if (strchr (s, '\'') || strchr (s, ' ')) { return NULL; } if (syscmd) { char *res = swift_demangle_cmd (s); if (res) { return res; } } out[0] = 0; const char *tail = NULL; if (p[0]) { switch (p[1]) { case 'W': switch (p[2]) { case 'a': tail = "..protocol"; break; } break; case 'F': switch (p[2]) { case 'e': tail = "..extension"; p += 2; break; } break; case 'M': switch (p[2]) { case 'a': tail = "..accessor.metadata"; break; case 'e': tail = "..override"; break; case 'm': tail = "..metaclass"; break; case 'L': tail = "..lazy.metadata"; break; default: tail = "..metadata"; break; } break; case 'I': // interfaces /* TODO */ break; } } p += (tail? 1: 2); // XXX q = getnum (p, NULL); // _TF or __TW if (IS_NUMBER (*p) || *p == 'v' || *p == 'I' || *p == 'o' || *p == 'T' || *p == 'V' || *p == 'M' || *p == 'C' || *p == 'F' || *p == 'W') { if (!strncmp (p+1, "SS", 2)) { strcat (out, "Swift.String.init ("); p += 3; } if (!strncmp (p, "vdv", 3)) { tail = "..field"; p += 3; } if (!strncmp (p, "oFC", 3)) { tail = "..init.witnesstable"; p += 4; } #if 0 if (!strncmp (p+1, "C", 2)) { strcat (out, "class "); p += 3; } #endif q = getnum (q, &len); q = numpos (p); //printf ("(%s)\n", getstring (p, (q-p))); for (i = 0, len = 1; len && q < q_end; q += len, i++) { if (*q == 'P') { // printf ("PUBLIC: "); q++; } q = getnum (q, &len); if (!len) break; const char *str = getstring (q, len); if (len == 2 && !strcmp (str, "ee")) { strcat (out, "Swift"); } else { #if 0 printf ("%s %d %s\n", element[i], len, getstring (q, len)); #endif // push string if (i && *out) strcat (out, "."); STRCAT_BOUNDS (len); len = R_MIN (len, strlen (q)); strcat (out, getstring (q, len)); } } if (q > q_end) { return 0; } p = resolve (flags, q, &attr); if (!p && ((*q == 'U') || (*q == 'R'))) { p = resolve (metas, q, &attr); if (attr && *q == 'R') { attr = NULL; q += 3; //q = p + 1; // //printf ("Template (%s)\n", attr); } else { //printf ("Findus (%s)\n", q); } // return 0; } /* parse accessors */ if (attr) { int len = 0; const char *name; /* get field name and then type */ resolve (types, q, &attr); //printf ("Accessor: %s\n", attr); q = getnum (q + 1, &len); name = getstring (q, len); #if 0 if (name && *name) { printf ("Field Name: %s\n", name); } #endif if (len < strlen (q)) { resolve (types, q + len, &attr2); } else { resolve (types, q, &attr2); } // printf ("Field Type: %s\n", attr2); do { if (name && *name) { strcat (out, "."); STRCAT_BOUNDS (strlen (name)); strcat (out, name); } if (attr && *attr) { strcat (out, "."); STRCAT_BOUNDS (strlen (attr)); strcat (out, attr); } if (attr2 && *attr2) { strcat (out, "__"); STRCAT_BOUNDS (strlen (attr2)); strcat (out, attr2); } } while (0); if (q && *q == '_') { strcat (out, " -> ()"); } } else { /* parse function parameters here */ // type len value/ for (i = 0; q && q < q_end; i++) { if (*q == 'f') { q++; } switch (*q) { case 's': { int n; const char *Q = getnum (q + 1, &n); strcat (out, getstring (Q, n)); q = Q + n + 1; continue; } break; case 'u': if (!strncmp (q, "uRxs", 4)) { strcat (out, ".."); int n; const char *Q = getnum (q + 4, &n); strcat (out, getstring (Q, n)); q = Q + n + 1; continue; } break; case 'S': // "S0" if (q[1]=='1') q++; switch (q[1]) { case '0': strcat (out, " (self) -> ()"); if (attr) { strcat (out, attr); } //p = q + 7; q = p = q + 1; attr = ""; break; case 'S': // swift string strcat (out, "__String"); break; case '_': // swift string { strcat (out, ".."); int n; const char *Q = getnum (q + 2, &n); strcat (out, getstring (Q, n)); q = Q + n + 1; } continue; break; } break; case 'B': case 'T': case 'I': p = resolve (types, q + 0, &attr); // type if (p && *p && IS_NUMBER (p[1])) { p--; } break; case 'F': strcat (out, " ()"); p = resolve (types, q + 3, &attr); // type break; case 'G': q += 2; //printf ("GENERIC\n"); if (!strncmp (q, "_V", 2)) { q += 2; } p = resolve (types, q, &attr); // type break; case 'V': p = resolve (types, q + 1, &attr); // type break; case '_': // it's return value time! p = resolve (types, q+1, &attr); // type //printf ("RETURN TYPE %s\n", attr); break; default: p = resolve (types, q, &attr); // type } if (p) { q = p; q = getnum (p, &len); if (attr && !strcmp (attr, "generic")) is_generic = 1; //printf ("TYPE: %s LEN %d VALUE %s\n", // attr, len, getstring (q, len)); if (!len) { if (retmode) { if (q + 1 > q_end) { if (attr) { strcat (out, " -> "); STRCAT_BOUNDS (strlen (attr)); strcat (out, attr); } break; } p = resolve (types, q + 1, &attr); // type //printf ("RETURN TYPE %s\n", attr); // printf ("RET %s\n", attr); if (attr) { strcat (out, " -> "); STRCAT_BOUNDS (strlen (attr)); strcat (out, attr); } break; } retmode = 1; len++; } if (len <= (q_end-q) && q[len]) { const char *s = getstring (q, len); if (s && *s) { if (is_first) { strcat (out, is_generic?"<":"("); is_first = 0; } //printf ("ISLAST (%s)\n", q+len); is_last = q[len]; if (attr) { STRCAT_BOUNDS (strlen (attr)); strcat (out, attr); strcat (out, " "); } STRCAT_BOUNDS (strlen (s)); strcat (out, s); if (is_last) { strcat (out, is_generic?">":")"); is_first = (*s != '_'); if (is_generic && !is_first) { break; } } else { strcat (out, ", "); } } else { if (attr) { strcat (out, " -> "); STRCAT_BOUNDS (strlen (attr)); strcat (out, attr); } } } else { if (attr) { strcat (out, " -> "); STRCAT_BOUNDS (strlen (attr)); strcat (out, attr); } } q += len; p = q; } else { if (q) { q++; } else { break; } char *n = strstr (q, "__"); if (n) { q = n + 1; } else { n = strstr (q, "_"); if (n) { q = n + 1; } else { break; } } } } } } else { //printf ("Unsupported type: %c\n", *p); } if (*out) { if (tail) strcat (out, tail); #if 1 char *p, *outstr = strdup (out); p = outstr; for (;;) { p = strstr (p, ")("); if (p) { p[0] = '_'; p[1] = '_'; p+=2; } else break; } return outstr; #endif } return NULL; }
int ftp_client_read_response(struct network_client *client, char *response, size_t size) { int state; ssize_t rwlen; char buff[2048], *p = buff, *p_end = p + sizeof(buff); while (p < p_end) { char *q; rwlen = network_client_timed_recv(client, p, p_end - p, 5000); if (rwlen <= 0) { return -EFAULT; } for (q = p, p += rwlen; q < p; q++) { int step = 0; while (q < p && IS_NUMBER(*q)) { q++; } if (q < p && *q != '-') { step++; } while (q < p) { if (*q == '\n') { step++; break; } q++; } if (step == 2) { goto label_read_complete; } } } label_read_complete: *p = 0; #if FTP_DEBUG print_ntext(buff, p - buff); #endif state = text2value_unsigned(buff, (const char **) &p, 10); if (response && size > 0) { text_ncopy(response, p + 1, size); } return state; }
static gboolean metadatamux_exif_convert_from_datetime (GString * dt) { gboolean ret = TRUE; char *p = dt->str; if (dt->allocated_len < 20) goto error; /* check YYYY */ if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; if (*p == '\0') { sprintf (p, ":01:01 00:00:00"); goto done; } else if (*p == '-') { *p++ = ':'; } else goto error; /* check MM */ if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; if (*p == '\0') { sprintf (p, ":01 00:00:00"); goto done; } else if (*p == '-') { *p++ = ':'; } else goto error; /* check DD */ if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; if (*p == '\0') { sprintf (p, " 00:00:00"); goto done; } else if (*p == 'T') { *p++ = ' '; } else goto error; /* check hh */ if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; if (*p++ != ':') goto error; /* check mm */ if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; if (*p == ':') { p++; } else if (*p == 'Z' || *p == '+' || *p == '-') { /* FIXME: in case of '+' or '-', it would be better to also fill another * EXIF tag in order to save, somehow the time zone info */ sprintf (p, ":00"); goto done; } else goto error; /* check ss */ if (IS_NUMBER (*p)) p++; else goto error; if (IS_NUMBER (*p)) p++; else goto error; *p = '\0'; /* if here, everything is ok */ goto done; error: ret = FALSE; done: /* FIXME: do we need to check if the date is valid ? */ if (ret) dt->len = 19; return ret; }
/* convert: * char *foo = "\x41\x23\x42\x1b"; * into: * 4123421b */ R_API char *r_hex_from_c(const char *code) { const char abc[] = "0123456789abcdefABCDEF"; bool parse_on = false; int parse_mode = 0; char *out, *ret; int is_hexa = 0; if (code) { ret = malloc (strlen (code) * 3); } else { ret = malloc (3); } *ret = 0; out = ret; if (code) { for (;*code; code++) { if (!strncmp (code, "/*", 2)) { /* skip comments */ char *end = strstr (code, "*/"); if (end) { code = end + 1; } else { eprintf ("Missing closing comment\n"); } continue; } if (!strncmp (code, "//", 2)) { char *end = strchr (code, '\n'); if (end) { code = end; } continue; } if (parse_on) { if (*code == '}' || *code == '"') { parse_on = false; // stop parsing after the first string statement break; } } else { if (*code == '{') { parse_mode = *code; for (code++;*code; code++) { if (IS_WHITESPACE (*code)) continue; if (IS_NUMBER (*code)) { parse_on = true; break; } else { parse_on = false; parse_mode = 0; break; } } } } if (parse_on && parse_mode == '{') { char *comma = strchr (code, ','); if (!comma) comma = strchr (code, '}'); if (comma) { char *word = r_str_ndup (code, comma - code); if (IS_NUMBER (*word)) { ut8 n = (ut8)r_num_math (NULL, word); *out++ = abc[(n >> 4) & 0xf]; *out++ = abc[n & 0xf]; } else { parse_on = false; } code = comma; free (word); } } else if (*code == '"') {
void read_next_token(void) { if (token_has_been_peeked) { token_has_been_peeked = false; return; } uint32_t k = 0; do { if (buff[cursor] == 0) { cursor = 0; const char* res = fgets(buff, buff_size, input_source); if (res == 0) { *token = 0; next_token_type = END; return; } } bool is_quoted_string = false; while (buff[cursor] != 0) { if (IS_SPACE(buff[cursor]) && !is_quoted_string) { cursor += 1; break; } if (buff[cursor] == '\"') { // a " character is next is_quoted_string = !is_quoted_string; cursor += 1; } else if (buff[cursor] == '\\') { // a \ character is next switch(buff[cursor+1]) { case 'n': token[k] = '\n'; k += 1; break; case 't': token[k] = '\t'; k += 1; break; case '\\': token[k] = '\\'; k += 1; break; default: break; } cursor += 2; } else { token[k] = buff[cursor]; k += 1; cursor += 1; } } token[k] = 0; } while (k == 0); while (buff[cursor] != 0 && IS_SPACE(buff[cursor])) { cursor += 1; } /* now, set the various parsing flags */ if (IS_NUMBER(token[0])) { next_token_type = NUMBER; token_number_value = atoi(token); } else if (! IS_LETTER(token[0])) { next_token_type = SYMBOL; } else { next_token_type = NAME; } }
int numberp(int addr){ if(IS_NUMBER(addr)) return(1); else return(0); }
int atomp(int addr){ if((IS_NUMBER(addr)) || (IS_SYMBOL(addr))) return(1); else return(0); }
// this function takes a string containing an arithmetic // expression in infix notation and compiles it into an // internal reverse polish notation representation. // which can then easily be evaluated (and re-evaluated) // This is done by first tokenizing the string // and then parse the tokens, converting // the infix notation to rpn. bool Expression::compile(const char *string) { const char *src = string; Vector<Token> tokens; // tokenize it and parse and convert numbers. while(*src) { if(IS_WHITESPACE(*src)) { src++; continue; } switch(*src) { case '(': tokens.add(Token(LPAREN)); break; case ')': tokens.add(Token(RPAREN)); break; case '-': tokens.add(Token(MINUS)); break; case '+': tokens.add(Token(PLUS)); break; case '*': tokens.add(Token(MUL)); break; case '/': tokens.add(Token(DIV)); break; default: if(IS_NUMBER(*src)) { char num[32]; num[0] = *src; src++; char *num_dest = num+1; int numDots = 0; while(IS_NUMBER(*src)||*src=='.') { if(*src=='.') { numDots++; if(numDots>1) { // error printf("wrong amount of dots in constant number."); return false; } } *num_dest = *src; num_dest++; src++; } *num_dest = 0; float i = atof(num); tokens.add(Token(NUMBER, i)); continue; } else if(IS_LETTER(*src)) { char litteral[255]; litteral[0] = *src; src++; char *litteral_dest = litteral+1; while(IS_LETTER(*src)||IS_NUMBER(*src)) { *litteral_dest = *src; litteral_dest++; src++; } *litteral_dest = 0; while(IS_WHITESPACE(*src)) src++; if(*src=='(') { tokens.add(Token(FUNCTION, scope.getFunction(litteral))); src++; } else { tokens.add(Token(VARIABLE, scope.getVariable(litteral))); } continue; } else return false; } src++; } // compile! this is done recursivly rpn.clear(); _compile(0, tokens, rpn); rpn.add(Token(END)); return true; }
*/ REBINT Cmp_Value(REBVAL *s, REBVAL *t, REBFLG is_case) /* ** Compare two values and return the difference. ** ** is_case TRUE for case sensitive compare ** ***********************************************************************/ { REBDEC d1, d2; if (VAL_TYPE(t) != VAL_TYPE(s) && !(IS_NUMBER(s) && IS_NUMBER(t))) return VAL_TYPE(s) - VAL_TYPE(t); switch(VAL_TYPE(s)) { case REB_INTEGER: if (IS_DECIMAL(t)) { d1 = (REBDEC)VAL_INT64(s); d2 = VAL_DECIMAL(t); goto chkDecimal; } return THE_SIGN(VAL_INT64(s) - VAL_INT64(t)); case REB_LOGIC: return VAL_LOGIC(s) - VAL_LOGIC(t); case REB_CHAR: if (is_case) return THE_SIGN(VAL_CHAR(s) - VAL_CHAR(t)); return THE_SIGN((REBINT)(UP_CASE(VAL_CHAR(s)) - UP_CASE(VAL_CHAR(t)))); case REB_DECIMAL: case REB_MONEY: d1 = VAL_DECIMAL(s); if (IS_INTEGER(t)) d2 = (REBDEC)VAL_INT64(t); else d2 = VAL_DECIMAL(t); chkDecimal: if (Eq_Decimal(d1, d2)) return 0; if (d1 < d2) return -1; return 1; case REB_PAIR: return Cmp_Pair(s, t); case REB_EVENT: return Cmp_Event(s, t); case REB_GOB: return Cmp_Gob(s, t); case REB_TUPLE: return Cmp_Tuple(s, t); case REB_TIME: return Cmp_Time(s, t); case REB_DATE: return Cmp_Date(s, t); case REB_BLOCK: case REB_PAREN: case REB_MAP: case REB_PATH: case REB_SET_PATH: case REB_GET_PATH: case REB_LIT_PATH: return Cmp_Block(s, t, is_case); case REB_STRING: case REB_FILE: case REB_EMAIL: case REB_URL: case REB_TAG: return Compare_String_Vals(s, t, (REBOOL)!is_case); case REB_BITSET: case REB_BINARY: case REB_IMAGE: return Compare_Binary_Vals(s, t); case REB_VECTOR: return Compare_Vector(s, t); case REB_DATATYPE: return VAL_DATATYPE(s) - VAL_DATATYPE(t); case REB_WORD: case REB_SET_WORD: case REB_GET_WORD: case REB_LIT_WORD: case REB_REFINEMENT: case REB_ISSUE: return Compare_Word(s,t,is_case); case REB_ERROR: return VAL_ERR_NUM(s) - VAL_ERR_NUM(s); case REB_OBJECT: case REB_MODULE: case REB_PORT: return VAL_OBJ_FRAME(s) - VAL_OBJ_FRAME(t); case REB_NATIVE: return &VAL_FUNC_CODE(s) - &VAL_FUNC_CODE(t); case REB_ACTION: case REB_COMMAND: case REB_OP: case REB_FUNCTION: return VAL_FUNC_BODY(s) - VAL_FUNC_BODY(t); case REB_NONE: case REB_UNSET: case REB_END: default: break; } return 0; }
R_API void r_cons_grep(const char *str) { int wlen, len, is_range, num_is_parsed, fail = 0; ut64 range_begin, range_end; RCons *cons; char buf[R_CONS_GREP_BUFSIZE]; char *ptr, *optr, *ptr2, *ptr3; if (!str || !*str) { return; } cons = r_cons_singleton (); memset (&(cons->grep), 0, sizeof (cons->grep)); sorted_column = 0; cons->grep.sort = -1; cons->grep.line = -1; while (*str) { switch (*str) { case '.': if (str[1] == '.') { cons->grep.less = 1; return; } str++; break; case '{': if (str[1] == '}') { cons->grep.json = 1; if (!strncmp (str, "{}..", 4)) { cons->grep.less = 1; } str++; return; } str++; break; case '$': str++; if (*str == '!') { cons->grep.sort_invert = true; str++; } else { cons->grep.sort_invert = false; } cons->grep.sort = atoi (str); while (IS_NUMBER (*str)) { str++; } if (*str == ':') { cons->grep.sort_row = atoi (++str); str++; } break; case '&': str++; cons->grep.amp = 1; break; case '^': str++; cons->grep.begin = 1; break; case '!': str++; cons->grep.neg = 1; break; case '?': str++; cons->grep.counter = 1; if (*str == '?') { r_cons_grep_help (); return; } break; default: goto while_end; } } while_end: len = strlen (str) - 1; if (len > R_CONS_GREP_BUFSIZE - 1) { eprintf("r_cons_grep: too long!\n"); return; } if (len > 0 && str[len] == '?') { cons->grep.counter = 1; strncpy (buf, str, R_MIN (len, sizeof (buf) - 1)); buf[len]=0; len--; } else { strncpy (buf, str, sizeof (buf) - 1); } if (len > 1 && buf[len] == '$' && buf[len - 1] != '\\') { cons->grep.end = 1; buf[len] = 0; } ptr = buf; ptr2 = strchr (ptr, '['); ptr3 = strchr (ptr, ']'); is_range = 0; num_is_parsed = 0; fail = 0; range_begin = range_end = -1; if (ptr2 && ptr3) { ptr2[0] = '\0'; ptr2++; for (; ptr2 <= ptr3; ++ptr2) { if (fail) { memset (cons->grep.tokens, 0, R_CONS_GREP_TOKENS); cons->grep.tokens_used = 0; fail = 0; break; } switch (*ptr2) { case '-': is_range = 1; num_is_parsed = 0; break; case ']': // fallthrough to handle ']' like ',' case ',': for (; range_begin <= range_end; range_begin++) { if (range_begin >= R_CONS_GREP_TOKENS) { fail = 1; break; } cons->grep.tokens[range_begin] = 1; cons->grep.tokens_used = 1; } is_range = 0; num_is_parsed = 0; break; default: if (!num_is_parsed) { if (is_range) { range_end = r_num_get (cons->num, ptr2); } else { range_begin = range_end = r_num_get (cons->num, ptr2); } num_is_parsed = 1; } } } } ptr2 = strchr (ptr, ':'); // line number cons->grep.range_line = 2; //there is not : if (ptr2 && ptr2[1] != ':') { *ptr2 = '\0'; char *p, *token = ptr + 1; p = strstr (token, ".."); if (!p) { cons->grep.line = r_num_get (cons->num, ptr2 + 1); cons->grep.range_line = 0; } else { *p = '\0'; cons->grep.range_line = 1; if (!*token) { cons->grep.f_line = 0; } else { cons->grep.f_line = r_num_get (cons->num, token); } if (!p[2]) { cons->grep.l_line = -1; } else { cons->grep.l_line = r_num_get (cons->num, p + 2); } } } free (cons->grep.str); if (*ptr) { cons->grep.str = (char *)strdup (ptr); do { optr = ptr; ptr = strchr (ptr, ','); // grep keywords if (ptr) { *ptr++ = '\0'; } wlen = strlen (optr); if (!wlen) { continue; } if (wlen >= R_CONS_GREP_WORD_SIZE - 1) { eprintf ("grep string too long\n"); continue; } strncpy (cons->grep.strings[cons->grep.nstrings], optr, R_CONS_GREP_WORD_SIZE - 1); cons->grep.nstrings++; if (cons->grep.nstrings > R_CONS_GREP_WORDS - 1) { eprintf ("too many grep strings\n"); break; } } while (ptr); } else { cons->grep.str = strdup (ptr); cons->grep.nstrings++; cons->grep.strings[0][0] = 0; } }
static const char *json_strend(ACL_JSON *json, const char *data) { ACL_JSON_NODE *node = json->curr_node; ACL_JSON_NODE *parent; SKIP_SPACE(data); if (*data == 0) return data; #define EQ(x, y) !strcasecmp((x), ((y))) #define IS_NUMBER(x) (acl_alldig((x)) \ || ((*(x) == '-' || *(x) == '+') \ && *((x) + 1) != 0 && acl_alldig((x) + 1))) if (node->parent && node->parent->type == ACL_JSON_T_ARRAY) { if (node->quote == 0) { const char* txt = STR(node->text); if (EQ(txt, "null")) node->type = ACL_JSON_T_A_NULL | ACL_JSON_T_LEAF; else if (EQ(txt, "true") || EQ(txt, "false")) node->type = ACL_JSON_T_A_BOOL | ACL_JSON_T_LEAF; else if (IS_NUMBER(txt)) node->type = ACL_JSON_T_A_NUMBER | ACL_JSON_T_LEAF; else if (acl_is_double(txt)) node->type = ACL_JSON_T_A_DOUBLE | ACL_JSON_T_LEAF; else node->type = ACL_JSON_T_A_STRING | ACL_JSON_T_LEAF; } else node->type = ACL_JSON_T_A_STRING | ACL_JSON_T_LEAF; } else if (node->quote == 0) { const char* txt = STR(node->text); if (EQ(txt, "null")) node->type = ACL_JSON_T_NULL | ACL_JSON_T_LEAF; else if (EQ(txt, "true") || EQ(txt, "false")) node->type = ACL_JSON_T_BOOL | ACL_JSON_T_LEAF; else if (IS_NUMBER(txt)) node->type = ACL_JSON_T_NUMBER | ACL_JSON_T_LEAF; else if (acl_is_double(txt)) node->type = ACL_JSON_T_DOUBLE | ACL_JSON_T_LEAF; else node->type = ACL_JSON_T_STRING | ACL_JSON_T_LEAF; } else node->type = ACL_JSON_T_STRING | ACL_JSON_T_LEAF; if (*data == ',' || *data == ';') { json->status = ACL_JSON_S_NEXT; return data; } parent = acl_json_node_parent(json->curr_node); if (*data != parent->right_ch) { /* xxx */ data++; return data; } data++; if (parent == json->root) { json->finish = 1; return data; } json->curr_node = parent; json->status = ACL_JSON_S_NEXT; return data; }
int tokenize(struct token_list* tk_list, char* file_buffer) { enum Status status; line_num; size_t token_begin, token_end; token_begin = 0, token_end = 0; status = STATUS_INVALID; str_toupper(file_buffer); /* * Careful: it seems an error to let "i <= len", * but we need one more execution to flush the last token into token list. */ size_t line_num = 1; for (size_t i = 0; ; ++i) { struct token_node* tok_node; switch (status) { case STATUS_LETTER: if (!IS_LETTER(file_buffer[i]) && !IS_DIGIT(file_buffer[i])) { token_end = i; tok_node = create_token(TOKEN_LABEL, file_buffer + token_begin, token_end - token_begin); tok_node->type = letter_type(tok_node->liter, tok_node->len); token_append(tk_list, tok_node); token_begin = i; status = next_status(status, file_buffer[i]); } break; case STATUS_PRAGMA: if (!IS_LETTER(file_buffer[i])) { int type; token_end = i; type = pragma_type(file_buffer + token_begin, token_end - token_begin); if (type < 0) { error("invalid pragma ad line %d\n", line_num); return -4; } tok_node = create_token(type, file_buffer + token_begin, token_end - token_begin); token_append(tk_list, tok_node); token_begin = i; status = next_status(status, file_buffer[i]); } break; case STATUS_PUNCTUATION: token_end = i; tok_node = create_token(file_buffer[token_begin], file_buffer + token_begin, token_end - token_begin); token_append(tk_list, tok_node); token_begin = i; status = next_status(status, file_buffer[i]); break; case STATUS_NUMBER: if (!IS_NUMBER(file_buffer[i])) { token_end = i; if (!check_number(file_buffer + token_begin, token_end - token_begin)) { error("invalid number format at line %d\n", line_num); return -2; } tok_node = create_token(TOKEN_NUMBER, file_buffer + token_begin, token_end - token_begin); tok_node->data = parse_number(tok_node->liter); token_append(tk_list, tok_node); token_begin = i; status = next_status(status, file_buffer[i]); } break; case STATUS_BLANK: if (!IS_BLANK(file_buffer[i])) { token_begin = i; status = next_status(status, file_buffer[i]); } break; case STATUS_COMMENTS: //once status is in comments, it will always be in comments if ('\n' == file_buffer[i]) { token_begin = i; status = next_status(status, file_buffer[i]); } break; case STATUS_INVALID: token_begin = i; status = next_status(status, file_buffer[i]); if (STATUS_INVALID == status && 0 != file_buffer[i]) { error("invalid format at line %d\n", line_num); return -3; } break; } if (0 == file_buffer[i]) break; else if ('\n' == file_buffer[i]) ++line_num; } return 0; }
UnicodeGeneralCategoryClass GetGeneralCategoryClass(codepoint_t ch) { #ifndef HAS_REAL_ICU if (IS_CHAR(ch)) { return UnicodeGeneralCategoryClass::CategoryClassLetter; } if (IS_NUMBER(ch)) { return UnicodeGeneralCategoryClass::CategoryClassDigit; } if (ch == 8232) // U+2028 { return UnicodeGeneralCategoryClass::CategoryClassLineSeparator; } if (ch == 8233) // U+2029 { return UnicodeGeneralCategoryClass::CategoryClassParagraphSeparator; } if (IsWhitespace(ch)) { return UnicodeGeneralCategoryClass::CategoryClassSpaceSeparator; } if (ispunct((int)ch)) { return UnicodeGeneralCategoryClass::CategoryClassConnectorPunctuation; } // for the rest of the ``combining chars``, return CategoryClassSpaceSeparator // consider this approach as a fallback mechnanism. // since, this function returns CategoryClassLetter for everything else. if ((ch >= 836 && ch <= 846) || ch == 810) // U+32A || U+346 <= ch <= U+34E { return UnicodeGeneralCategoryClass::CategoryClassSpaceSeparator; } if (ch >= 768 && ch <= 879) // U+300 <= ch <= U+36F (version 1.0) { return UnicodeGeneralCategoryClass::CategoryClassSpaceSeparator; } if (ch >= 6832 && ch <= 6911) // U+1AB0 <= ch <= U+1AFF (version 7.0) { return UnicodeGeneralCategoryClass::CategoryClassSpaceSeparator; } // default to letter since we don't identify unicode letters // xplat-todo: can we do this better? return UnicodeGeneralCategoryClass::CategoryClassLetter; #else // HAS_REAL_ICU int8_t charType = u_charType(ch); if (charType == U_LOWERCASE_LETTER || charType == U_UPPERCASE_LETTER || charType == U_TITLECASE_LETTER || charType == U_MODIFIER_LETTER || charType == U_OTHER_LETTER || charType == U_LETTER_NUMBER) { return UnicodeGeneralCategoryClass::CategoryClassLetter; } if (charType == U_DECIMAL_DIGIT_NUMBER) { return UnicodeGeneralCategoryClass::CategoryClassDigit; } if (charType == U_LINE_SEPARATOR) { return UnicodeGeneralCategoryClass::CategoryClassLineSeparator; } if (charType == U_PARAGRAPH_SEPARATOR) { return UnicodeGeneralCategoryClass::CategoryClassParagraphSeparator; } if (charType == U_SPACE_SEPARATOR) { return UnicodeGeneralCategoryClass::CategoryClassSpaceSeparator; } if (charType == U_COMBINING_SPACING_MARK) { return UnicodeGeneralCategoryClass::CategoryClassSpacingCombiningMark; } if (charType == U_NON_SPACING_MARK) { return UnicodeGeneralCategoryClass::CategoryClassNonSpacingMark; } if (charType == U_CONNECTOR_PUNCTUATION) { return UnicodeGeneralCategoryClass::CategoryClassConnectorPunctuation; } return UnicodeGeneralCategoryClass::CategoryClassOther; #endif // HAS_REAL_ICU }