1 /*
2 * $Id: json_tokener.c,v 1.20 2006/07/25 03:24:50 mclark Exp $
3 *
4 * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.
5 * Michael Clark <michael@metaparadigm.com>
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the MIT license. See COPYING for details.
9 *
10 *
11 * Copyright (c) 2008-2009 Yahoo! Inc. All rights reserved.
12 * The copyrights to the contents of this file are licensed under the MIT License
13 * (http://www.opensource.org/licenses/mit-license.php)
14 */
15
16 #include "config.h"
17
18 #include <math.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <stddef.h>
22 #include <ctype.h>
23 #include <string.h>
24 #include <limits.h>
25
26 #include "debug.h"
27 #include "printbuf.h"
28 #include "arraylist.h"
29 #include "json_inttypes.h"
30 #include "json_object.h"
31 #include "json_tokener.h"
32 #include "json_util.h"
33
34 #ifdef HAVE_LOCALE_H
35 #include <locale.h>
36 #endif /* HAVE_LOCALE_H */
37
38 #define jt_hexdigit(x) (((x) <= '9') ? (x) - '0' : ((x) & 7) + 9)
39
40 #if !HAVE_STRDUP && defined(_MSC_VER)
41 /* MSC has the version as _strdup */
42 # define strdup _strdup
43 #elif !HAVE_STRDUP
44 # error You do not have strdup on your system.
45 #endif /* HAVE_STRDUP */
46
47 #if !HAVE_STRNCASECMP && defined(_MSC_VER)
48 /* MSC has the version as _strnicmp */
49 # define strncasecmp _strnicmp
50 #elif !HAVE_STRNCASECMP
51 # error You do not have strncasecmp on your system.
52 #endif /* HAVE_STRNCASECMP */
53
54 /* Use C99 NAN by default; if not available, nan("") should work too. */
55 #ifndef NAN
56 #define NAN nan("")
57 #endif /* !NAN */
58
59 static const char json_null_str[] = "null";
60 static const int json_null_str_len = sizeof(json_null_str) - 1;
61 static const char json_inf_str[] = "Infinity";
62 static const int json_inf_str_len = sizeof(json_inf_str) - 1;
63 static const char json_nan_str[] = "NaN";
64 static const int json_nan_str_len = sizeof(json_nan_str) - 1;
65 static const char json_true_str[] = "true";
66 static const int json_true_str_len = sizeof(json_true_str) - 1;
67 static const char json_false_str[] = "false";
68 static const int json_false_str_len = sizeof(json_false_str) - 1;
69
70 static const char* json_tokener_errors[] = {
71 "success",
72 "continue",
73 "nesting too deep",
74 "unexpected end of data",
75 "unexpected character",
76 "null expected",
77 "boolean expected",
78 "number expected",
79 "array value separator ',' expected",
80 "quoted object property name expected",
81 "object property name separator ':' expected",
82 "object value separator ',' expected",
83 "invalid string sequence",
84 "expected comment",
85 "buffer size overflow"
86 };
87
json_tokener_error_desc(enum json_tokener_error jerr)88 const char *json_tokener_error_desc(enum json_tokener_error jerr)
89 {
90 int jerr_int = (int)jerr;
91 if (jerr_int < 0 || jerr_int >= (int)(sizeof(json_tokener_errors) / sizeof(json_tokener_errors[0])))
92 return "Unknown error, invalid json_tokener_error value passed to json_tokener_error_desc()";
93 return json_tokener_errors[jerr];
94 }
95
json_tokener_get_error(json_tokener * tok)96 enum json_tokener_error json_tokener_get_error(json_tokener *tok)
97 {
98 return tok->err;
99 }
100
101 /* Stuff for decoding unicode sequences */
102 #define IS_HIGH_SURROGATE(uc) (((uc) & 0xFC00) == 0xD800)
103 #define IS_LOW_SURROGATE(uc) (((uc) & 0xFC00) == 0xDC00)
104 #define DECODE_SURROGATE_PAIR(hi,lo) ((((hi) & 0x3FF) << 10) + ((lo) & 0x3FF) + 0x10000)
105 static unsigned char utf8_replacement_char[3] = { 0xEF, 0xBF, 0xBD };
106
json_tokener_new_ex(int depth)107 struct json_tokener* json_tokener_new_ex(int depth)
108 {
109 struct json_tokener *tok;
110
111 tok = (struct json_tokener*)calloc(1, sizeof(struct json_tokener));
112 if (!tok) return NULL;
113 tok->stack = (struct json_tokener_srec *)calloc(depth, sizeof(struct json_tokener_srec));
114 if (!tok->stack) {
115 free(tok);
116 return NULL;
117 }
118 tok->pb = printbuf_new();
119 tok->max_depth = depth;
120 json_tokener_reset(tok);
121 return tok;
122 }
123
json_tokener_new(void)124 struct json_tokener* json_tokener_new(void)
125 {
126 return json_tokener_new_ex(JSON_TOKENER_DEFAULT_DEPTH);
127 }
128
json_tokener_free(struct json_tokener * tok)129 void json_tokener_free(struct json_tokener *tok)
130 {
131 json_tokener_reset(tok);
132 if (tok->pb) printbuf_free(tok->pb);
133 if (tok->stack) free(tok->stack);
134 free(tok);
135 }
136
json_tokener_reset_level(struct json_tokener * tok,int depth)137 static void json_tokener_reset_level(struct json_tokener *tok, int depth)
138 {
139 tok->stack[depth].state = json_tokener_state_eatws;
140 tok->stack[depth].saved_state = json_tokener_state_start;
141 json_object_put(tok->stack[depth].current);
142 tok->stack[depth].current = NULL;
143 free(tok->stack[depth].obj_field_name);
144 tok->stack[depth].obj_field_name = NULL;
145 }
146
json_tokener_reset(struct json_tokener * tok)147 void json_tokener_reset(struct json_tokener *tok)
148 {
149 int i;
150 if (!tok)
151 return;
152
153 for(i = tok->depth; i >= 0; i--)
154 json_tokener_reset_level(tok, i);
155 tok->depth = 0;
156 tok->err = json_tokener_success;
157 }
158
json_tokener_parse(const char * str)159 struct json_object* json_tokener_parse(const char *str)
160 {
161 enum json_tokener_error jerr_ignored;
162 struct json_object* obj;
163 obj = json_tokener_parse_verbose(str, &jerr_ignored);
164 return obj;
165 }
166
json_tokener_parse_verbose(const char * str,enum json_tokener_error * error)167 struct json_object* json_tokener_parse_verbose(const char *str, enum json_tokener_error *error)
168 {
169 struct json_tokener* tok;
170 struct json_object* obj;
171
172 tok = json_tokener_new();
173 if (!tok)
174 return NULL;
175 obj = json_tokener_parse_ex(tok, str, -1);
176 *error = tok->err;
177 if(tok->err != json_tokener_success) {
178 if (obj != NULL)
179 json_object_put(obj);
180 obj = NULL;
181 }
182
183 json_tokener_free(tok);
184 return obj;
185 }
186
187 #define state tok->stack[tok->depth].state
188 #define saved_state tok->stack[tok->depth].saved_state
189 #define current tok->stack[tok->depth].current
190 #define obj_field_name tok->stack[tok->depth].obj_field_name
191
192 /* Optimization:
193 * json_tokener_parse_ex() consumed a lot of CPU in its main loop,
194 * iterating character-by character. A large performance boost is
195 * achieved by using tighter loops to locally handle units such as
196 * comments and strings. Loops that handle an entire token within
197 * their scope also gather entire strings and pass them to
198 * printbuf_memappend() in a single call, rather than calling
199 * printbuf_memappend() one char at a time.
200 *
201 * PEEK_CHAR() and ADVANCE_CHAR() macros are used for code that is
202 * common to both the main loop and the tighter loops.
203 */
204
205 /* PEEK_CHAR(dest, tok) macro:
206 * Peeks at the current char and stores it in dest.
207 * Returns 1 on success, sets tok->err and returns 0 if no more chars.
208 * Implicit inputs: str, len vars
209 */
210 #define PEEK_CHAR(dest, tok) \
211 (((tok)->char_offset == len) ? \
212 (((tok)->depth == 0 && state == json_tokener_state_eatws && saved_state == json_tokener_state_finish) ? \
213 (((tok)->err = json_tokener_success), 0) \
214 : \
215 (((tok)->err = json_tokener_continue), 0) \
216 ) : \
217 (((dest) = *str), 1) \
218 )
219
220 /* ADVANCE_CHAR() macro:
221 * Incrementes str & tok->char_offset.
222 * For convenience of existing conditionals, returns the old value of c (0 on eof)
223 * Implicit inputs: c var
224 */
225 #define ADVANCE_CHAR(str, tok) \
226 ( ++(str), ((tok)->char_offset)++, c)
227
228
229 /* End optimization macro defs */
230
231
json_tokener_parse_ex(struct json_tokener * tok,const char * str,int len)232 struct json_object* json_tokener_parse_ex(struct json_tokener *tok,
233 const char *str, int len)
234 {
235 struct json_object *obj = NULL;
236 char c = '\1';
237 #ifdef HAVE_SETLOCALE
238 char *oldlocale=NULL, *tmplocale;
239
240 tmplocale = setlocale(LC_NUMERIC, NULL);
241 if (tmplocale) oldlocale = strdup(tmplocale);
242 setlocale(LC_NUMERIC, "C");
243 #endif
244
245 tok->char_offset = 0;
246 tok->err = json_tokener_success;
247
248 /* this interface is presently not 64-bit clean due to the int len argument
249 and the internal printbuf interface that takes 32-bit int len arguments
250 so the function limits the maximum string size to INT32_MAX (2GB).
251 If the function is called with len == -1 then strlen is called to check
252 the string length is less than INT32_MAX (2GB) */
253 if ((len < -1) || (len == -1 && strlen(str) > INT32_MAX)) {
254 tok->err = json_tokener_error_size;
255 return NULL;
256 }
257
258 while (PEEK_CHAR(c, tok)) {
259
260 redo_char:
261 switch(state) {
262
263 case json_tokener_state_eatws:
264 /* Advance until we change state */
265 while (isspace((int)c)) {
266 if ((!ADVANCE_CHAR(str, tok)) || (!PEEK_CHAR(c, tok)))
267 goto out;
268 }
269 if(c == '/' && !(tok->flags & JSON_TOKENER_STRICT)) {
270 printbuf_reset(tok->pb);
271 printbuf_memappend_fast(tok->pb, &c, 1);
272 state = json_tokener_state_comment_start;
273 } else {
274 state = saved_state;
275 goto redo_char;
276 }
277 break;
278
279 case json_tokener_state_start:
280 switch(c) {
281 case '{':
282 state = json_tokener_state_eatws;
283 saved_state = json_tokener_state_object_field_start;
284 current = json_object_new_object();
285 break;
286 case '[':
287 state = json_tokener_state_eatws;
288 saved_state = json_tokener_state_array;
289 current = json_object_new_array();
290 break;
291 case 'I':
292 case 'i':
293 state = json_tokener_state_inf;
294 printbuf_reset(tok->pb);
295 tok->st_pos = 0;
296 goto redo_char;
297 case 'N':
298 case 'n':
299 state = json_tokener_state_null; // or NaN
300 printbuf_reset(tok->pb);
301 tok->st_pos = 0;
302 goto redo_char;
303 case '\'':
304 if (tok->flags & JSON_TOKENER_STRICT) {
305 /* in STRICT mode only double-quote are allowed */
306 tok->err = json_tokener_error_parse_unexpected;
307 goto out;
308 }
309 case '"':
310 state = json_tokener_state_string;
311 printbuf_reset(tok->pb);
312 tok->quote_char = c;
313 break;
314 case 'T':
315 case 't':
316 case 'F':
317 case 'f':
318 state = json_tokener_state_boolean;
319 printbuf_reset(tok->pb);
320 tok->st_pos = 0;
321 goto redo_char;
322 #if defined(__GNUC__)
323 case '0' ... '9':
324 #else
325 case '0':
326 case '1':
327 case '2':
328 case '3':
329 case '4':
330 case '5':
331 case '6':
332 case '7':
333 case '8':
334 case '9':
335 #endif
336 case '-':
337 state = json_tokener_state_number;
338 printbuf_reset(tok->pb);
339 tok->is_double = 0;
340 goto redo_char;
341 default:
342 tok->err = json_tokener_error_parse_unexpected;
343 goto out;
344 }
345 break;
346
347 case json_tokener_state_finish:
348 if(tok->depth == 0) goto out;
349 obj = json_object_get(current);
350 json_tokener_reset_level(tok, tok->depth);
351 tok->depth--;
352 goto redo_char;
353
354 case json_tokener_state_inf: /* aka starts with 'i' */
355 {
356 int size_inf;
357 int is_negative = 0;
358
359 printbuf_memappend_fast(tok->pb, &c, 1);
360 size_inf = json_min(tok->st_pos+1, json_inf_str_len);
361 char *infbuf = tok->pb->buf;
362 if (*infbuf == '-')
363 {
364 infbuf++;
365 is_negative = 1;
366 }
367 if ((!(tok->flags & JSON_TOKENER_STRICT) &&
368 strncasecmp(json_inf_str, infbuf, size_inf) == 0) ||
369 (strncmp(json_inf_str, infbuf, size_inf) == 0)
370 )
371 {
372 if (tok->st_pos == json_inf_str_len)
373 {
374 current = json_object_new_double(is_negative ? -INFINITY : INFINITY);
375 saved_state = json_tokener_state_finish;
376 state = json_tokener_state_eatws;
377 goto redo_char;
378 }
379 } else {
380 tok->err = json_tokener_error_parse_unexpected;
381 goto out;
382 }
383 tok->st_pos++;
384 }
385 break;
386 case json_tokener_state_null: /* aka starts with 'n' */
387 {
388 int size;
389 int size_nan;
390 printbuf_memappend_fast(tok->pb, &c, 1);
391 size = json_min(tok->st_pos+1, json_null_str_len);
392 size_nan = json_min(tok->st_pos+1, json_nan_str_len);
393 if((!(tok->flags & JSON_TOKENER_STRICT) &&
394 strncasecmp(json_null_str, tok->pb->buf, size) == 0)
395 || (strncmp(json_null_str, tok->pb->buf, size) == 0)
396 ) {
397 if (tok->st_pos == json_null_str_len) {
398 current = NULL;
399 saved_state = json_tokener_state_finish;
400 state = json_tokener_state_eatws;
401 goto redo_char;
402 }
403 }
404 else if ((!(tok->flags & JSON_TOKENER_STRICT) &&
405 strncasecmp(json_nan_str, tok->pb->buf, size_nan) == 0) ||
406 (strncmp(json_nan_str, tok->pb->buf, size_nan) == 0)
407 )
408 {
409 if (tok->st_pos == json_nan_str_len)
410 {
411 current = json_object_new_double(NAN);
412 saved_state = json_tokener_state_finish;
413 state = json_tokener_state_eatws;
414 goto redo_char;
415 }
416 } else {
417 tok->err = json_tokener_error_parse_null;
418 goto out;
419 }
420 tok->st_pos++;
421 }
422 break;
423
424 case json_tokener_state_comment_start:
425 if(c == '*') {
426 state = json_tokener_state_comment;
427 } else if(c == '/') {
428 state = json_tokener_state_comment_eol;
429 } else {
430 tok->err = json_tokener_error_parse_comment;
431 goto out;
432 }
433 printbuf_memappend_fast(tok->pb, &c, 1);
434 break;
435
436 case json_tokener_state_comment:
437 {
438 /* Advance until we change state */
439 const char *case_start = str;
440 while(c != '*') {
441 if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) {
442 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
443 goto out;
444 }
445 }
446 printbuf_memappend_fast(tok->pb, case_start, 1+str-case_start);
447 state = json_tokener_state_comment_end;
448 }
449 break;
450
451 case json_tokener_state_comment_eol:
452 {
453 /* Advance until we change state */
454 const char *case_start = str;
455 while(c != '\n') {
456 if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) {
457 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
458 goto out;
459 }
460 }
461 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
462 MC_DEBUG("json_tokener_comment: %s\n", tok->pb->buf);
463 state = json_tokener_state_eatws;
464 }
465 break;
466
467 case json_tokener_state_comment_end:
468 printbuf_memappend_fast(tok->pb, &c, 1);
469 if(c == '/') {
470 MC_DEBUG("json_tokener_comment: %s\n", tok->pb->buf);
471 state = json_tokener_state_eatws;
472 } else {
473 state = json_tokener_state_comment;
474 }
475 break;
476
477 case json_tokener_state_string:
478 {
479 /* Advance until we change state */
480 const char *case_start = str;
481 while(1) {
482 if(c == tok->quote_char) {
483 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
484 current = json_object_new_string_len(tok->pb->buf, tok->pb->bpos);
485 saved_state = json_tokener_state_finish;
486 state = json_tokener_state_eatws;
487 break;
488 } else if(c == '\\') {
489 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
490 saved_state = json_tokener_state_string;
491 state = json_tokener_state_string_escape;
492 break;
493 }
494 if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) {
495 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
496 goto out;
497 }
498 }
499 }
500 break;
501
502 case json_tokener_state_string_escape:
503 switch(c) {
504 case '"':
505 case '\\':
506 case '/':
507 printbuf_memappend_fast(tok->pb, &c, 1);
508 state = saved_state;
509 break;
510 case 'b':
511 case 'n':
512 case 'r':
513 case 't':
514 case 'f':
515 if(c == 'b') printbuf_memappend_fast(tok->pb, "\b", 1);
516 else if(c == 'n') printbuf_memappend_fast(tok->pb, "\n", 1);
517 else if(c == 'r') printbuf_memappend_fast(tok->pb, "\r", 1);
518 else if(c == 't') printbuf_memappend_fast(tok->pb, "\t", 1);
519 else if(c == 'f') printbuf_memappend_fast(tok->pb, "\f", 1);
520 state = saved_state;
521 break;
522 case 'u':
523 tok->ucs_char = 0;
524 tok->st_pos = 0;
525 state = json_tokener_state_escape_unicode;
526 break;
527 default:
528 tok->err = json_tokener_error_parse_string;
529 goto out;
530 }
531 break;
532
533 case json_tokener_state_escape_unicode:
534 {
535 unsigned int got_hi_surrogate = 0;
536
537 /* Handle a 4-byte sequence, or two sequences if a surrogate pair */
538 while(1) {
539 if(strchr(json_hex_chars, c)) {
540 tok->ucs_char += ((unsigned int)jt_hexdigit(c) << ((3-tok->st_pos++)*4));
541 if(tok->st_pos == 4) {
542 unsigned char unescaped_utf[4];
543
544 if (got_hi_surrogate) {
545 if (IS_LOW_SURROGATE(tok->ucs_char)) {
546 /* Recalculate the ucs_char, then fall thru to process normally */
547 tok->ucs_char = DECODE_SURROGATE_PAIR(got_hi_surrogate, tok->ucs_char);
548 } else {
549 /* Hi surrogate was not followed by a low surrogate */
550 /* Replace the hi and process the rest normally */
551 printbuf_memappend_fast(tok->pb, (char*)utf8_replacement_char, 3);
552 }
553 got_hi_surrogate = 0;
554 }
555
556 if (tok->ucs_char < 0x80) {
557 unescaped_utf[0] = tok->ucs_char;
558 printbuf_memappend_fast(tok->pb, (char*)unescaped_utf, 1);
559 } else if (tok->ucs_char < 0x800) {
560 unescaped_utf[0] = 0xc0 | (tok->ucs_char >> 6);
561 unescaped_utf[1] = 0x80 | (tok->ucs_char & 0x3f);
562 printbuf_memappend_fast(tok->pb, (char*)unescaped_utf, 2);
563 } else if (IS_HIGH_SURROGATE(tok->ucs_char)) {
564 /* Got a high surrogate. Remember it and look for the
565 * the beginning of another sequence, which should be the
566 * low surrogate.
567 */
568 got_hi_surrogate = tok->ucs_char;
569 /* Not at end, and the next two chars should be "\u" */
570 if ((tok->char_offset+1 != len) &&
571 (tok->char_offset+2 != len) &&
572 (str[1] == '\\') &&
573 (str[2] == 'u'))
574 {
575 /* Advance through the 16 bit surrogate, and move on to the
576 * next sequence. The next step is to process the following
577 * characters.
578 */
579 if( !ADVANCE_CHAR(str, tok) || !ADVANCE_CHAR(str, tok) ) {
580 printbuf_memappend_fast(tok->pb, (char*)utf8_replacement_char, 3);
581 }
582 /* Advance to the first char of the next sequence and
583 * continue processing with the next sequence.
584 */
585 if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) {
586 printbuf_memappend_fast(tok->pb, (char*)utf8_replacement_char, 3);
587 goto out;
588 }
589 tok->ucs_char = 0;
590 tok->st_pos = 0;
591 continue; /* other json_tokener_state_escape_unicode */
592 } else {
593 /* Got a high surrogate without another sequence following
594 * it. Put a replacement char in for the hi surrogate
595 * and pretend we finished.
596 */
597 printbuf_memappend_fast(tok->pb, (char*)utf8_replacement_char, 3);
598 }
599 } else if (IS_LOW_SURROGATE(tok->ucs_char)) {
600 /* Got a low surrogate not preceded by a high */
601 printbuf_memappend_fast(tok->pb, (char*)utf8_replacement_char, 3);
602 } else if (tok->ucs_char < 0x10000) {
603 unescaped_utf[0] = 0xe0 | (tok->ucs_char >> 12);
604 unescaped_utf[1] = 0x80 | ((tok->ucs_char >> 6) & 0x3f);
605 unescaped_utf[2] = 0x80 | (tok->ucs_char & 0x3f);
606 printbuf_memappend_fast(tok->pb, (char*)unescaped_utf, 3);
607 } else if (tok->ucs_char < 0x110000) {
608 unescaped_utf[0] = 0xf0 | ((tok->ucs_char >> 18) & 0x07);
609 unescaped_utf[1] = 0x80 | ((tok->ucs_char >> 12) & 0x3f);
610 unescaped_utf[2] = 0x80 | ((tok->ucs_char >> 6) & 0x3f);
611 unescaped_utf[3] = 0x80 | (tok->ucs_char & 0x3f);
612 printbuf_memappend_fast(tok->pb, (char*)unescaped_utf, 4);
613 } else {
614 /* Don't know what we got--insert the replacement char */
615 printbuf_memappend_fast(tok->pb, (char*)utf8_replacement_char, 3);
616 }
617 state = saved_state;
618 break;
619 }
620 } else {
621 tok->err = json_tokener_error_parse_string;
622 goto out;
623 }
624 if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) {
625 if (got_hi_surrogate) /* Clean up any pending chars */
626 printbuf_memappend_fast(tok->pb, (char*)utf8_replacement_char, 3);
627 goto out;
628 }
629 }
630 }
631 break;
632
633 case json_tokener_state_boolean:
634 {
635 int size1, size2;
636 printbuf_memappend_fast(tok->pb, &c, 1);
637 size1 = json_min(tok->st_pos+1, json_true_str_len);
638 size2 = json_min(tok->st_pos+1, json_false_str_len);
639 if((!(tok->flags & JSON_TOKENER_STRICT) &&
640 strncasecmp(json_true_str, tok->pb->buf, size1) == 0)
641 || (strncmp(json_true_str, tok->pb->buf, size1) == 0)
642 ) {
643 if(tok->st_pos == json_true_str_len) {
644 current = json_object_new_boolean(1);
645 saved_state = json_tokener_state_finish;
646 state = json_tokener_state_eatws;
647 goto redo_char;
648 }
649 } else if((!(tok->flags & JSON_TOKENER_STRICT) &&
650 strncasecmp(json_false_str, tok->pb->buf, size2) == 0)
651 || (strncmp(json_false_str, tok->pb->buf, size2) == 0)) {
652 if(tok->st_pos == json_false_str_len) {
653 current = json_object_new_boolean(0);
654 saved_state = json_tokener_state_finish;
655 state = json_tokener_state_eatws;
656 goto redo_char;
657 }
658 } else {
659 tok->err = json_tokener_error_parse_boolean;
660 goto out;
661 }
662 tok->st_pos++;
663 }
664 break;
665
666 case json_tokener_state_number:
667 {
668 /* Advance until we change state */
669 const char *case_start = str;
670 int case_len=0;
671 while(c && strchr(json_number_chars, c)) {
672 ++case_len;
673 if(c == '.' || c == 'e' || c == 'E')
674 tok->is_double = 1;
675 if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) {
676 printbuf_memappend_fast(tok->pb, case_start, case_len);
677 goto out;
678 }
679 }
680 if (case_len>0)
681 printbuf_memappend_fast(tok->pb, case_start, case_len);
682
683 // Check for -Infinity
684 if (tok->pb->buf[0] == '-' && case_len == 1 &&
685 (c == 'i' || c == 'I'))
686 {
687 state = json_tokener_state_inf;
688 goto redo_char;
689 }
690 }
691 {
692 int64_t num64;
693 double numd;
694 if (!tok->is_double && json_parse_int64(tok->pb->buf, &num64) == 0) {
695 if (num64 && tok->pb->buf[0]=='0' && (tok->flags & JSON_TOKENER_STRICT)) {
696 /* in strict mode, number must not start with 0 */
697 tok->err = json_tokener_error_parse_number;
698 goto out;
699 }
700 current = json_object_new_int64(num64);
701 }
702 else if(tok->is_double && json_parse_double(tok->pb->buf, &numd) == 0)
703 {
704 current = json_object_new_double_s(numd, tok->pb->buf);
705 } else {
706 tok->err = json_tokener_error_parse_number;
707 goto out;
708 }
709 saved_state = json_tokener_state_finish;
710 state = json_tokener_state_eatws;
711 goto redo_char;
712 }
713 break;
714
715 case json_tokener_state_array_after_sep:
716 case json_tokener_state_array:
717 if(c == ']') {
718 if (state == json_tokener_state_array_after_sep &&
719 (tok->flags & JSON_TOKENER_STRICT))
720 {
721 tok->err = json_tokener_error_parse_unexpected;
722 goto out;
723 }
724 saved_state = json_tokener_state_finish;
725 state = json_tokener_state_eatws;
726 } else {
727 if(tok->depth >= tok->max_depth-1) {
728 tok->err = json_tokener_error_depth;
729 goto out;
730 }
731 state = json_tokener_state_array_add;
732 tok->depth++;
733 json_tokener_reset_level(tok, tok->depth);
734 goto redo_char;
735 }
736 break;
737
738 case json_tokener_state_array_add:
739 json_object_array_add(current, obj);
740 saved_state = json_tokener_state_array_sep;
741 state = json_tokener_state_eatws;
742 goto redo_char;
743
744 case json_tokener_state_array_sep:
745 if(c == ']') {
746 saved_state = json_tokener_state_finish;
747 state = json_tokener_state_eatws;
748 } else if(c == ',') {
749 saved_state = json_tokener_state_array_after_sep;
750 state = json_tokener_state_eatws;
751 } else {
752 tok->err = json_tokener_error_parse_array;
753 goto out;
754 }
755 break;
756
757 case json_tokener_state_object_field_start:
758 case json_tokener_state_object_field_start_after_sep:
759 if(c == '}') {
760 if (state == json_tokener_state_object_field_start_after_sep &&
761 (tok->flags & JSON_TOKENER_STRICT))
762 {
763 tok->err = json_tokener_error_parse_unexpected;
764 goto out;
765 }
766 saved_state = json_tokener_state_finish;
767 state = json_tokener_state_eatws;
768 } else if (c == '"' || c == '\'') {
769 tok->quote_char = c;
770 printbuf_reset(tok->pb);
771 state = json_tokener_state_object_field;
772 } else {
773 tok->err = json_tokener_error_parse_object_key_name;
774 goto out;
775 }
776 break;
777
778 case json_tokener_state_object_field:
779 {
780 /* Advance until we change state */
781 const char *case_start = str;
782 while(1) {
783 if(c == tok->quote_char) {
784 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
785 obj_field_name = strdup(tok->pb->buf);
786 saved_state = json_tokener_state_object_field_end;
787 state = json_tokener_state_eatws;
788 break;
789 } else if(c == '\\') {
790 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
791 saved_state = json_tokener_state_object_field;
792 state = json_tokener_state_string_escape;
793 break;
794 }
795 if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) {
796 printbuf_memappend_fast(tok->pb, case_start, str-case_start);
797 goto out;
798 }
799 }
800 }
801 break;
802
803 case json_tokener_state_object_field_end:
804 if(c == ':') {
805 saved_state = json_tokener_state_object_value;
806 state = json_tokener_state_eatws;
807 } else {
808 tok->err = json_tokener_error_parse_object_key_sep;
809 goto out;
810 }
811 break;
812
813 case json_tokener_state_object_value:
814 if(tok->depth >= tok->max_depth-1) {
815 tok->err = json_tokener_error_depth;
816 goto out;
817 }
818 state = json_tokener_state_object_value_add;
819 tok->depth++;
820 json_tokener_reset_level(tok, tok->depth);
821 goto redo_char;
822
823 case json_tokener_state_object_value_add:
824 json_object_object_add(current, obj_field_name, obj);
825 free(obj_field_name);
826 obj_field_name = NULL;
827 saved_state = json_tokener_state_object_sep;
828 state = json_tokener_state_eatws;
829 goto redo_char;
830
831 case json_tokener_state_object_sep:
832 if(c == '}') {
833 saved_state = json_tokener_state_finish;
834 state = json_tokener_state_eatws;
835 } else if(c == ',') {
836 saved_state = json_tokener_state_object_field_start_after_sep;
837 state = json_tokener_state_eatws;
838 } else {
839 tok->err = json_tokener_error_parse_object_value_sep;
840 goto out;
841 }
842 break;
843
844 }
845 if (!ADVANCE_CHAR(str, tok))
846 goto out;
847 } /* while(POP_CHAR) */
848
849 out:
850 if (c &&
851 (state == json_tokener_state_finish) &&
852 (tok->depth == 0) &&
853 (tok->flags & JSON_TOKENER_STRICT)) {
854 /* unexpected char after JSON data */
855 tok->err = json_tokener_error_parse_unexpected;
856 }
857 if (!c) { /* We hit an eof char (0) */
858 if(state != json_tokener_state_finish &&
859 saved_state != json_tokener_state_finish)
860 tok->err = json_tokener_error_parse_eof;
861 }
862
863 #ifdef HAVE_SETLOCALE
864 setlocale(LC_NUMERIC, oldlocale);
865 if (oldlocale) free(oldlocale);
866 #endif
867
868 if (tok->err == json_tokener_success)
869 {
870 json_object *ret = json_object_get(current);
871 int ii;
872
873 /* Partially reset, so we parse additional objects on subsequent calls. */
874 for(ii = tok->depth; ii >= 0; ii--)
875 json_tokener_reset_level(tok, ii);
876 return ret;
877 }
878
879 MC_DEBUG("json_tokener_parse_ex: error %s at offset %d\n",
880 json_tokener_errors[tok->err], tok->char_offset);
881 return NULL;
882 }
883
json_tokener_set_flags(struct json_tokener * tok,int flags)884 void json_tokener_set_flags(struct json_tokener *tok, int flags)
885 {
886 tok->flags = flags;
887 }
888