static void parse_suffixes(w_query* res, const json_ref& query) {
size_t i;
auto suffixes = query.get_default("suffix");
if (!suffixes) {
return;
}
if (suffixes.isString()) {
auto suff = parse_suffix(suffixes);
res->suffixes.emplace_back(std::move(suff));
return;
}
if (!suffixes.isArray()) {
throw QueryParseError("'suffix' must be a string or an array of strings");
}
res->suffixes.reserve(json_array_size(suffixes));
for (i = 0; i < json_array_size(suffixes); i++) {
const auto& ele = suffixes.at(i);
if (!ele.isString()) {
throw QueryParseError("'suffix' must be a string or an array of strings");
}
auto suff = parse_suffix(ele);
res->suffixes.emplace_back(std::move(suff));
}
}
long long parse_size(const char *str)
{
static struct suffix sfx[] = {
{ "", 1 },
{ "b", 1 },
{ "s", 1ll<<9 },
{ "k", 1ll<<10 },
{ "kb", 1ll<<10 },
{ "p", 1ll<<12 },
{ "m", 1ll<<20 },
{ "mb", 1ll<<20 },
{ "g", 1ll<<30 },
{ "gb", 1ll<<30 },
{ "t", 1ll<<40 },
{ "tb", 1ll<<40 },
{ "p", 1ll<<50 },
{ "pb", 1ll<<50 },
{ "e", 1ll<<60 },
{ "eb", 1ll<<60 },
/*
{ "z", 1ll<<70 },
{ "zb", 1ll<<70 },
{ "y", 1ll<<80 },
{ "yb", 1ll<<80 },
*/
{ NULL, 0ll },
};
return parse_suffix(str, sfx);
}
long long parse_time(const char *str)
{
static struct suffix sfx[] = {
{ "us", 1ll },
{ "usec", 1ll },
{ "ms", 1000ll },
{ "msec", 1000ll },
{ "", 1000000ll },
{ "s", 1000000ll },
{ "sec", 1000000ll },
{ "m", 1000000ll * 60 },
{ "min", 1000000ll * 60 },
{ "h", 1000000ll * 60 * 60 },
{ "hour", 1000000ll * 60 * 60 },
{ "day", 1000000ll * 60 * 60 * 24 },
{ "week", 1000000ll * 60 * 60 * 24 * 7 },
{ "month", 1000000ll * 60 * 60 * 24 * 7 * 30 },
{ "year", 1000000ll * 60 * 60 * 24 * 7 * 365 },
{ "century", 1000000ll * 60 * 60 * 24 * 7 * 365 * 100 },
{ "millenium", 1000000ll * 60 * 60 * 24 * 7 * 365 * 1000 },
{ NULL, 0ll },
};
return parse_suffix(str, sfx);
}
/**
* Count the number of characters in a quoted string.
* The next bit of text starts with a quote char " or ' or <.
* Count the number of characters until the matching character.
*
* @param pc The structure to update, str is an input.
* @return Whether a string was parsed
*/
static bool parse_string(tok_ctx& ctx, chunk_t& pc, int quote_idx, bool allow_escape)
{
bool escaped = 0;
int end_ch;
char escape_char = cpd.settings[UO_string_escape_char].n;
char escape_char2 = cpd.settings[UO_string_escape_char2].n;
pc.str.clear();
while (quote_idx-- > 0)
{
pc.str.append(ctx.get());
}
pc.type = CT_STRING;
end_ch = CharTable::Get(ctx.peek()) & 0xff;
pc.str.append(ctx.get()); /* store the " */
while (ctx.more())
{
int ch = ctx.get();
pc.str.append(ch);
if (ch == '\n')
{
pc.nl_count++;
pc.type = CT_STRING_MULTI;
escaped = 0;
continue;
}
if ((ch == '\r') && (ctx.peek() != '\n'))
{
pc.str.append(ctx.get());
pc.nl_count++;
pc.type = CT_STRING_MULTI;
escaped = 0;
continue;
}
if (!escaped)
{
if (ch == escape_char)
{
escaped = (escape_char != 0);
}
else if ((ch == escape_char2) && (ctx.peek() == end_ch))
{
escaped = allow_escape;
}
else if (ch == end_ch)
{
break;
}
}
else
{
escaped = false;
}
}
parse_suffix(ctx, pc, true);
return(true);
}
int parse_size_str(const char *in, size_t in_size, uint64_t *out)
{
int retval;
char int_buf[sizeof("18446744073709551615")];
int chars_copied = copy_numeric(in, in_size, int_buf, sizeof(int_buf));
if (chars_copied == 0)
{
return ERROR_parse_size_str_NO_LEADING_NUMERIC_CHARS;
}
int base = 10;
unsigned long long int size = strtoull(int_buf, NULL, base);
char *suffix_in = (char*)in + chars_copied;
size_t suffix_size = in_size - chars_copied;
suffix_t suffix;
retval = parse_suffix(suffix_in, suffix_size, &suffix);
if (retval < 0) return retval;
uint64_t multiplier = suffix_to_multiplier(&suffix);
// thanks to http://stackoverflow.com/a/199363
bool would_overflow = (multiplier > (UINT64_MAX / size));
if (would_overflow)
{
return ERROR_parse_size_str_WOULD_OVERFLOW_UINT64;
}
*out = size * multiplier;
return RETURN_SUCCESS;
}
/**
* Parses a C++0x 'R' string. R"( xxx )" R"tag( )tag" u8R"(x)" uR"(x)"
* Newlines may be in the string.
*/
static bool parse_cr_string(tok_ctx& ctx, chunk_t& pc, int q_idx)
{
int cnt;
int tag_idx = ctx.c.idx + q_idx + 1;
int tag_len = 0;
ctx.save();
/* Copy the prefix + " to the string */
pc.str.clear();
cnt = q_idx + 1;
while (cnt--)
{
pc.str.append(ctx.get());
}
/* Add the tag and get the length of the tag */
while (ctx.more() && (ctx.peek() != '('))
{
tag_len++;
pc.str.append(ctx.get());
}
if (ctx.peek() != '(')
{
ctx.restore();
return(false);
}
pc.type = CT_STRING;
while (ctx.more())
{
if ((ctx.peek() == ')') &&
(ctx.peek(tag_len + 1) == '"') &&
tag_compare(ctx.data, tag_idx, ctx.c.idx + 1, tag_len))
{
cnt = tag_len + 2; /* for the )" */
while (cnt--)
{
pc.str.append(ctx.get());
}
parse_suffix(ctx, pc);
return(true);
}
if (ctx.peek() == '\n')
{
pc.str.append(ctx.get());
pc.nl_count++;
pc.type = CT_STRING_MULTI;
}
else
{
pc.str.append(ctx.get());
}
}
ctx.restore();
return(false);
} // parse_cr_string
long long parse_int(const char *str)
{
static struct suffix sfx[] = {
{ "", 1ll },
{ "da", 10ll },
{ "k", 1000ll },
{ "M", 1000000ll },
{ "G", 1000000000ll },
{ "T", 1000000000000ll },
{ "P", 1000000000000000ll },
{ "E", 1000000000000000000ll },
{ NULL, 0ll },
};
return parse_suffix(str, sfx);
}
/**
* Count the number of characters in the number.
* The next bit of text starts with a number (0-9 or '.'), so it is a number.
* Count the number of characters in the number.
*
* This should cover all number formats for all languages.
* Note that this is not a strict parser. It will happily parse numbers in
* an invalid format.
*
* For example, only D allows underscores in the numbers, but they are
* allowed in all formats.
*
* @param pc The structure to update, str is an input.
* @return Whether a number was parsed
*/
static bool parse_number(tok_ctx& ctx, chunk_t& pc)
{
int tmp;
bool is_float;
bool did_hex = false;
/* A number must start with a digit or a dot, followed by a digit */
if (!is_dec(ctx.peek()) &&
((ctx.peek() != '.') || !is_dec(ctx.peek(1))))
{
return(false);
}
is_float = (ctx.peek() == '.');
if (is_float && (ctx.peek(1) == '.'))
{
return(false);
}
/* Check for Hex, Octal, or Binary
* Note that only D and Pawn support binary, but who cares?
*/
if (ctx.peek() == '0')
{
pc.str.append(ctx.get()); /* store the '0' */
switch (unc_toupper(ctx.peek()))
{
case 'X': /* hex */
did_hex = true;
do
{
pc.str.append(ctx.get()); /* store the 'x' and then the rest */
} while (is_hex_(ctx.peek()));
break;
case 'B': /* binary */
do
{
pc.str.append(ctx.get()); /* store the 'b' and then the rest */
} while (is_bin_(ctx.peek()));
break;
case '0': /* octal or decimal */
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
do
{
pc.str.append(ctx.get());
} while (is_oct_(ctx.peek()));
break;
default:
/* either just 0 or 0.1 or 0UL, etc */
break;
}
}
else
{
/* Regular int or float */
while (is_dec_(ctx.peek()))
{
pc.str.append(ctx.get());
}
}
/* Check if we stopped on a decimal point & make sure it isn't '..' */
if ((ctx.peek() == '.') && (ctx.peek(1) != '.'))
{
pc.str.append(ctx.get());
is_float = true;
if (did_hex)
{
while (is_hex_(ctx.peek()))
{
pc.str.append(ctx.get());
}
}
else
{
while (is_dec_(ctx.peek()))
{
pc.str.append(ctx.get());
}
}
}
/* Check exponent
* Valid exponents per language (not that it matters):
* C/C++/D/Java: eEpP
* C#/Pawn: eE
*/
tmp = unc_toupper(ctx.peek());
if ((tmp == 'E') || (tmp == 'P'))
{
is_float = true;
pc.str.append(ctx.get());
if ((ctx.peek() == '+') || (ctx.peek() == '-'))
{
pc.str.append(ctx.get());
}
while (is_dec_(ctx.peek()))
{
pc.str.append(ctx.get());
}
}
/* Check the suffixes
* Valid suffixes per language (not that it matters):
* Integer Float
* C/C++: uUlL64 lLfF
* C#: uUlL fFdDMm
* D: uUL ifFL
* Java: lL fFdD
* Pawn: (none) (none)
*
* Note that i, f, d, and m only appear in floats.
*/
while (1)
{
tmp = unc_toupper(ctx.peek());
if ((tmp == 'I') || (tmp == 'F') || (tmp == 'D') || (tmp == 'M'))
{
is_float = true;
}
else if ((tmp != 'L') && (tmp != 'U'))
{
break;
}
pc.str.append(ctx.get());
}
/* skip the Microsoft-specific '64' suffix */
if ((ctx.peek() == '6') && (ctx.peek(1) == '4'))
{
pc.str.append(ctx.get());
pc.str.append(ctx.get());
}
pc.type = is_float ? CT_NUMBER_FP : CT_NUMBER;
/* If there is anything left, then we are probably dealing with garbage or
* some sick macro junk. Eat it.
*/
parse_suffix(ctx, pc);
return(true);
} // parse_number
/**
* Skips the next bit of whatever and returns the type of block.
*
* pc.str is the input text.
* pc.len in the output length.
* pc.type is the output type
* pc.column is output column
*
* @param pc The structure to update, str is an input.
* @return true/false - whether anything was parsed
*/
static bool parse_next(tok_ctx& ctx, chunk_t& pc)
{
const chunk_tag_t *punc;
int ch, ch1;
if (!ctx.more())
{
//fprintf(stderr, "All done!\n");
return(false);
}
/* Save off the current column */
pc.orig_line = ctx.c.row;
pc.column = ctx.c.col;
pc.orig_col = ctx.c.col;
pc.type = CT_NONE;
pc.nl_count = 0;
pc.flags = 0;
/* If it is turned off, we put everything except newlines into CT_UNKNOWN */
if (cpd.unc_off)
{
if (parse_ignored(ctx, pc))
{
return(true);
}
}
/**
* Parse whitespace
*/
if (parse_whitespace(ctx, pc))
{
return(true);
}
/**
* Handle unknown/unhandled preprocessors
*/
if ((cpd.in_preproc > CT_PP_BODYCHUNK) &&
(cpd.in_preproc <= CT_PP_OTHER))
{
pc.str.clear();
tok_info ss;
ctx.save(ss);
/* Chunk to a newline or comment */
pc.type = CT_PREPROC_BODY;
int last = 0;
while (ctx.more())
{
int ch = ctx.peek();
if ((ch == '\n') || (ch == '\r'))
{
/* Back off if this is an escaped newline */
if (last == '\\')
{
ctx.restore(ss);
pc.str.pop_back();
}
break;
}
/* Quit on a C++ comment start */
if ((ch == '/') && (ctx.peek(1) == '/'))
{
break;
}
last = ch;
ctx.save(ss);
pc.str.append(ctx.get());
}
if (pc.str.size() > 0)
{
return(true);
}
}
/**
* Detect backslash-newline
*/
if ((ctx.peek() == '\\') && parse_bs_newline(ctx, pc))
{
return(true);
}
/**
* Parse comments
*/
if (parse_comment(ctx, pc))
{
return(true);
}
/* Parse code placeholders */
if (parse_code_placeholder(ctx, pc))
{
return(true);
}
/* Check for C# literal strings, ie @"hello" and identifiers @for*/
if ((cpd.lang_flags & LANG_CS) && (ctx.peek() == '@'))
{
if (ctx.peek(1) == '"')
{
parse_cs_string(ctx, pc);
return(true);
}
/* check for non-keyword identifiers such as @if @switch, etc */
if (CharTable::IsKw1(ctx.peek(1)))
{
parse_word(ctx, pc, true);
return(true);
}
}
/* Check for C# Interpolated strings */
if ((cpd.lang_flags & LANG_CS) && (ctx.peek() == '$') && (ctx.peek(1) == '"'))
{
parse_cs_interpolated_string(ctx, pc);
return(true);
}
/* handle VALA """ strings """ */
if ((cpd.lang_flags & LANG_VALA) &&
(ctx.peek() == '"') &&
(ctx.peek(1) == '"') &&
(ctx.peek(2) == '"'))
{
parse_verbatim_string(ctx, pc);
return(true);
}
/* handle C++0x strings u8"x" u"x" U"x" R"x" u8R"XXX(I'm a "raw UTF-8" string.)XXX" */
ch = ctx.peek();
if ((cpd.lang_flags & LANG_CPP) &&
((ch == 'u') || (ch == 'U') || (ch == 'R')))
{
int idx = 0;
bool is_real = false;
if ((ch == 'u') && (ctx.peek(1) == '8'))
{
idx = 2;
}
else if (unc_tolower(ch) == 'u')
{
idx++;
}
if (ctx.peek(idx) == 'R')
{
idx++;
is_real = true;
}
if (ctx.peek(idx) == '"')
{
if (is_real)
{
if (parse_cr_string(ctx, pc, idx))
{
return(true);
}
}
else
{
if (parse_string(ctx, pc, idx, true))
{
parse_suffix(ctx, pc, true);
return(true);
}
}
}
}
/* PAWN specific stuff */
if (cpd.lang_flags & LANG_PAWN)
{
if ((cpd.preproc_ncnl_count == 1) &&
((cpd.in_preproc == CT_PP_DEFINE) ||
(cpd.in_preproc == CT_PP_EMIT)))
{
parse_pawn_pattern(ctx, pc, CT_MACRO);
return(true);
}
/* Check for PAWN strings: \"hi" or !"hi" or !\"hi" or \!"hi" */
if ((ctx.peek() == '\\') || (ctx.peek() == '!'))
{
if (ctx.peek(1) == '"')
{
parse_string(ctx, pc, 1, (ctx.peek() == '!'));
return(true);
}
else if (((ctx.peek(1) == '\\') || (ctx.peek(1) == '!')) &&
(ctx.peek(2) == '"'))
{
parse_string(ctx, pc, 2, false);
return(true);
}
}
/* handle PAWN preprocessor args %0 .. %9 */
if ((cpd.in_preproc == CT_PP_DEFINE) &&
(ctx.peek() == '%') &&
unc_isdigit(ctx.peek(1)))
{
pc.str.clear();
pc.str.append(ctx.get());
pc.str.append(ctx.get());
pc.type = CT_WORD;
return(true);
}
}
/**
* Parse strings and character constants
*/
if (parse_number(ctx, pc))
{
return(true);
}
if (cpd.lang_flags & LANG_D)
{
/* D specific stuff */
if (d_parse_string(ctx, pc))
{
return(true);
}
}
else
{
/* Not D stuff */
/* Check for L'a', L"abc", 'a', "abc", <abc> strings */
ch = ctx.peek();
ch1 = ctx.peek(1);
if ((((ch == 'L') || (ch == 'S')) &&
((ch1 == '"') || (ch1 == '\''))) ||
(ch == '"') ||
(ch == '\'') ||
((ch == '<') && (cpd.in_preproc == CT_PP_INCLUDE)))
{
parse_string(ctx, pc, unc_isalpha(ch) ? 1 : 0, true);
return(true);
}
if ((ch == '<') && (cpd.in_preproc == CT_PP_DEFINE))
{
if (chunk_get_tail()->type == CT_MACRO)
{
/* We have "#define XXX <", assume '<' starts an include string */
parse_string(ctx, pc, 0, false);
return(true);
}
}
}
/* Check for Objective C literals and VALA identifiers ('@1', '@if')*/
if ((cpd.lang_flags & (LANG_OC | LANG_VALA)) && (ctx.peek() == '@'))
{
int nc = ctx.peek(1);
if ((nc == '"') || (nc == '\''))
{
/* literal string */
parse_string(ctx, pc, 1, true);
return(true);
}
else if ((nc >= '0') && (nc <= '9'))
{
/* literal number */
pc.str.append(ctx.get()); /* store the '@' */
parse_number(ctx, pc);
return(true);
}
}
/* Check for pawn/ObjectiveC/Java and normal identifiers */
if (CharTable::IsKw1(ctx.peek()) ||
((ctx.peek() == '@') && CharTable::IsKw1(ctx.peek(1))))
{
parse_word(ctx, pc, false);
return(true);
}
/* see if we have a punctuator */
char punc_txt[4];
punc_txt[0] = ctx.peek();
punc_txt[1] = ctx.peek(1);
punc_txt[2] = ctx.peek(2);
punc_txt[3] = ctx.peek(3);
if ((punc = find_punctuator(punc_txt, cpd.lang_flags)) != NULL)
{
int cnt = strlen(punc->tag);
while (cnt--)
{
pc.str.append(ctx.get());
}
pc.type = punc->type;
pc.flags |= PCF_PUNCTUATOR;
return(true);
}
/* throw away this character */
pc.type = CT_UNKNOWN;
pc.str.append(ctx.get());
LOG_FMT(LWARN, "%s:%d Garbage in col %d: %x\n",
cpd.filename, pc.orig_line, (int)ctx.c.col, pc.str[0]);
cpd.error_count++;
return(true);
} // parse_next
long long parse_time(const char *str)
{
return parse_suffix(str, time_suffix, 0, LLONG_MAX);
}
off_t parse_offset(const char *str)
{
return parse_suffix(str, size_suffix, 0, LLONG_MAX);
}
ssize_t parse_size(const char *str)
{
return parse_suffix(str, size_suffix, 0, LONG_MAX);
}
int parse_int(const char *str)
{
return parse_suffix(str, int_suffix, 0, INT_MAX);
}
/**
* Count the number of characters in a quoted string.
* The next bit of text starts with a quote char " or ' or <.
* Count the number of characters until the matching character.
*
* @param pc The structure to update, str is an input.
* @return Whether a string was parsed
*/
static bool parse_string(tok_ctx &ctx, chunk_t &pc, int quote_idx, bool allow_escape)
{
bool escaped = false;
int end_ch;
char escape_char = cpd.settings[UO_string_escape_char].n;
char escape_char2 = cpd.settings[UO_string_escape_char2].n;
bool should_escape_tabs = cpd.settings[UO_string_replace_tab_chars].b && (cpd.lang_flags & LANG_ALLC);
pc.str.clear();
while (quote_idx-- > 0)
{
pc.str.append(ctx.get());
}
pc.type = CT_STRING;
end_ch = CharTable::Get(ctx.peek()) & 0xff;
pc.str.append(ctx.get()); /* store the " */
while (ctx.more())
{
int lastcol = ctx.c.col;
int ch = ctx.get();
if ((ch == '\t') && should_escape_tabs)
{
ctx.c.col = lastcol + 2;
pc.str.append(escape_char);
pc.str.append('t');
continue;
}
pc.str.append(ch);
if (ch == '\n')
{
pc.nl_count++;
pc.type = CT_STRING_MULTI;
escaped = false;
continue;
}
if ((ch == '\r') && (ctx.peek() != '\n'))
{
pc.str.append(ctx.get());
pc.nl_count++;
pc.type = CT_STRING_MULTI;
escaped = false;
continue;
}
if (!escaped)
{
if (ch == escape_char)
{
escaped = (escape_char != 0);
}
else if ((ch == escape_char2) && (ctx.peek() == end_ch))
{
escaped = allow_escape;
}
else if (ch == end_ch)
{
break;
}
}
else
{
escaped = false;
}
}
parse_suffix(ctx, pc, true);
return(true);
} // parse_string
