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