/* ****************************************************************** */
static ssize_t ppc_rtas_clock_write(struct file *file,
const char __user *buf, size_t count, loff_t *ppos)
{
struct rtc_time tm;
unsigned long nowtime;
int error = parse_number(buf, count, &nowtime);
if (error)
return error;
to_tm(nowtime, &tm);
error = rtas_call(rtas_token("set-time-of-day"), 7, 1, NULL,
tm.tm_year, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, 0);
if (error)
printk(KERN_WARNING "error: setting the clock returned: %s\n",
ppc_rtas_process_error(error));
return count;
}
std::pair< bool, bool > parser::parse(const char* begin, const char* end)
{
assert( !state_.empty() );
for ( ; begin != end && !state_.empty(); )
{
switch ( main_state( state_.top() ) )
{
case idle_parsing:
begin = eat_white_space(begin, end);
if ( begin != end )
{
state_.top() = parse_idle(*begin);
}
break;
case start_number_parsing:
begin = parse_number(begin, end);
break;
case start_array_parsing:
begin = parse_array(begin, end);
break;
case start_object_parsing:
begin = parse_object(begin, end);
break;
case start_string_parsing:
begin = parse_string(begin, end);
break;
case start_true_parsing:
case start_false_parsing:
case start_null_parsing:
begin = parse_literal(begin, end);
break;
default:
assert(!"should not happen");
}
}
// consume trailing whitespaces
if ( state_.empty() )
begin = eat_white_space(begin, end);
return std::make_pair( begin == end, state_.empty() );
}
/* Parser core - when encountering text, process appropriately. */
static const char *parse_value(cJSON *item, const char *value, const char **ep)
{
if (!value)
{
/* Fail on null. */
return 0;
}
/* parse the different types of values */
if (!strncmp(value, "null", 4))
{
item->type = cJSON_NULL;
return value + 4;
}
if (!strncmp(value, "false", 5))
{
item->type = cJSON_False;
return value + 5;
}
if (!strncmp(value, "true", 4))
{
item->type = cJSON_True;
item->valueint = 1;
return value + 4;
}
if (*value == '\"')
{
return parse_string(item, value, ep);
}
if ((*value == '-') || ((*value >= '0') && (*value <= '9')))
{
return parse_number(item, value);
}
if (*value == '[')
{
return parse_array(item, value, ep);
}
if (*value == '{')
{
return parse_object(item, value, ep);
}
*ep=value;return 0; /* failure. */
}
// Note: this function returns a pointer, but for some strange
// reason we must put the asterisk after the EXPORT.
CI_Result EXPORT * CI_submit( char const* input )
{
double number;
if( !parse_number( input, number ) )
return NULL;
std::ostringstream ss;
ss << number;
std::string result = ss.str();
CI_Result* res = new CI_Result;
res->input = component( input );
res->num_outputs = 1;
res->outputs = new CI_ResultComponent[1];
res->outputs[0] = component( result.c_str() );
return res;
}
/* ****************************************************************** */
static ssize_t ppc_rtas_tone_volume_write(struct file *file,
const char __user *buf, size_t count, loff_t *ppos)
{
unsigned long volume;
int error = parse_number(buf, count, &volume);
if (error)
return error;
if (volume > 100)
volume = 100;
rtas_tone_volume = volume; /* save it for later */
error = rtas_call(rtas_token("set-indicator"), 3, 1, NULL,
TONE_VOLUME, 0, volume);
if (error)
printk(KERN_WARNING "error: setting tone volume returned: %s\n",
ppc_rtas_process_error(error));
return count;
}
version_number_t::version_number_t(const std::string &s)
: valid(false)
{
memset(parts, 0, 5 * sizeof(unsigned int));
if (debugging_requested("version_check"))
mxinfo(boost::format("version check: Parsing %1%\n") % s);
// Match the following:
// 4.4.0
// 4.4.0.5 build 123
// 4.4.0-build20101201-123
// mkvmerge v4.4.0
// * Optional prefix "mkvmerge v"
// * At least three digits separated by dots
// * Optional fourth digit separated by a dot
// * Optional build number that can have two forms:
// - " build nnn"
// - "-buildYYYYMMDD-nnn" (date is ignored)
static boost::regex s_version_number_re("^ (?: mkv[a-z]+ \\s+ v)?" // Optional prefix mkv... v
"(\\d+) \\. (\\d+) \\. (\\d+)" // Three digitss separated by dots; $1 - $3
"(?: \\. (\\d+) )?" // Optional fourth digit separated by a dot; $4
"(?:" // Optional build number including its prefix
" (?: \\s* build \\s*" // Build number prefix: either " build " or...
" | - build \\d{8} - )" // ... "-buildYYYYMMDD-"
" (\\d+)" // The build number itself; $5
")?",
boost::regex::perl | boost::regex::mod_x);
boost::smatch matches;
if (!boost::regex_search(s, matches, s_version_number_re))
return;
size_t idx;
for (idx = 1; 5 >= idx; ++idx)
if (!matches[idx].str().empty())
parse_number(matches[idx].str(), parts[idx - 1]);
valid = true;
if (debugging_requested("version_check"))
mxinfo(boost::format("version check: parse OK; result: %1%\n") % to_string());
}
/* Parser core - when encountering text, process appropriately. */
static const char *ICACHE_FLASH_ATTR
parse_value(cJSON *item, const char *value)
{
if (!value) {
return 0; /* Fail on null. */
}
if (!strncmp(value, "null", 4)) {
item->type = cJSON_NULL;
return value + 4;
}
if (!strncmp(value, "false", 5)) {
item->type = cJSON_False;
return value + 5;
}
if (!strncmp(value, "true", 4)) {
item->type = cJSON_True;
item->valueint = 1;
return value + 4;
}
if (*value == '\"') {
return parse_string(item, value);
}
if (*value == '-' || (*value >= '0' && *value <= '9')) {
return parse_number(item, value);
}
if (*value == '[') {
return parse_array(item, value);
}
if (*value == '{') {
return parse_object(item, value);
}
ep = value;
return 0; /* failure. */
}
// primary_expr ::= number
// bool
// ( expr )
//
Expr*
parse_primary_expr(Parser& p, Token_stream& ts)
{
if (ts.next()) {
switch (ts.next()->kind()) {
case number_tok: return parse_number(p, ts);
case lparen_tok: return parse_paren_enclosed(p, ts);
case bool_tok: return parse_bool(p, ts);
// // negative number
// case minus_tok: return parse_neg(p, ts);
default:
print("Unable to parse primary expr beginning with: ");
print(ts.next());
print("\n");
return nullptr;
}
}
return nullptr;
}
/* value = 'null' | 'true' | 'false' | number | string | array | object */
static int parse_value(struct frozen *f) {
int ch = cur(f);
switch (ch) {
case '"':
TRY(parse_string(f));
break;
case '{':
TRY(parse_object(f));
break;
case '[':
TRY(parse_array(f));
break;
case 'n':
TRY(expect(f, "null", 4, JSON_TYPE_NULL));
break;
case 't':
TRY(expect(f, "true", 4, JSON_TYPE_TRUE));
break;
case 'f':
TRY(expect(f, "false", 5, JSON_TYPE_FALSE));
break;
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
TRY(parse_number(f));
break;
default:
return ch == END_OF_STRING ? JSON_STRING_INCOMPLETE : JSON_STRING_INVALID;
}
return 0;
}
void
extract_cli_parser_c::add_extraction_spec() {
if ( (options_c::em_tracks != m_options.m_extraction_mode)
&& (options_c::em_timecodes_v2 != m_options.m_extraction_mode)
&& (options_c::em_attachments != m_options.m_extraction_mode))
mxerror(boost::format(Y("Unrecognized command line option '%1%'.\n")) % m_current_arg);
boost::regex s_track_id_re("^(\\d+)(:(.+))?$", boost::regex::perl);
boost::smatch matches;
if (!boost::regex_search(m_current_arg, matches, s_track_id_re)) {
if (options_c::em_attachments == m_options.m_extraction_mode)
mxerror(boost::format(Y("Invalid attachment ID/file name specification in argument '%1%'.\n")) % m_current_arg);
else
mxerror(boost::format(Y("Invalid track ID/file name specification in argument '%1%'.\n")) % m_current_arg);
}
track_spec_t track;
parse_number(matches[1].str(), track.tid);
std::string output_file_name;
if (matches[3].matched)
output_file_name = matches[3].str();
if (output_file_name.empty()) {
if (options_c::em_attachments == m_options.m_extraction_mode)
mxinfo(Y("No output file name specified, will use attachment name.\n"));
else
mxerror(boost::format(Y("Missing output file name in argument '%1%'.\n")) % m_current_arg);
}
track.out_name = output_file_name;
track.sub_charset = m_charset;
track.extract_cuesheet = m_extract_cuesheet;
track.extract_blockadd_level = m_extract_blockadd_level;
track.target_mode = m_target_mode;
m_options.m_tracks.push_back(track);
set_default_values();
}
std::string
get_local_charset() {
std::string lc_charset;
setlocale(LC_CTYPE, "");
#if defined(COMP_MINGW) || defined(COMP_MSC)
lc_charset = "CP" + to_string(GetACP());
#elif defined(SYS_SOLARIS)
int i;
lc_charset = nl_langinfo(CODESET);
if (parse_number(lc_charset, i))
lc_charset = std::string("ISO") + lc_charset + std::string("-US");
#elif HAVE_NL_LANGINFO
lc_charset = nl_langinfo(CODESET);
#elif HAVE_LOCALE_CHARSET
lc_charset = locale_charset();
#endif
return lc_charset;
}
Variant JSONReader::parse_value()
{
skip_space();
if (at('{'))
return parse_object();
if (at('['))
return parse_array();
if (at('"'))
return parse_string();
if (at_digit() || at('-'))
return parse_number();
if (skip_string("true"))
return Variant(true);
if (skip_string("false"))
return Variant(false);
if (skip_string("null"))
return Variant();
throw Exception(position(), "invalid value");
}
/* ****************************************************************** */
static ssize_t ppc_rtas_poweron_write(struct file *file,
const char __user *buf, size_t count, loff_t *ppos)
{
struct rtc_time tm;
unsigned long nowtime;
int error = parse_number(buf, count, &nowtime);
if (error)
return error;
power_on_time = nowtime; /* save the time */
to_tm(nowtime, &tm);
error = rtas_call(rtas_token("set-time-for-power-on"), 7, 1, NULL,
tm.tm_year, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, 0 /* nano */);
if (error)
printk(KERN_WARNING "error: setting poweron time returned: %s\n",
ppc_rtas_process_error(error));
return count;
}
/*
* parenthesized expression or value
*/
double ExpParser::parse_level10()
{
// check if it is a parenthesized expression
if (token_type == DELIMETER)
{
if (token[0] == '(' && token[1] == '\0')
{
getToken();
double ans = parse_level2();
if (token_type != DELIMETER || token[0] != ')' || token[1] || '\0')
{
throw Error(row(), col(), 3);
}
getToken();
return ans;
}
}
// if not parenthesized then the expression is a value
return parse_number();
}
void json::parse_value( std::istream_iterator<char> &it, std::istream_iterator<char> &end, int &line )
{
skip_whitespace( it, end, line );
if ( it == end )
{
clear();
return;
}
switch ( *it )
{
case '[':
parse_array( it, end, line );
break;
case '{':
parse_object( it, end, line );
break;
case '"':
parse_string( it, end, line );
break;
case 't':
parse_true( it, end, line );
break;
case 'f':
parse_false( it, end, line );
break;
case 'n':
parse_null( it, end, line );
break;
default:
parse_number( it, end, line );
}
}
size_t
dt_parse_iso_time_basic(const char *str, size_t len, int *sp, int *fp) {
const unsigned char *p;
int h, m, s, f;
size_t n;
p = (const unsigned char *)str;
n = count_digits(p, 0, len);
m = s = f = 0;
switch (n) {
case 2: /* hh */
h = parse_number(p, 0, 2);
goto hms;
case 4: /* hhmm */
h = parse_number(p, 0, 2);
m = parse_number(p, 2, 2);
goto hms;
case 6: /* hhmmss */
h = parse_number(p, 0, 2);
m = parse_number(p, 2, 2);
s = parse_number(p, 4, 2);
break;
default:
return 0;
}
/* hhmmss.fffffffff */
if (n < len && (p[n] == '.' || p[n] == ',')) {
size_t r = parse_fraction_digits(p, ++n, len, &f);
if (!r)
return 0;
n += r;
}
hms:
if (h > 23 || m > 59 || s > 59) {
if (!(h == 24 && m == 0 && s == 0 && f == 0))
return 0;
}
if (sp)
*sp = h * 3600 + m * 60 + s;
if (fp)
*fp = f;
return n;
}
static heim_object_t
parse_value(struct parse_ctx *ctx)
{
size_t len;
if (white_spaces(ctx))
return NULL;
if (*ctx->p == '"') {
return parse_string(ctx);
} else if (*ctx->p == '{') {
return parse_dict(ctx);
} else if (*ctx->p == '[') {
return parse_array(ctx);
} else if (is_number(*ctx->p) || *ctx->p == '-') {
return parse_number(ctx);
}
len = ctx->pend - ctx->p;
if (len >= 4 && memcmp(ctx->p, "null", 4) == 0) {
ctx->p += 4;
return heim_null_create();
} else if (len >= 4 && strncasecmp((char *)ctx->p, "true", 4) == 0) {
ctx->p += 4;
return heim_bool_create(1);
} else if (len >= 5 && strncasecmp((char *)ctx->p, "false", 5) == 0) {
ctx->p += 5;
return heim_bool_create(0);
}
ctx->error = heim_error_create(EINVAL, "unknown char %c at %lu line %lu",
(char)*ctx->p,
(unsigned long)(ctx->p - ctx->pstart),
ctx->lineno);
return NULL;
}
static int parse_value(lua_State *L, parse_state *state) {
eat_whitespace(state);
char c = *state->ptr;
switch (c) {
case '"': return parse_string(L, state);
case '{': return parse_object(L, state);
case '[': return parse_array(L, state);
case 't':
case 'f': return parse_boolean(L, state);
case 'n': return parse_null(L, state);
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': return parse_number(L, state);
default: return push_parse_error(L, state, "unexpected character");
}
}
int prompt_number(const char *prompt, uint64_t *number, unsigned int base) {
char *string = readline(prompt);
int start=0;
if(string == NULL) {return -1; };
{ /* Trim Whitespace */
int i=strlen(string);
while (isspace(string[i])) string[i] = 0;
while(isspace(string[start])) ++start;
}
if(strlen(string+start) == 0) {
free(string);
return -1;
}
if(parse_number(string+start, base, number)) {
free(string);
return -1;
};
free(string);
return 0;
}
FILE *fopen_generic(const char *path, const char *mode, int debug)
{
assert(path != NULL);
assert(mode != NULL);
FILE *file = NULL;
uint32_t port = 0;
if (strncasecmp(path, "aa:", 3) == 0) {
if (parse_number(path + 3, &port) == 0)
assert(0);
//file = fopen_aaflash(port, mode, debug);
} else if (strncasecmp(path, "rw:", 3) == 0) {
assert(0);
//file = fopen_rwflash(path + 3, mode, debug);
} else {
file = fopen(path, mode);
}
if (file == NULL)
ERRNO(errno);
return file;
}
static int I2cWriteReadCommand(int argc, char const ** argv) {
if (argc < 2 || argc > 18) return -1;
uint8_t addr = (uint8_t) parse_hex(argv[0]);
++argv;
--argc;
size_t readlen = (size_t) parse_number(argv[argc - 1]);
--argc;
uint8_t buf[16];
for (int i = 0; i < argc; ++i) {
buf[i] = (uint8_t) parse_hex(argv[i]);
}
if (ERROR_NONE != I2cWriteRead(addr, buf, argc, buf, readlen)) return -3;
for (int i = 0; i < readlen; ++i) {
printf("%02x ", buf[i]);
}
printf("\r\n");
return 0;
}
static time_t
parse_date_string(const char *str_to_parse)
{
char year[5];
char month[3];
char day[3];
char hour[3];
char minute[3];
char second[3];
struct tm t;
time_t temp_time;
memset(year, 0, 5);
memset(month, 0, 3);
memset(day, 0, 3);
memset(hour, 0, 3);
memset(minute, 0, 3);
memset(second, 0, 3);
if (split_date(year, month, day, hour, minute, second, str_to_parse) == 1)
{
memset((void *)&t, 0, sizeof(struct tm));
t.tm_isdst = 0;
t.tm_mday = 1;
if (!((parse_number(year, 1900, 2037, &(t.tm_year)) == -1) ||
(parse_number(month, 1, 12, &(t.tm_mon)) == -1) ||
(parse_number(day, 1, 31, &(t.tm_mday)) == -1) ||
(parse_number(hour, 0, 9999, &(t.tm_hour)) == -1) ||
(parse_number(minute, 0, 59, &(t.tm_min)) == -1) ||
(parse_number(second, 0, 59, &(t.tm_sec)) == -1)))
{
t.tm_year -= 1900;
--(t.tm_mon);
temp_time = mktime(&t);
if (temp_time != -1)
return temp_time;
}
}
exit_error(PARAMETER_PROBLEM,
"invalid date `%s' specified, should be YYYY[:MM[:DD[:hh[:mm[:ss]]]]] format", str_to_parse);
}
static bool parse_factor(const char *&str, double &r) {
if (parse_number(str, r)) return true;
return parse_char(str, '(') && parse_addExpr(str, r) && parse_char(str, ')');
}
FBCALL void fb_GfxDraw(void *target, FBSTRING *command)
{
FB_GFXCTX *context;
float x, y, dx, dy, ax, ay, x2, y2;
int angle = 0, diagonal = FALSE;
char *c;
intptr_t value1, value2;
int draw = TRUE, move = TRUE, length = 0, flags, rel;
FB_GRAPHICS_LOCK( );
if ((!__fb_gfx) || (!command) || (!command->data)) {
if (command)
fb_hStrDelTemp(command);
FB_GRAPHICS_UNLOCK( );
return;
}
context = fb_hGetContext( );
fb_hPrepareTarget(context, target);
fb_hSetPixelTransfer(context, MASK_A_32);
x = context->last_x;
y = context->last_y;
DRIVER_LOCK();
flags = context->flags;
context->flags |= CTX_VIEW_SCREEN;
for (c = command->data; *c;) {
switch (toupper(*c)) {
case 'B':
c++;
draw = FALSE;
break;
case 'N':
c++;
move = FALSE;
break;
case 'C':
c++;
if ((value1 = parse_number(&c)) == FB_NAN)
goto error;
context->fg_color = fb_hFixColor(context->target_bpp, value1);
break;
case 'S':
c++;
if ((value1 = parse_number(&c)) == FB_NAN)
goto error;
base_scale = (float)value1 / 4.0;
break;
case 'A':
c++;
if ((value1 = parse_number(&c)) == FB_NAN)
goto error;
base_angle = (value1 & 0x3) * 90;
break;
case 'T':
c++;
if (toupper(*c) != 'A')
goto error;
c++;
if ((value1 = parse_number(&c)) == FB_NAN)
goto error;
base_angle = mod360( value1 );
break;
case 'X':
c++;
/* Here we could be more severe with checking, but it's unlikely our substring
* resides at location FB_NAN (0x80000000) */
if ((value1 = parse_number(&c)) == FB_NAN)
goto error;
/* Store our current x/y for the recursive fb_GfxDraw() call */
context->last_x = x;
context->last_y = y;
DRIVER_UNLOCK();
fb_GfxDraw(target, (FBSTRING *)value1);
DRIVER_LOCK();
/* And update to x/y produced by the recursive fb_GfxDraw() call */
x = context->last_x;
y = context->last_y;
break;
case 'P':
c++;
if ((value1 = parse_number(&c)) == FB_NAN)
goto error;
value2 = value1;
if (*c == ',') {
c++;
if ((value2 = parse_number(&c)) == FB_NAN)
goto error;
}
DRIVER_UNLOCK();
fb_GfxPaint(target, x, y, value1 & __fb_gfx->color_mask, value2 & __fb_gfx->color_mask, NULL, PAINT_TYPE_FILL, COORD_TYPE_A);
DRIVER_LOCK();
break;
case 'M':
c++;
while ((*c == ' ') || (*c == '\t'))
c++;
rel = ((*c == '+') || (*c == '-'));
if ((value1 = parse_number(&c)) == FB_NAN)
goto error;
if (*c++ != ',')
goto error;
if ((value2 = parse_number(&c)) == FB_NAN)
goto error;
x2 = (float)value1;
y2 = (float)value2;
if (rel) {
ax = dcos(base_angle);
ay = -dsin(base_angle);
dx = x2;
dy = y2;
x2 = (((dx * ax) - (dy * ay)) * base_scale) + x;
y2 = (((dy * ax) + (dx * ay)) * base_scale) + y;
}
if (draw) {
DRIVER_UNLOCK();
fb_GfxLine(target, (int)x, (int)y, (int)x2, (int)y2, 0, LINE_TYPE_LINE, 0xFFFF, COORD_TYPE_AA | DEFAULT_COLOR_1);
DRIVER_LOCK();
}
if (move) {
x = x2;
y = y2;
}
move = draw = TRUE;
break;
case 'F': case 'D': angle += 90;
case 'G': case 'L': angle += 90;
case 'H': case 'U': angle += 90;
case 'E': case 'R':
diagonal = ((toupper(*c) >= 'E') && (toupper(*c) <= 'H'));
c++;
if ((value1 = parse_number(&c)) != FB_NAN)
length = value1;
else
length = 1;
angle = mod360( angle + base_angle );
dx = (float)length * base_scale * dcos( angle );
dy = (float)length * base_scale * -dsin( angle );
if (diagonal) {
x2 = x + (dx + dy);
y2 = y + (dy - dx);
}
else {
x2 = x + dx;
y2 = y + dy;
}
if (draw) {
fb_GfxDrawLine( context, CINT(x), CINT(y), CINT(x2), CINT(y2), context->fg_color, 0xffff );
}
if (move) {
x = x2;
y = y2;
}
angle = 0;
move = draw = TRUE;
break;
default:
c++;
break;
}
}
context->last_x = x;
context->last_y = y;
error:
context->flags = flags;
DRIVER_UNLOCK();
/* del if temp */
fb_hStrDelTemp( command );
FB_GRAPHICS_UNLOCK( );
}
static void next_lexem(struct context_t *ctx, struct lexem_t *lexem)
{
#define ret_simple(t, adv) \
do {locate_lexem(lexem, ctx); \
lexem->type = t; \
advance(ctx, adv); \
return;} while(0)
while(!eof(ctx))
{
char c = cur_char(ctx);
/* skip whitespace */
if(c == ' ' || c == '\t' || c == '\n' || c == '\r')
{
advance(ctx, 1);
continue;
}
/* skip C++ style comments */
if(c == '/' && next_valid(ctx, 1) && next_char(ctx, 1) == '/')
{
while(!eof(ctx) && cur_char(ctx) != '\n')
advance(ctx, 1);
continue;
}
/* skip C-style comments */
if(c == '/' && next_valid(ctx, 1) && next_char(ctx, 1) == '*')
{
advance(ctx, 2);
while(true)
{
if(!next_valid(ctx, 1))
parse_error(ctx, "Unterminated comment");
if(cur_char(ctx) == '*' && next_char(ctx, 1) == '/')
{
advance(ctx, 2);
break;
}
advance(ctx, 1);
}
continue;
}
break;
}
if(eof(ctx)) ret_simple(LEX_EOF, 0);
char c = cur_char(ctx);
bool nv = next_valid(ctx, 1);
char nc = nv ? next_char(ctx, 1) : 0;
if(c == '(') ret_simple(LEX_LPAREN, 1);
if(c == ')') ret_simple(LEX_RPAREN, 1);
if(c == '{') ret_simple(LEX_LBRACE, 1);
if(c == '}') ret_simple(LEX_RBRACE, 1);
if(c == '>') ret_simple(LEX_RANGLE, 1);
if(c == '=') ret_simple(LEX_EQUAL, 1);
if(c == ';') ret_simple(LEX_SEMICOLON, 1);
if(c == ',') ret_simple(LEX_COLON, 1);
if(c == '|') ret_simple(LEX_OR, 1);
if(c == '<' && nv && nc == '<') ret_simple(LEX_LSHIFT, 2);
if(c == '<' && nv && nc == '=') ret_simple(LEX_LE, 2);
if(c == '"') return parse_string(ctx, lexem);
if(c == '\'') return parse_ascii_number(ctx, lexem);
if(isdigit(c)) return parse_number(ctx, lexem);
if(isalpha(c) || c == '_') return parse_identifier(ctx, lexem);
parse_error(ctx, "Unexpected character '%c'\n", c);
#undef ret_simple
}
static void u32_parse(struct xt_option_call *cb)
{
struct xt_u32 *data = cb->data;
unsigned int testind = 0, locind = 0, valind = 0;
struct xt_u32_test *ct = &data->tests[testind]; /* current test */
const char *arg = cb->arg; /* the argument string */
const char *start = cb->arg;
int state = 0;
xtables_option_parse(cb);
data->invert = cb->invert;
/*
* states:
* 0 = looking for numbers and operations,
* 1 = looking for ranges
*/
while (1) {
/* read next operand/number or range */
while (isspace(*arg))
++arg;
if (*arg == '\0') {
/* end of argument found */
if (state == 0)
xtables_error(PARAMETER_PROBLEM,
"u32: abrupt end of input after location specifier");
if (valind == 0)
xtables_error(PARAMETER_PROBLEM,
"u32: test ended with no value specified");
ct->nnums = locind;
ct->nvalues = valind;
data->ntests = ++testind;
if (testind > XT_U32_MAXSIZE)
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: too many \"&&\"s",
(unsigned int)(arg - start));
return;
}
if (state == 0) {
/*
* reading location: read a number if nothing read yet,
* otherwise either op number or = to end location spec
*/
if (*arg == '=') {
if (locind == 0) {
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: "
"location spec missing",
(unsigned int)(arg - start));
} else {
++arg;
state = 1;
}
} else {
if (locind != 0) {
/* need op before number */
if (*arg == '&') {
ct->location[locind].nextop = XT_U32_AND;
} else if (*arg == '<') {
if (*++arg != '<')
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: a second '<' was expected", (unsigned int)(arg - start));
ct->location[locind].nextop = XT_U32_LEFTSH;
} else if (*arg == '>') {
if (*++arg != '>')
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: a second '>' was expected", (unsigned int)(arg - start));
ct->location[locind].nextop = XT_U32_RIGHTSH;
} else if (*arg == '@') {
ct->location[locind].nextop = XT_U32_AT;
} else {
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: operator expected", (unsigned int)(arg - start));
}
++arg;
}
/* now a number; string_to_number skips white space? */
ct->location[locind].number =
parse_number(&arg, arg - start);
if (++locind > XT_U32_MAXSIZE)
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: too many operators", (unsigned int)(arg - start));
}
} else {
/*
* state 1 - reading values: read a range if nothing
* read yet, otherwise either ,range or && to end
* test spec
*/
if (*arg == '&') {
if (*++arg != '&')
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: a second '&' was expected", (unsigned int)(arg - start));
if (valind == 0) {
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: value spec missing", (unsigned int)(arg - start));
} else {
ct->nnums = locind;
ct->nvalues = valind;
ct = &data->tests[++testind];
if (testind > XT_U32_MAXSIZE)
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: too many \"&&\"s", (unsigned int)(arg - start));
++arg;
state = 0;
locind = 0;
valind = 0;
}
} else { /* read value range */
if (valind > 0) { /* need , before number */
if (*arg != ',')
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: expected \",\" or \"&&\"", (unsigned int)(arg - start));
++arg;
}
ct->value[valind].min =
parse_number(&arg, arg - start);
while (isspace(*arg))
++arg;
if (*arg == ':') {
++arg;
ct->value[valind].max =
parse_number(&arg, arg-start);
} else {
ct->value[valind].max =
ct->value[valind].min;
}
if (++valind > XT_U32_MAXSIZE)
xtables_error(PARAMETER_PROBLEM,
"u32: at char %u: too many \",\"s", (unsigned int)(arg - start));
}
}
}
}
/* much of this is taken from unicodeobject.c */
static int
format_float_internal(PyObject *value,
const InternalFormatSpec *format,
_PyUnicodeWriter *writer)
{
char *buf = NULL; /* buffer returned from PyOS_double_to_string */
Py_ssize_t n_digits;
Py_ssize_t n_remainder;
Py_ssize_t n_total;
int has_decimal;
double val;
int precision, default_precision = 6;
Py_UCS4 type = format->type;
int add_pct = 0;
Py_ssize_t index;
NumberFieldWidths spec;
int flags = 0;
int result = -1;
Py_UCS4 maxchar = 127;
Py_UCS4 sign_char = '\0';
int float_type; /* Used to see if we have a nan, inf, or regular float. */
PyObject *unicode_tmp = NULL;
/* Locale settings, either from the actual locale or
from a hard-code pseudo-locale */
LocaleInfo locale = STATIC_LOCALE_INFO_INIT;
if (format->precision > INT_MAX) {
PyErr_SetString(PyExc_ValueError, "precision too big");
goto done;
}
precision = (int)format->precision;
if (format->alternate)
flags |= Py_DTSF_ALT;
if (type == '\0') {
/* Omitted type specifier. Behaves in the same way as repr(x)
and str(x) if no precision is given, else like 'g', but with
at least one digit after the decimal point. */
flags |= Py_DTSF_ADD_DOT_0;
type = 'r';
default_precision = 0;
}
if (type == 'n')
/* 'n' is the same as 'g', except for the locale used to
format the result. We take care of that later. */
type = 'g';
val = PyFloat_AsDouble(value);
if (val == -1.0 && PyErr_Occurred())
goto done;
if (type == '%') {
type = 'f';
val *= 100;
add_pct = 1;
}
if (precision < 0)
precision = default_precision;
else if (type == 'r')
type = 'g';
/* Cast "type", because if we're in unicode we need to pass a
8-bit char. This is safe, because we've restricted what "type"
can be. */
buf = PyOS_double_to_string(val, (char)type, precision, flags,
&float_type);
if (buf == NULL)
goto done;
n_digits = strlen(buf);
if (add_pct) {
/* We know that buf has a trailing zero (since we just called
strlen() on it), and we don't use that fact any more. So we
can just write over the trailing zero. */
buf[n_digits] = '%';
n_digits += 1;
}
if (format->sign != '+' && format->sign != ' '
&& format->width == -1
&& format->type != 'n'
&& !format->thousands_separators)
{
/* Fast path */
result = _PyUnicodeWriter_WriteASCIIString(writer, buf, n_digits);
PyMem_Free(buf);
return result;
}
/* Since there is no unicode version of PyOS_double_to_string,
just use the 8 bit version and then convert to unicode. */
unicode_tmp = _PyUnicode_FromASCII(buf, n_digits);
PyMem_Free(buf);
if (unicode_tmp == NULL)
goto done;
/* Is a sign character present in the output? If so, remember it
and skip it */
index = 0;
if (PyUnicode_READ_CHAR(unicode_tmp, index) == '-') {
sign_char = '-';
++index;
--n_digits;
}
/* Determine if we have any "remainder" (after the digits, might include
decimal or exponent or both (or neither)) */
parse_number(unicode_tmp, index, index + n_digits, &n_remainder, &has_decimal);
/* Determine the grouping, separator, and decimal point, if any. */
if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
(format->thousands_separators ?
LT_DEFAULT_LOCALE :
LT_NO_LOCALE),
&locale) == -1)
goto done;
/* Calculate how much memory we'll need. */
n_total = calc_number_widths(&spec, 0, sign_char, unicode_tmp, index,
index + n_digits, n_remainder, has_decimal,
&locale, format, &maxchar);
/* Allocate the memory. */
if (_PyUnicodeWriter_Prepare(writer, n_total, maxchar) == -1)
goto done;
/* Populate the memory. */
result = fill_number(writer, &spec,
unicode_tmp, index, index + n_digits,
NULL, 0, format->fill_char,
&locale, 0);
done:
Py_XDECREF(unicode_tmp);
free_locale_info(&locale);
return result;
}
static int
format_complex_internal(PyObject *value,
const InternalFormatSpec *format,
_PyUnicodeWriter *writer)
{
double re;
double im;
char *re_buf = NULL; /* buffer returned from PyOS_double_to_string */
char *im_buf = NULL; /* buffer returned from PyOS_double_to_string */
InternalFormatSpec tmp_format = *format;
Py_ssize_t n_re_digits;
Py_ssize_t n_im_digits;
Py_ssize_t n_re_remainder;
Py_ssize_t n_im_remainder;
Py_ssize_t n_re_total;
Py_ssize_t n_im_total;
int re_has_decimal;
int im_has_decimal;
int precision, default_precision = 6;
Py_UCS4 type = format->type;
Py_ssize_t i_re;
Py_ssize_t i_im;
NumberFieldWidths re_spec;
NumberFieldWidths im_spec;
int flags = 0;
int result = -1;
Py_UCS4 maxchar = 127;
enum PyUnicode_Kind rkind;
void *rdata;
Py_UCS4 re_sign_char = '\0';
Py_UCS4 im_sign_char = '\0';
int re_float_type; /* Used to see if we have a nan, inf, or regular float. */
int im_float_type;
int add_parens = 0;
int skip_re = 0;
Py_ssize_t lpad;
Py_ssize_t rpad;
Py_ssize_t total;
PyObject *re_unicode_tmp = NULL;
PyObject *im_unicode_tmp = NULL;
/* Locale settings, either from the actual locale or
from a hard-code pseudo-locale */
LocaleInfo locale = STATIC_LOCALE_INFO_INIT;
if (format->precision > INT_MAX) {
PyErr_SetString(PyExc_ValueError, "precision too big");
goto done;
}
precision = (int)format->precision;
/* Zero padding is not allowed. */
if (format->fill_char == '0') {
PyErr_SetString(PyExc_ValueError,
"Zero padding is not allowed in complex format "
"specifier");
goto done;
}
/* Neither is '=' alignment . */
if (format->align == '=') {
PyErr_SetString(PyExc_ValueError,
"'=' alignment flag is not allowed in complex format "
"specifier");
goto done;
}
re = PyComplex_RealAsDouble(value);
if (re == -1.0 && PyErr_Occurred())
goto done;
im = PyComplex_ImagAsDouble(value);
if (im == -1.0 && PyErr_Occurred())
goto done;
if (format->alternate)
flags |= Py_DTSF_ALT;
if (type == '\0') {
/* Omitted type specifier. Should be like str(self). */
type = 'r';
default_precision = 0;
if (re == 0.0 && copysign(1.0, re) == 1.0)
skip_re = 1;
else
add_parens = 1;
}
if (type == 'n')
/* 'n' is the same as 'g', except for the locale used to
format the result. We take care of that later. */
type = 'g';
if (precision < 0)
precision = default_precision;
else if (type == 'r')
type = 'g';
/* Cast "type", because if we're in unicode we need to pass a
8-bit char. This is safe, because we've restricted what "type"
can be. */
re_buf = PyOS_double_to_string(re, (char)type, precision, flags,
&re_float_type);
if (re_buf == NULL)
goto done;
im_buf = PyOS_double_to_string(im, (char)type, precision, flags,
&im_float_type);
if (im_buf == NULL)
goto done;
n_re_digits = strlen(re_buf);
n_im_digits = strlen(im_buf);
/* Since there is no unicode version of PyOS_double_to_string,
just use the 8 bit version and then convert to unicode. */
re_unicode_tmp = _PyUnicode_FromASCII(re_buf, n_re_digits);
if (re_unicode_tmp == NULL)
goto done;
i_re = 0;
im_unicode_tmp = _PyUnicode_FromASCII(im_buf, n_im_digits);
if (im_unicode_tmp == NULL)
goto done;
i_im = 0;
/* Is a sign character present in the output? If so, remember it
and skip it */
if (PyUnicode_READ_CHAR(re_unicode_tmp, i_re) == '-') {
re_sign_char = '-';
++i_re;
--n_re_digits;
}
if (PyUnicode_READ_CHAR(im_unicode_tmp, i_im) == '-') {
im_sign_char = '-';
++i_im;
--n_im_digits;
}
/* Determine if we have any "remainder" (after the digits, might include
decimal or exponent or both (or neither)) */
parse_number(re_unicode_tmp, i_re, i_re + n_re_digits,
&n_re_remainder, &re_has_decimal);
parse_number(im_unicode_tmp, i_im, i_im + n_im_digits,
&n_im_remainder, &im_has_decimal);
/* Determine the grouping, separator, and decimal point, if any. */
if (get_locale_info(format->type == 'n' ? LT_CURRENT_LOCALE :
(format->thousands_separators ?
LT_DEFAULT_LOCALE :
LT_NO_LOCALE),
&locale) == -1)
goto done;
/* Turn off any padding. We'll do it later after we've composed
the numbers without padding. */
tmp_format.fill_char = '\0';
tmp_format.align = '<';
tmp_format.width = -1;
/* Calculate how much memory we'll need. */
n_re_total = calc_number_widths(&re_spec, 0, re_sign_char, re_unicode_tmp,
i_re, i_re + n_re_digits, n_re_remainder,
re_has_decimal, &locale, &tmp_format,
&maxchar);
/* Same formatting, but always include a sign, unless the real part is
* going to be omitted, in which case we use whatever sign convention was
* requested by the original format. */
if (!skip_re)
tmp_format.sign = '+';
n_im_total = calc_number_widths(&im_spec, 0, im_sign_char, im_unicode_tmp,
i_im, i_im + n_im_digits, n_im_remainder,
im_has_decimal, &locale, &tmp_format,
&maxchar);
if (skip_re)
n_re_total = 0;
/* Add 1 for the 'j', and optionally 2 for parens. */
calc_padding(n_re_total + n_im_total + 1 + add_parens * 2,
format->width, format->align, &lpad, &rpad, &total);
if (lpad || rpad)
maxchar = Py_MAX(maxchar, format->fill_char);
if (_PyUnicodeWriter_Prepare(writer, total, maxchar) == -1)
goto done;
rkind = writer->kind;
rdata = writer->data;
/* Populate the memory. First, the padding. */
result = fill_padding(writer,
n_re_total + n_im_total + 1 + add_parens * 2,
format->fill_char, lpad, rpad);
if (result == -1)
goto done;
if (add_parens) {
PyUnicode_WRITE(rkind, rdata, writer->pos, '(');
writer->pos++;
}
if (!skip_re) {
result = fill_number(writer, &re_spec,
re_unicode_tmp, i_re, i_re + n_re_digits,
NULL, 0,
0,
&locale, 0);
if (result == -1)
goto done;
}
result = fill_number(writer, &im_spec,
im_unicode_tmp, i_im, i_im + n_im_digits,
NULL, 0,
0,
&locale, 0);
if (result == -1)
goto done;
PyUnicode_WRITE(rkind, rdata, writer->pos, 'j');
writer->pos++;
if (add_parens) {
PyUnicode_WRITE(rkind, rdata, writer->pos, ')');
writer->pos++;
}
writer->pos += rpad;
done:
PyMem_Free(re_buf);
PyMem_Free(im_buf);
Py_XDECREF(re_unicode_tmp);
Py_XDECREF(im_unicode_tmp);
free_locale_info(&locale);
return result;
}
ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
strptime (const char *buf, const char *format, struct tm *timeptr)
{
char c;
for (; (c = *format) != '\0'; ++format) {
char *s;
int ret;
if (isspace ((unsigned char)c)) {
while (isspace ((unsigned char)*buf))
++buf;
} else if (c == '%' && format[1] != '\0') {
c = *++format;
if (c == 'E' || c == 'O')
c = *++format;
switch (c) {
case 'A' :
ret = match_string (&buf, full_weekdays);
if (ret < 0)
return NULL;
timeptr->tm_wday = ret;
break;
case 'a' :
ret = match_string (&buf, abb_weekdays);
if (ret < 0)
return NULL;
timeptr->tm_wday = ret;
break;
case 'B' :
ret = match_string (&buf, full_month);
if (ret < 0)
return NULL;
timeptr->tm_mon = ret;
break;
case 'b' :
case 'h' :
ret = match_string (&buf, abb_month);
if (ret < 0)
return NULL;
timeptr->tm_mon = ret;
break;
case 'C' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_year = (ret * 100) - tm_year_base;
break;
case 'c' :
abort ();
case 'D' : /* %m/%d/%y */
s = strptime (buf, "%m/%d/%y", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'd' :
case 'e' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_mday = ret;
break;
case 'H' :
case 'k' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_hour = ret;
break;
case 'I' :
case 'l' :
if (parse_number(&buf, 2, &ret))
return NULL;
if (ret == 12)
timeptr->tm_hour = 0;
else
timeptr->tm_hour = ret;
break;
case 'j' :
if (parse_number(&buf, 3, &ret))
return NULL;
if (ret == 0)
return NULL;
timeptr->tm_yday = ret - 1;
break;
case 'm' :
if (parse_number(&buf, 2, &ret))
return NULL;
if (ret == 0)
return NULL;
timeptr->tm_mon = ret - 1;
break;
case 'M' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_min = ret;
break;
case 'n' :
while (isspace ((unsigned char)*buf))
buf++;
break;
case 'p' :
ret = match_string (&buf, ampm);
if (ret < 0)
return NULL;
if (timeptr->tm_hour == 0) {
if (ret == 1)
timeptr->tm_hour = 12;
} else
timeptr->tm_hour += 12;
break;
case 'r' : /* %I:%M:%S %p */
s = strptime (buf, "%I:%M:%S %p", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'R' : /* %H:%M */
s = strptime (buf, "%H:%M", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'S' :
if (parse_number(&buf, 2, &ret))
return NULL;
timeptr->tm_sec = ret;
break;
case 't' :
while (isspace ((unsigned char)*buf))
buf++;
break;
case 'T' : /* %H:%M:%S */
case 'X' :
s = strptime (buf, "%H:%M:%S", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'u' :
if (parse_number(&buf, 1, &ret))
return NULL;
if (ret <= 0)
return NULL;
timeptr->tm_wday = ret - 1;
break;
case 'w' :
if (parse_number(&buf, 1, &ret))
return NULL;
timeptr->tm_wday = ret;
break;
case 'U' :
if (parse_number(&buf, 2, &ret))
return NULL;
set_week_number_sun (timeptr, ret);
break;
case 'V' :
if (parse_number(&buf, 2, &ret))
return NULL;
set_week_number_mon4 (timeptr, ret);
break;
case 'W' :
if (parse_number(&buf, 2, &ret))
return NULL;
set_week_number_mon (timeptr, ret);
break;
case 'x' :
s = strptime (buf, "%Y:%m:%d", timeptr);
if (s == NULL)
return NULL;
buf = s;
break;
case 'y' :
if (parse_number(&buf, 2, &ret))
return NULL;
if (ret < 70)
timeptr->tm_year = 100 + ret;
else
timeptr->tm_year = ret;
break;
case 'Y' :
if (parse_number(&buf, 4, &ret))
return NULL;
timeptr->tm_year = ret - tm_year_base;
break;
case 'Z' :
abort ();
case '\0' :
--format;
/* FALLTHROUGH */
case '%' :
if (*buf == '%')
++buf;
else
return NULL;
break;
default :
if (*buf == '%' || *++buf == c)
++buf;
else
return NULL;
break;
}
} else {
if (*buf == c)
++buf;
else
return NULL;
}
}
return rk_UNCONST(buf);
}
bool parser::parse_value(context& ctx, value_type& value, IteratorType& ch, IteratorType end)
{
bool result = false;
if (ch != end)
{
switch (*ch)
{
case '{':
{
object_type object;
result = parse_object(ctx, object, ch, end);
if (result) { value = object; }
break;
}
case '[':
{
array_type array;
result = parse_array(ctx, array, ch, end);
if (result) { value = array; }
break;
}
case '"':
{
string_type str;
result = parse_string(ctx, str, ch, end);
if (result) { value = str; }
break;
}
case 't':
case 'f':
{
boolean_type bt;
result = parse_boolean(ctx, bt, ch, end);
if (result) { value = bt; }
break;
}
case 'n':
{
null_type nt;
result = parse_null(ctx, nt, ch, end);
if (result) { value = nt; }
break;
}
default:
{
number_type nb;
result = parse_number(ctx, nb, ch, end);
if (result) { value = nb; }
break;
}
}
}
return result;
}