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
}
