int isClaimedIDE(char *model)
{
char tmparray[MAXARRAY][MAXARRSIZE];
int tmpidx;
unsigned long size=0;
int i;
tmpidx=parse_array("/tmp/diskstatus", "claimed_disk_interface_names", tmparray);
for (i=0;i<tmpidx;i++)
{
printf("%d:%s\n", i, &tmparray[i][0]);
if (strstr(&tmparray[i][0], "IDE")) break;
}
if (i==tmpidx) return 0;
tmpidx=parse_array("/tmp/diskstatus", "claimed_disk_total_size", tmparray);
if (i>=tmpidx) return 0;
size = atoi(&tmparray[i][0]);
tmpidx=parse_array("/tmp/diskstatus", "claimed_disk_model_info", tmparray);
if (i>=tmpidx) return 0;
strcpy(model, &tmparray[i][0]);
return size;
}
int JSON::parse_value(const char *begin, const char *end, JSON::Node *node)
{
char const *ptr = begin;
int n;
ptr += scan_space(ptr, end);
if (ptr < end) {
if (*ptr == '[') {
ptr++;
node->type = Type::Array;
n = parse_array(ptr, end, false, &node->children);
ptr += n;
if (ptr < end && *ptr == ']') {
ptr++;
return ptr - begin;
}
} else if (*ptr == '{') {
ptr++;
node->type = Type::Object;
n = parse_array(ptr, end, true, &node->children);
ptr += n;
if (ptr < end && *ptr == '}') {
ptr++;
return ptr - begin;
}
} else if (*ptr == '\"') {
n = parse_string(ptr, end, &node->value);
if (n > 0) {
ptr += n;
node->type = Type::String;
return ptr - begin;
}
} else {
char const *left = ptr;
while (ptr < end) {
int c = *ptr & 0xff;
if (isspace(c)) break;
if (strchr("[]{},:\"", c)) break;
ptr++;
}
if (left < ptr) {
std::string value(left, ptr);
if (value == "null") {
node->type = Type::Null;
} else if (value == "false") {
node->type = Type::Boolean;
node->value = "0";
} else if (value == "true") {
node->type = Type::Boolean;
node->value = "1";
} else {
node->type = Type::Number;
node->value = value;
}
return ptr - begin;
}
}
}
return 0;
}
static void
parse_array_element(JsonLexContext *lex, JsonSemAction *sem)
{
json_aelem_action astart = sem->array_element_start;
json_aelem_action aend = sem->array_element_end;
JsonTokenType tok = lex_peek(lex);
bool isnull;
isnull = tok == JSON_TOKEN_NULL;
if (astart != NULL)
(*astart) (sem->semstate, isnull);
/* an array element is any object, array or scalar */
switch (tok)
{
case JSON_TOKEN_OBJECT_START:
parse_object(lex, sem);
break;
case JSON_TOKEN_ARRAY_START:
parse_array(lex, sem);
break;
default:
parse_scalar(lex, sem);
}
if (aend != NULL)
(*aend) (sem->semstate, isnull);
}
// value = 'null' | 'true' | 'false' | number | string | array | object
static int parse_value(struct frozen *f) {
int ch = cur(f);
if (ch == '"') {
TRY(parse_string(f));
} else if (ch == '{') {
TRY(parse_object(f));
} else if (ch == '[') {
TRY(parse_array(f));
} else if (ch == 'n' && left(f) > 4 && compare(f->cur, "null", 4)) {
TRY(capture_ptr(f, f->cur, JSON_TYPE_NULL));
f->cur += 4;
capture_len(f, f->num_tokens - 1, f->cur);
} else if (ch == 't' && left(f) > 4 && compare(f->cur, "true", 4)) {
TRY(capture_ptr(f, f->cur, JSON_TYPE_TRUE));
f->cur += 4;
capture_len(f, f->num_tokens - 1, f->cur);
} else if (ch == 'f' && left(f) > 5 && compare(f->cur, "false", 5)) {
TRY(capture_ptr(f, f->cur, JSON_TYPE_FALSE));
f->cur += 5;
capture_len(f, f->num_tokens - 1, f->cur);
} else if (is_digit(ch) ||
(ch == '-' && f->cur + 1 < f->end && is_digit(f->cur[1]))) {
TRY(parse_number(f));
} else {
return ch == END_OF_STRING ? JSON_STRING_INCOMPLETE : JSON_STRING_INVALID;
}
return 0;
}
json parser::parse_next(
const std::string& input, size_t& offset, std::error_code& error)
{
char value;
consume_white_space(input, offset, error);
value = input[offset];
switch (value)
{
case '[': return parse_array(input, offset, error);
case '{': return parse_object(input, offset, error);
case '\"': return parse_string(input, offset, error);
case 't':
case 'f': return parse_bool(input, offset, error);
case 'n': return parse_null(input, offset, error);
default:
{
if ((value <= '9' && value >= '0') || value == '-')
{
return parse_number(input, offset, error);
}
}
}
// Error: Unknown starting character
error = std::make_error_code(std::errc::invalid_argument);
return json();
}
/*
* pg_parse_json
*
* Publicly visible entry point for the JSON parser.
*
* lex is a lexing context, set up for the json to be processed by calling
* makeJsonLexContext(). sem is a strucure of function pointers to semantic
* action routines to be called at appropriate spots during parsing, and a
* pointer to a state object to be passed to those routines.
*/
void
pg_parse_json(JsonLexContext *lex, JsonSemAction *sem)
{
JsonTokenType tok;
/* get the initial token */
json_lex(lex);
tok = lex_peek(lex);
/* parse by recursive descent */
switch (tok)
{
case JSON_TOKEN_OBJECT_START:
parse_object(lex, sem);
break;
case JSON_TOKEN_ARRAY_START:
parse_array(lex, sem);
break;
default:
parse_scalar(lex, sem); /* json can be a bare scalar */
}
lex_expect(JSON_PARSE_END, lex, JSON_TOKEN_END);
}
static void parse_key_value(int indent, json_obj_t * kv){
if(kv->type != JSON_KEY_VALUE_PAIR){
printf("%d: unexpected type %d\n", __LINE__, kv->type);
return;
}
json_obj_t * key = kv->children;
json_obj_t * value = kv->children->next_sibling;
printf("%*s%.*s",IDENT(indent), "", key->length, key->str);
switch(value->type){
case JSON_STRING:
printf(" -> %.*s\n", value->length, value->str);
break;
case JSON_PRIMITIVE:
printf(" -> %.*s\n", value->length, value->str);
break;
case JSON_OBJECT:
printf("\n");
parse_object(indent + 1, value);
printf("\n");
break;
case JSON_ARRAY:
printf("\n");
parse_array(indent + 1, value);
printf("\n");
break;
default:
printf("%d: unexpected type %d in array\n", __LINE__, value->type);
return;
}
}
void config_file::parse_key(config_file::value& value, std::string& key, const std::string& strvalue)
{
value::value_type keytype = config_file::parse_keytype(key);
value.type_ = keytype;
if(keytype == value::RAW_VALUE){
value.raw_value_ = strvalue;
}
else if(keytype == value::ARRAY){
size_t index;
bool ret_val = parse_array(key, index);
if(index>=value.array_.size())
{
value.array_.resize(index + 1);
}
parse_key(value.array_[index], key, strvalue);
}
else if(keytype == value::RECORD){
std::string recordname = parse_record_name(key);
mapi it = value.record_.find(recordname);
if(it == value.record_.end()){
config_file::value new_value;
parse_key(new_value, key, strvalue);
value.record_.insert(mapt::value_type(recordname, new_value));
}
else{
parse_key(it->second, key, strvalue);
}
}
}
int main(int argc, char **argv) {
char *buf;
if(read_json_file(&buf, JSON_FILE)!=0){
printf("failed to read fixture\n");
if(buf != NULL){
free(buf);
}
return 1;
}
json_context_t ctx;
json_init_context(&ctx, buf);
json_obj_t * res = NULL;
res = json_read_array(NULL, &ctx);
parse_array(1, res);
json_object_destroy(res, &ctx);
if(buf != NULL){
free(buf);
}
return 0;
}
// build JSON object hierarchy
JSON * JSON::parse_private(Lexer *lexer)
{
// check token to determine what JSON type to construct
Json_Token token = lexer->get_token();
switch (token)
{
case Object_start_token:
return parse_object(lexer);
case Array_start_token:
return parse_array(lexer);
case String_token:
return new_string(lexer->token_src, lexer->token_len);
case Null_token:
return new_null();
case True_token:
return new_boolean(true);
case False_token:
return new_boolean(false);
case Float_token:
return new_float(lexer->float_num);
case Unsigned_token:
return new_unsigned(lexer->unsigned_num);
case Signed_token:
return new_signed(lexer->signed_num);
default:
Serial.println(F("JSON syntax error"));
}
return null;
}
static ZZJSON *parse_value(ZZJSON_CONFIG *config) {
ZZJSON *retval = NULL;
int c;
SKIPWS();
c = GETC();
UNGETC(c);
switch (c) {
case '"': retval = parse_string2(config); break;
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9': case '-':
retval = parse_number(config); break;
case '{': retval = parse_object(config); break;
case '[': retval = parse_array(config); break;
case 't': retval = parse_true(config); break;
case 'f': retval = parse_false(config); break;
case 'n': retval = parse_null(config); break;
}
if (!retval) {
ERROR("value: invalid value");
return retval;
}
return retval;
}
/* Parser core - when encountering text, process appropriately. */
static const char *parse_value(srjson_doc_t *doc, srjson_t *item, const char *value)
{
if (!value)
return 0; /* Fail on null. */
if (!strncmp(value, "null", 4)) {
item->type = srjson_NULL;
item->valuedouble = 0;
return value + 4;
}
if (!strncmp(value, "false", 5)) {
item->type = srjson_False;
item->valuedouble = 0;
return value + 5;
}
if (!strncmp(value, "true", 4)) {
item->type = srjson_True;
item->valuedouble = 1;
return value + 4;
}
if (*value == '\"') {
return parse_string(doc, item, value);
}
if (*value == '-' || (*value >= '0' && *value <= '9')) {
return parse_number(doc, item, value);
}
if (*value == '[') {
return parse_array(doc, item, value);
}
if (*value == '{') {
return parse_object(doc, item, value);
}
ep = value;
return 0; /* failure. */
}
/* Parser core - when encountering text, process appropriately. */
static const char *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. */
}
/* Parser core - when encountering text, process appropriately. */
static const char* parse_value (json *item, const char* value) {
/* Referenced by json_create(), parse_array(), and parse_object(). */
/* Always called with the result of skip(). */
#if SPINE_JSON_DEBUG /* Checked at entry to graph, json_create, and after every parse_ call. */
if (!value) return 0; /* Fail on null. */
#endif
switch (*value) {
case 'n': {
if (!strncmp(value + 1, "ull", 3)) {
item->type = json_NULL;
return value + 4;
}
break;
}
case 'f': {
if (!strncmp(value + 1, "alse", 4)) {
item->type = json_False;
/* calloc prevents us needing item->type = json_False or valueInt = 0 here */
return value + 5;
}
break;
}
case 't': {
if (!strncmp(value + 1, "rue", 3)) {
item->type = json_True;
item->valueInt = 1;
return value + 4;
}
break;
}
case '\"':
return parse_string(item, value);
case '[':
return parse_array(item, value);
case '{':
return parse_object(item, value);
case '-': /* fallthrough */
case '0': /* fallthrough */
case '1': /* fallthrough */
case '2': /* fallthrough */
case '3': /* fallthrough */
case '4': /* fallthrough */
case '5': /* fallthrough */
case '6': /* fallthrough */
case '7': /* fallthrough */
case '8': /* fallthrough */
case '9':
return parse_number(item, value);
default:
break;
}
ep = value;
return 0; /* failure. */
}
TilingPatternImpl::TilingPatternImpl(DocWriterImpl& doc,
Char const* pattern_str,
ICanvas* canvas)
: PatternBase(pattern_str)
, m_doc(doc)
, m_canvas(checked_static_cast<CanvasImpl*>(canvas))
{
if (m_canvas->content_stream().is_empty())
throw exception_invalid_value(msg_pattern_no_canvas()) << JAGLOC;
IProfileInternal const& profile = m_doc.exec_context().config();
m_tiling_type = static_cast<PatternTilingType>(
profile.get_int("patterns.tiling_type"));
reset_indirect_object_worker(m_canvas);
// parse the string spec
try
{
ParsedResult const& p =
parse_options(pattern_str,
ParseArgs(&g_tiling_keywords));
parse_array(p, TIP_MATRIX, m_matrix, true, 6);
parse_array(p, TIP_STEP, m_step, false, 2);
if (!parse_array(p, TIP_BBOX, m_bbox, true, 4))
{
// if bbox not set, set it to [0, 0, stepx, stepy]
m_bbox[0] = m_bbox[1] = 0;
m_bbox[2] = m_step[0];
m_bbox[3] = m_step[1];
}
m_tiling_type = static_cast<PatternTilingType>(
p.to_<int>(TIP_TYPE, m_tiling_type));
}
catch(exception const& exc)
{
throw exception_invalid_value(
msg_invalid_shading_spec(), &exc) << JAGLOC;
}
}
static heim_object_t
parse_value(struct parse_ctx *ctx)
{
size_t len;
heim_object_t o;
if (white_spaces(ctx))
return NULL;
if (*ctx->p == '"') {
return parse_string(ctx);
} else if (*ctx->p == '{') {
if (ctx->depth-- == 1) {
ctx->error = heim_error_create(EINVAL, "JSON object too deep");
return NULL;
}
o = parse_dict(ctx);
ctx->depth++;
return o;
} else if (*ctx->p == '[') {
if (ctx->depth-- == 1) {
ctx->error = heim_error_create(EINVAL, "JSON object too deep");
return NULL;
}
o = parse_array(ctx);
ctx->depth++;
return o;
} else if (is_number(*ctx->p) || *ctx->p == '-') {
return parse_number(ctx);
}
len = ctx->pend - ctx->p;
if ((ctx->flags & HEIM_JSON_F_NO_C_NULL) == 0 &&
len >= 6 && memcmp(ctx->p, "<NULL>", 6) == 0) {
ctx->p += 6;
return heim_null_create();
} else 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 json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
{
json_t *json;
switch(lex->token) {
case TOKEN_STRING: {
json = json_string_nocheck(lex->value.string);
break;
}
case TOKEN_INTEGER: {
json = json_integer(lex->value.integer);
break;
}
case TOKEN_REAL: {
json = json_real(lex->value.real);
break;
}
case TOKEN_TRUE:
json = json_true();
break;
case TOKEN_FALSE:
json = json_false();
break;
case TOKEN_NULL:
json = json_null();
break;
case '{':
json = parse_object(lex, flags, error);
break;
case '[':
json = parse_array(lex, flags, error);
break;
case TOKEN_INVALID:
error_set(error, lex, "invalid token");
return NULL;
default:
error_set(error, lex, "unexpected token");
return NULL;
}
if(!json)
return NULL;
return json;
}
// Parser core - when encountering text, process appropriately.
const char *parse_value(JSON *item,const char *value)
{
if (!value) return 0; // Fail on null.
if (!strncmp(value,"null",4)) { item->type=JSON_NULL; return value+4; }
if (!strncmp(value,"false",5)) { item->type=JSON_FALSE; return value+5; }
if (!strncmp(value,"true",4)) { item->type=JSON_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); }
return 0; // failure.
}
int main (void) {
// Read the array in first
int ** matrix = malloc (sizeof (int*) * DIMENSIONS);
int index = 0;
while (index < DIMENSIONS) {
matrix[index] = malloc (sizeof (int) * DIMENSIONS);
index++;
}
srand (time(NULL));
int col = 0;
while (col < DIMENSIONS) {
int row = 0;
while (row < DIMENSIONS) {
int value = rand() % 100;
if (value < 100-FREQUENCY) {
matrix[col][row] = 0;
} else {
matrix[col][row] = 1;
}
row++;
}
col++;
}
// Show the matrix
show_array (matrix);
// Keep track of values in an array
int nextFree = 0;
int * areas = malloc (sizeof (int) * DIMENSIONS * DIMENSIONS);
// Parse matrix
parse_array (matrix, areas, &nextFree);
// See what values we come up with
index = 0;
printf ("AREAS: ");
while (index < nextFree) {
printf ("%d ", areas[index]);
index++;
}
printf("\n");
// Perform quick select for median.
printf ("Median Area: %d\n", quickselect (areas, nextFree - 1));
return EXIT_SUCCESS;
}
ShadingImpl::ShadingImpl(DocWriterImpl& doc,
Char const* pattern,
ColorSpaceHandle cs,
FunctionHandle const* fns,
UInt num_functions)
: IndirectObjectImpl(doc)
, m_cs(cs)
{
// Indexed is not allowed for dictionaries with Function field. Shading
// types supported now require Function field so indexed color space is
// forbidden.
if (is_pattern_color_space(cs) || (CS_INDEXED == color_space_type(cs)))
throw exception_invalid_value(msg_shading_invalid_space()) << JAGLOC;
m_function_handles.resize(num_functions);
std::copy(fns, fns + num_functions, m_function_handles.begin());
try
{
ParsedResult const& p =
parse_options(pattern, ParseArgs(&g_shading_keywords, &g_shading_values));
// common options matrix
parse_array(p, SH_BBOX, m_bbox, true, 4);
parse_array(p, SH_BACKGROUND, m_background);
// shading type specific
m_shading_type = p.explicit_value();
switch(m_shading_type)
{
case SHV_AXIAL:
case SHV_RADIAL:
parse_array(p, SH_COORDS, m_coords, false, m_shading_type==SHV_AXIAL ? 4 : 6);
parse_array(p, SH_DOMAIN, m_domain, true, 2);
if (parse_array(p, SH_EXTEND, m_extend, true, 2)) m_keys.set(BIT_EXTEND);
break;
case SHV_FUNCTION:
parse_array(p, SH_MATRIX_FUN, m_matrix_fun, true, 6);
parse_array(p, SH_DOMAIN, m_domain, true, 4);
break;
default:
throw exception_invalid_value(msg_unknown_shading_type()) << JAGLOC;
}
}
catch(exception const& exc)
{
throw exception_invalid_value(msg_invalid_shading_spec(), &exc) << JAGLOC;
}
}
static int doit(struct frozen *f) {
int ret = 0;
if (f->cur == 0 || f->end < f->cur) return JSON_STRING_INVALID;
if (f->end == f->cur) return JSON_STRING_INCOMPLETE;
if (0 == (ret = test_no_skip(f, '{'))) {
TRY(parse_object(f));
} else if (0 == (ret = test_no_skip(f, '['))) {
TRY(parse_array(f));
} else {
return ret;
}
return 0;
}
static void
parse_object_field(JsonLexContext *lex, JsonSemAction *sem)
{
/*
* an object field is "fieldname" : value where value can be a scalar,
* object or array
*/
char *fname = NULL; /* keep compiler quiet */
json_ofield_action ostart = sem->object_field_start;
json_ofield_action oend = sem->object_field_end;
bool isnull;
char **fnameaddr = NULL;
JsonTokenType tok;
if (ostart != NULL || oend != NULL)
fnameaddr = &fname;
if (!lex_accept(lex, JSON_TOKEN_STRING, fnameaddr))
report_parse_error(JSON_PARSE_STRING, lex);
lex_expect(JSON_PARSE_OBJECT_LABEL, lex, JSON_TOKEN_COLON);
tok = lex_peek(lex);
isnull = tok == JSON_TOKEN_NULL;
if (ostart != NULL)
(*ostart) (sem->semstate, fname, isnull);
switch (tok)
{
case JSON_TOKEN_OBJECT_START:
parse_object(lex, sem);
break;
case JSON_TOKEN_ARRAY_START:
parse_array(lex, sem);
break;
default:
parse_scalar(lex, sem);
}
if (oend != NULL)
(*oend) (sem->semstate, fname, isnull);
if (fname != NULL)
pfree(fname);
}
/* 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 NULL;
}
/* 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);
}
/* failure. */
*ep = value;
return NULL;
}
int isPrinter(char *model1, char *model2)
{
char tmparray[MAXARRAY][MAXARRSIZE];
int tmpidx;
unsigned long size=0;
int i;
tmpidx=parse_array("/tmp/diskstatus", "printer_models", tmparray);
if (tmpidx<=0) return 0;
if (tmpidx>=1)
strcpy(model1, &tmparray[0][0]);
if (tmpidx>=2)
strcpy(model2, &tmparray[1][0]);
return tmpidx;
}
int parse_value(const char** input, JzonValue* output, JzonAllocator* allocator)
{
skip_whitespace(input);
char ch = current(input);
switch (ch)
{
case '{': return parse_object(input, output, false, allocator);
case '[': return parse_array(input, output, allocator);
case '"': return parse_string(input, output, allocator);
case '-': return parse_number(input, output);
case 'f': return parse_false(input, output);
case 't': return parse_true(input, output);
case 'n': return parse_null(input, output);
default: return ch >= '0' && ch <= '9' ? parse_number(input, output) : -1;
}
}
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() );
}
ShadingPatternImpl::ShadingPatternImpl(DocWriterImpl& doc,
Char const* pattern,
ShadingHandle shading)
: IndirectObjectImpl(doc)
, PatternBase(pattern)
, m_shading(shading)
{
try
{
ParsedResult const& p =
parse_options(pattern, ParseArgs(&g_shading_keywords, &g_shading_values));
parse_array(p, SH_MATRIX, m_matrix, true, 6);
}
catch(exception const& exc)
{
throw exception_invalid_value(msg_invalid_shading_spec(), &exc) << JAGLOC;
}
}
/* 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;
}
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");
}
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 );
}
}
