"Fossies" - the Fresh Open Source Software Archive 
Member "jansson-2.14/src/load.c" (19 Nov 2020, 28743 Bytes) of package /linux/www/jansson-2.14.tar.bz2:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
1 /*
2 * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
3 *
4 * Jansson is free software; you can redistribute it and/or modify
5 * it under the terms of the MIT license. See LICENSE for details.
6 */
7
8 #ifndef _GNU_SOURCE
9 #define _GNU_SOURCE
10 #endif
11
12 #include "jansson_private.h"
13
14 #include <assert.h>
15 #include <errno.h>
16 #include <limits.h>
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #ifdef HAVE_UNISTD_H
21 #include <unistd.h>
22 #endif
23
24 #include "jansson.h"
25 #include "strbuffer.h"
26 #include "utf.h"
27
28 #define STREAM_STATE_OK 0
29 #define STREAM_STATE_EOF -1
30 #define STREAM_STATE_ERROR -2
31
32 #define TOKEN_INVALID -1
33 #define TOKEN_EOF 0
34 #define TOKEN_STRING 256
35 #define TOKEN_INTEGER 257
36 #define TOKEN_REAL 258
37 #define TOKEN_TRUE 259
38 #define TOKEN_FALSE 260
39 #define TOKEN_NULL 261
40
41 /* Locale independent versions of isxxx() functions */
42 #define l_isupper(c) ('A' <= (c) && (c) <= 'Z')
43 #define l_islower(c) ('a' <= (c) && (c) <= 'z')
44 #define l_isalpha(c) (l_isupper(c) || l_islower(c))
45 #define l_isdigit(c) ('0' <= (c) && (c) <= '9')
46 #define l_isxdigit(c) \
47 (l_isdigit(c) || ('A' <= (c) && (c) <= 'F') || ('a' <= (c) && (c) <= 'f'))
48
49 /* Read one byte from stream, convert to unsigned char, then int, and
50 return. return EOF on end of file. This corresponds to the
51 behaviour of fgetc(). */
52 typedef int (*get_func)(void *data);
53
54 typedef struct {
55 get_func get;
56 void *data;
57 char buffer[5];
58 size_t buffer_pos;
59 int state;
60 int line;
61 int column, last_column;
62 size_t position;
63 } stream_t;
64
65 typedef struct {
66 stream_t stream;
67 strbuffer_t saved_text;
68 size_t flags;
69 size_t depth;
70 int token;
71 union {
72 struct {
73 char *val;
74 size_t len;
75 } string;
76 json_int_t integer;
77 double real;
78 } value;
79 } lex_t;
80
81 #define stream_to_lex(stream) container_of(stream, lex_t, stream)
82
83 /*** error reporting ***/
84
85 static void error_set(json_error_t *error, const lex_t *lex, enum json_error_code code,
86 const char *msg, ...) {
87 va_list ap;
88 char msg_text[JSON_ERROR_TEXT_LENGTH];
89 char msg_with_context[JSON_ERROR_TEXT_LENGTH];
90
91 int line = -1, col = -1;
92 size_t pos = 0;
93 const char *result = msg_text;
94
95 if (!error)
96 return;
97
98 va_start(ap, msg);
99 vsnprintf(msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap);
100 msg_text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
101 va_end(ap);
102
103 if (lex) {
104 const char *saved_text = strbuffer_value(&lex->saved_text);
105
106 line = lex->stream.line;
107 col = lex->stream.column;
108 pos = lex->stream.position;
109
110 if (saved_text && saved_text[0]) {
111 if (lex->saved_text.length <= 20) {
112 snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, "%s near '%s'",
113 msg_text, saved_text);
114 msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
115 result = msg_with_context;
116 }
117 } else {
118 if (code == json_error_invalid_syntax) {
119 /* More specific error code for premature end of file. */
120 code = json_error_premature_end_of_input;
121 }
122 if (lex->stream.state == STREAM_STATE_ERROR) {
123 /* No context for UTF-8 decoding errors */
124 result = msg_text;
125 } else {
126 snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, "%s near end of file",
127 msg_text);
128 msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
129 result = msg_with_context;
130 }
131 }
132 }
133
134 jsonp_error_set(error, line, col, pos, code, "%s", result);
135 }
136
137 /*** lexical analyzer ***/
138
139 static void stream_init(stream_t *stream, get_func get, void *data) {
140 stream->get = get;
141 stream->data = data;
142 stream->buffer[0] = '\0';
143 stream->buffer_pos = 0;
144
145 stream->state = STREAM_STATE_OK;
146 stream->line = 1;
147 stream->column = 0;
148 stream->position = 0;
149 }
150
151 static int stream_get(stream_t *stream, json_error_t *error) {
152 int c;
153
154 if (stream->state != STREAM_STATE_OK)
155 return stream->state;
156
157 if (!stream->buffer[stream->buffer_pos]) {
158 c = stream->get(stream->data);
159 if (c == EOF) {
160 stream->state = STREAM_STATE_EOF;
161 return STREAM_STATE_EOF;
162 }
163
164 stream->buffer[0] = c;
165 stream->buffer_pos = 0;
166
167 if (0x80 <= c && c <= 0xFF) {
168 /* multi-byte UTF-8 sequence */
169 size_t i, count;
170
171 count = utf8_check_first(c);
172 if (!count)
173 goto out;
174
175 assert(count >= 2);
176
177 for (i = 1; i < count; i++)
178 stream->buffer[i] = stream->get(stream->data);
179
180 if (!utf8_check_full(stream->buffer, count, NULL))
181 goto out;
182
183 stream->buffer[count] = '\0';
184 } else
185 stream->buffer[1] = '\0';
186 }
187
188 c = stream->buffer[stream->buffer_pos++];
189
190 stream->position++;
191 if (c == '\n') {
192 stream->line++;
193 stream->last_column = stream->column;
194 stream->column = 0;
195 } else if (utf8_check_first(c)) {
196 /* track the Unicode character column, so increment only if
197 this is the first character of a UTF-8 sequence */
198 stream->column++;
199 }
200
201 return c;
202
203 out:
204 stream->state = STREAM_STATE_ERROR;
205 error_set(error, stream_to_lex(stream), json_error_invalid_utf8,
206 "unable to decode byte 0x%x", c);
207 return STREAM_STATE_ERROR;
208 }
209
210 static void stream_unget(stream_t *stream, int c) {
211 if (c == STREAM_STATE_EOF || c == STREAM_STATE_ERROR)
212 return;
213
214 stream->position--;
215 if (c == '\n') {
216 stream->line--;
217 stream->column = stream->last_column;
218 } else if (utf8_check_first(c))
219 stream->column--;
220
221 assert(stream->buffer_pos > 0);
222 stream->buffer_pos--;
223 assert(stream->buffer[stream->buffer_pos] == c);
224 }
225
226 static int lex_get(lex_t *lex, json_error_t *error) {
227 return stream_get(&lex->stream, error);
228 }
229
230 static void lex_save(lex_t *lex, int c) { strbuffer_append_byte(&lex->saved_text, c); }
231
232 static int lex_get_save(lex_t *lex, json_error_t *error) {
233 int c = stream_get(&lex->stream, error);
234 if (c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR)
235 lex_save(lex, c);
236 return c;
237 }
238
239 static void lex_unget(lex_t *lex, int c) { stream_unget(&lex->stream, c); }
240
241 static void lex_unget_unsave(lex_t *lex, int c) {
242 if (c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR) {
243 /* Since we treat warnings as errors, when assertions are turned
244 * off the "d" variable would be set but never used. Which is
245 * treated as an error by GCC.
246 */
247 #ifndef NDEBUG
248 char d;
249 #endif
250 stream_unget(&lex->stream, c);
251 #ifndef NDEBUG
252 d =
253 #endif
254 strbuffer_pop(&lex->saved_text);
255 assert(c == d);
256 }
257 }
258
259 static void lex_save_cached(lex_t *lex) {
260 while (lex->stream.buffer[lex->stream.buffer_pos] != '\0') {
261 lex_save(lex, lex->stream.buffer[lex->stream.buffer_pos]);
262 lex->stream.buffer_pos++;
263 lex->stream.position++;
264 }
265 }
266
267 static void lex_free_string(lex_t *lex) {
268 jsonp_free(lex->value.string.val);
269 lex->value.string.val = NULL;
270 lex->value.string.len = 0;
271 }
272
273 /* assumes that str points to 'u' plus at least 4 valid hex digits */
274 static int32_t decode_unicode_escape(const char *str) {
275 int i;
276 int32_t value = 0;
277
278 assert(str[0] == 'u');
279
280 for (i = 1; i <= 4; i++) {
281 char c = str[i];
282 value <<= 4;
283 if (l_isdigit(c))
284 value += c - '0';
285 else if (l_islower(c))
286 value += c - 'a' + 10;
287 else if (l_isupper(c))
288 value += c - 'A' + 10;
289 else
290 return -1;
291 }
292
293 return value;
294 }
295
296 static void lex_scan_string(lex_t *lex, json_error_t *error) {
297 int c;
298 const char *p;
299 char *t;
300 int i;
301
302 lex->value.string.val = NULL;
303 lex->token = TOKEN_INVALID;
304
305 c = lex_get_save(lex, error);
306
307 while (c != '"') {
308 if (c == STREAM_STATE_ERROR)
309 goto out;
310
311 else if (c == STREAM_STATE_EOF) {
312 error_set(error, lex, json_error_premature_end_of_input,
313 "premature end of input");
314 goto out;
315 }
316
317 else if (0 <= c && c <= 0x1F) {
318 /* control character */
319 lex_unget_unsave(lex, c);
320 if (c == '\n')
321 error_set(error, lex, json_error_invalid_syntax, "unexpected newline");
322 else
323 error_set(error, lex, json_error_invalid_syntax, "control character 0x%x",
324 c);
325 goto out;
326 }
327
328 else if (c == '\\') {
329 c = lex_get_save(lex, error);
330 if (c == 'u') {
331 c = lex_get_save(lex, error);
332 for (i = 0; i < 4; i++) {
333 if (!l_isxdigit(c)) {
334 error_set(error, lex, json_error_invalid_syntax,
335 "invalid escape");
336 goto out;
337 }
338 c = lex_get_save(lex, error);
339 }
340 } else if (c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' ||
341 c == 'n' || c == 'r' || c == 't')
342 c = lex_get_save(lex, error);
343 else {
344 error_set(error, lex, json_error_invalid_syntax, "invalid escape");
345 goto out;
346 }
347 } else
348 c = lex_get_save(lex, error);
349 }
350
351 /* the actual value is at most of the same length as the source
352 string, because:
353 - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
354 - a single \uXXXX escape (length 6) is converted to at most 3 bytes
355 - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
356 are converted to 4 bytes
357 */
358 t = jsonp_malloc(lex->saved_text.length + 1);
359 if (!t) {
360 /* this is not very nice, since TOKEN_INVALID is returned */
361 goto out;
362 }
363 lex->value.string.val = t;
364
365 /* + 1 to skip the " */
366 p = strbuffer_value(&lex->saved_text) + 1;
367
368 while (*p != '"') {
369 if (*p == '\\') {
370 p++;
371 if (*p == 'u') {
372 size_t length;
373 int32_t value;
374
375 value = decode_unicode_escape(p);
376 if (value < 0) {
377 error_set(error, lex, json_error_invalid_syntax,
378 "invalid Unicode escape '%.6s'", p - 1);
379 goto out;
380 }
381 p += 5;
382
383 if (0xD800 <= value && value <= 0xDBFF) {
384 /* surrogate pair */
385 if (*p == '\\' && *(p + 1) == 'u') {
386 int32_t value2 = decode_unicode_escape(++p);
387 if (value2 < 0) {
388 error_set(error, lex, json_error_invalid_syntax,
389 "invalid Unicode escape '%.6s'", p - 1);
390 goto out;
391 }
392 p += 5;
393
394 if (0xDC00 <= value2 && value2 <= 0xDFFF) {
395 /* valid second surrogate */
396 value =
397 ((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000;
398 } else {
399 /* invalid second surrogate */
400 error_set(error, lex, json_error_invalid_syntax,
401 "invalid Unicode '\\u%04X\\u%04X'", value, value2);
402 goto out;
403 }
404 } else {
405 /* no second surrogate */
406 error_set(error, lex, json_error_invalid_syntax,
407 "invalid Unicode '\\u%04X'", value);
408 goto out;
409 }
410 } else if (0xDC00 <= value && value <= 0xDFFF) {
411 error_set(error, lex, json_error_invalid_syntax,
412 "invalid Unicode '\\u%04X'", value);
413 goto out;
414 }
415
416 if (utf8_encode(value, t, &length))
417 assert(0);
418 t += length;
419 } else {
420 switch (*p) {
421 case '"':
422 case '\\':
423 case '/':
424 *t = *p;
425 break;
426 case 'b':
427 *t = '\b';
428 break;
429 case 'f':
430 *t = '\f';
431 break;
432 case 'n':
433 *t = '\n';
434 break;
435 case 'r':
436 *t = '\r';
437 break;
438 case 't':
439 *t = '\t';
440 break;
441 default:
442 assert(0);
443 }
444 t++;
445 p++;
446 }
447 } else
448 *(t++) = *(p++);
449 }
450 *t = '\0';
451 lex->value.string.len = t - lex->value.string.val;
452 lex->token = TOKEN_STRING;
453 return;
454
455 out:
456 lex_free_string(lex);
457 }
458
459 #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
460 #if JSON_INTEGER_IS_LONG_LONG
461 #ifdef _MSC_VER /* Microsoft Visual Studio */
462 #define json_strtoint _strtoi64
463 #else
464 #define json_strtoint strtoll
465 #endif
466 #else
467 #define json_strtoint strtol
468 #endif
469 #endif
470
471 static int lex_scan_number(lex_t *lex, int c, json_error_t *error) {
472 const char *saved_text;
473 char *end;
474 double doubleval;
475
476 lex->token = TOKEN_INVALID;
477
478 if (c == '-')
479 c = lex_get_save(lex, error);
480
481 if (c == '0') {
482 c = lex_get_save(lex, error);
483 if (l_isdigit(c)) {
484 lex_unget_unsave(lex, c);
485 goto out;
486 }
487 } else if (l_isdigit(c)) {
488 do
489 c = lex_get_save(lex, error);
490 while (l_isdigit(c));
491 } else {
492 lex_unget_unsave(lex, c);
493 goto out;
494 }
495
496 if (!(lex->flags & JSON_DECODE_INT_AS_REAL) && c != '.' && c != 'E' && c != 'e') {
497 json_int_t intval;
498
499 lex_unget_unsave(lex, c);
500
501 saved_text = strbuffer_value(&lex->saved_text);
502
503 errno = 0;
504 intval = json_strtoint(saved_text, &end, 10);
505 if (errno == ERANGE) {
506 if (intval < 0)
507 error_set(error, lex, json_error_numeric_overflow,
508 "too big negative integer");
509 else
510 error_set(error, lex, json_error_numeric_overflow, "too big integer");
511 goto out;
512 }
513
514 assert(end == saved_text + lex->saved_text.length);
515
516 lex->token = TOKEN_INTEGER;
517 lex->value.integer = intval;
518 return 0;
519 }
520
521 if (c == '.') {
522 c = lex_get(lex, error);
523 if (!l_isdigit(c)) {
524 lex_unget(lex, c);
525 goto out;
526 }
527 lex_save(lex, c);
528
529 do
530 c = lex_get_save(lex, error);
531 while (l_isdigit(c));
532 }
533
534 if (c == 'E' || c == 'e') {
535 c = lex_get_save(lex, error);
536 if (c == '+' || c == '-')
537 c = lex_get_save(lex, error);
538
539 if (!l_isdigit(c)) {
540 lex_unget_unsave(lex, c);
541 goto out;
542 }
543
544 do
545 c = lex_get_save(lex, error);
546 while (l_isdigit(c));
547 }
548
549 lex_unget_unsave(lex, c);
550
551 if (jsonp_strtod(&lex->saved_text, &doubleval)) {
552 error_set(error, lex, json_error_numeric_overflow, "real number overflow");
553 goto out;
554 }
555
556 lex->token = TOKEN_REAL;
557 lex->value.real = doubleval;
558 return 0;
559
560 out:
561 return -1;
562 }
563
564 static int lex_scan(lex_t *lex, json_error_t *error) {
565 int c;
566
567 strbuffer_clear(&lex->saved_text);
568
569 if (lex->token == TOKEN_STRING)
570 lex_free_string(lex);
571
572 do
573 c = lex_get(lex, error);
574 while (c == ' ' || c == '\t' || c == '\n' || c == '\r');
575
576 if (c == STREAM_STATE_EOF) {
577 lex->token = TOKEN_EOF;
578 goto out;
579 }
580
581 if (c == STREAM_STATE_ERROR) {
582 lex->token = TOKEN_INVALID;
583 goto out;
584 }
585
586 lex_save(lex, c);
587
588 if (c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
589 lex->token = c;
590
591 else if (c == '"')
592 lex_scan_string(lex, error);
593
594 else if (l_isdigit(c) || c == '-') {
595 if (lex_scan_number(lex, c, error))
596 goto out;
597 }
598
599 else if (l_isalpha(c)) {
600 /* eat up the whole identifier for clearer error messages */
601 const char *saved_text;
602
603 do
604 c = lex_get_save(lex, error);
605 while (l_isalpha(c));
606 lex_unget_unsave(lex, c);
607
608 saved_text = strbuffer_value(&lex->saved_text);
609
610 if (strcmp(saved_text, "true") == 0)
611 lex->token = TOKEN_TRUE;
612 else if (strcmp(saved_text, "false") == 0)
613 lex->token = TOKEN_FALSE;
614 else if (strcmp(saved_text, "null") == 0)
615 lex->token = TOKEN_NULL;
616 else
617 lex->token = TOKEN_INVALID;
618 }
619
620 else {
621 /* save the rest of the input UTF-8 sequence to get an error
622 message of valid UTF-8 */
623 lex_save_cached(lex);
624 lex->token = TOKEN_INVALID;
625 }
626
627 out:
628 return lex->token;
629 }
630
631 static char *lex_steal_string(lex_t *lex, size_t *out_len) {
632 char *result = NULL;
633 if (lex->token == TOKEN_STRING) {
634 result = lex->value.string.val;
635 *out_len = lex->value.string.len;
636 lex->value.string.val = NULL;
637 lex->value.string.len = 0;
638 }
639 return result;
640 }
641
642 static int lex_init(lex_t *lex, get_func get, size_t flags, void *data) {
643 stream_init(&lex->stream, get, data);
644 if (strbuffer_init(&lex->saved_text))
645 return -1;
646
647 lex->flags = flags;
648 lex->token = TOKEN_INVALID;
649 return 0;
650 }
651
652 static void lex_close(lex_t *lex) {
653 if (lex->token == TOKEN_STRING)
654 lex_free_string(lex);
655 strbuffer_close(&lex->saved_text);
656 }
657
658 /*** parser ***/
659
660 static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error);
661
662 static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error) {
663 json_t *object = json_object();
664 if (!object)
665 return NULL;
666
667 lex_scan(lex, error);
668 if (lex->token == '}')
669 return object;
670
671 while (1) {
672 char *key;
673 size_t len;
674 json_t *value;
675
676 if (lex->token != TOKEN_STRING) {
677 error_set(error, lex, json_error_invalid_syntax, "string or '}' expected");
678 goto error;
679 }
680
681 key = lex_steal_string(lex, &len);
682 if (!key)
683 return NULL;
684 if (memchr(key, '\0', len)) {
685 jsonp_free(key);
686 error_set(error, lex, json_error_null_byte_in_key,
687 "NUL byte in object key not supported");
688 goto error;
689 }
690
691 if (flags & JSON_REJECT_DUPLICATES) {
692 if (json_object_getn(object, key, len)) {
693 jsonp_free(key);
694 error_set(error, lex, json_error_duplicate_key, "duplicate object key");
695 goto error;
696 }
697 }
698
699 lex_scan(lex, error);
700 if (lex->token != ':') {
701 jsonp_free(key);
702 error_set(error, lex, json_error_invalid_syntax, "':' expected");
703 goto error;
704 }
705
706 lex_scan(lex, error);
707 value = parse_value(lex, flags, error);
708 if (!value) {
709 jsonp_free(key);
710 goto error;
711 }
712
713 if (json_object_setn_new_nocheck(object, key, len, value)) {
714 jsonp_free(key);
715 goto error;
716 }
717
718 jsonp_free(key);
719
720 lex_scan(lex, error);
721 if (lex->token != ',')
722 break;
723
724 lex_scan(lex, error);
725 }
726
727 if (lex->token != '}') {
728 error_set(error, lex, json_error_invalid_syntax, "'}' expected");
729 goto error;
730 }
731
732 return object;
733
734 error:
735 json_decref(object);
736 return NULL;
737 }
738
739 static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error) {
740 json_t *array = json_array();
741 if (!array)
742 return NULL;
743
744 lex_scan(lex, error);
745 if (lex->token == ']')
746 return array;
747
748 while (lex->token) {
749 json_t *elem = parse_value(lex, flags, error);
750 if (!elem)
751 goto error;
752
753 if (json_array_append_new(array, elem)) {
754 goto error;
755 }
756
757 lex_scan(lex, error);
758 if (lex->token != ',')
759 break;
760
761 lex_scan(lex, error);
762 }
763
764 if (lex->token != ']') {
765 error_set(error, lex, json_error_invalid_syntax, "']' expected");
766 goto error;
767 }
768
769 return array;
770
771 error:
772 json_decref(array);
773 return NULL;
774 }
775
776 static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error) {
777 json_t *json;
778
779 lex->depth++;
780 if (lex->depth > JSON_PARSER_MAX_DEPTH) {
781 error_set(error, lex, json_error_stack_overflow, "maximum parsing depth reached");
782 return NULL;
783 }
784
785 switch (lex->token) {
786 case TOKEN_STRING: {
787 const char *value = lex->value.string.val;
788 size_t len = lex->value.string.len;
789
790 if (!(flags & JSON_ALLOW_NUL)) {
791 if (memchr(value, '\0', len)) {
792 error_set(error, lex, json_error_null_character,
793 "\\u0000 is not allowed without JSON_ALLOW_NUL");
794 return NULL;
795 }
796 }
797
798 json = jsonp_stringn_nocheck_own(value, len);
799 lex->value.string.val = NULL;
800 lex->value.string.len = 0;
801 break;
802 }
803
804 case TOKEN_INTEGER: {
805 json = json_integer(lex->value.integer);
806 break;
807 }
808
809 case TOKEN_REAL: {
810 json = json_real(lex->value.real);
811 break;
812 }
813
814 case TOKEN_TRUE:
815 json = json_true();
816 break;
817
818 case TOKEN_FALSE:
819 json = json_false();
820 break;
821
822 case TOKEN_NULL:
823 json = json_null();
824 break;
825
826 case '{':
827 json = parse_object(lex, flags, error);
828 break;
829
830 case '[':
831 json = parse_array(lex, flags, error);
832 break;
833
834 case TOKEN_INVALID:
835 error_set(error, lex, json_error_invalid_syntax, "invalid token");
836 return NULL;
837
838 default:
839 error_set(error, lex, json_error_invalid_syntax, "unexpected token");
840 return NULL;
841 }
842
843 if (!json)
844 return NULL;
845
846 lex->depth--;
847 return json;
848 }
849
850 static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error) {
851 json_t *result;
852
853 lex->depth = 0;
854
855 lex_scan(lex, error);
856 if (!(flags & JSON_DECODE_ANY)) {
857 if (lex->token != '[' && lex->token != '{') {
858 error_set(error, lex, json_error_invalid_syntax, "'[' or '{' expected");
859 return NULL;
860 }
861 }
862
863 result = parse_value(lex, flags, error);
864 if (!result)
865 return NULL;
866
867 if (!(flags & JSON_DISABLE_EOF_CHECK)) {
868 lex_scan(lex, error);
869 if (lex->token != TOKEN_EOF) {
870 error_set(error, lex, json_error_end_of_input_expected,
871 "end of file expected");
872 json_decref(result);
873 return NULL;
874 }
875 }
876
877 if (error) {
878 /* Save the position even though there was no error */
879 error->position = (int)lex->stream.position;
880 }
881
882 return result;
883 }
884
885 typedef struct {
886 const char *data;
887 size_t pos;
888 } string_data_t;
889
890 static int string_get(void *data) {
891 char c;
892 string_data_t *stream = (string_data_t *)data;
893 c = stream->data[stream->pos];
894 if (c == '\0')
895 return EOF;
896 else {
897 stream->pos++;
898 return (unsigned char)c;
899 }
900 }
901
902 json_t *json_loads(const char *string, size_t flags, json_error_t *error) {
903 lex_t lex;
904 json_t *result;
905 string_data_t stream_data;
906
907 jsonp_error_init(error, "<string>");
908
909 if (string == NULL) {
910 error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
911 return NULL;
912 }
913
914 stream_data.data = string;
915 stream_data.pos = 0;
916
917 if (lex_init(&lex, string_get, flags, (void *)&stream_data))
918 return NULL;
919
920 result = parse_json(&lex, flags, error);
921
922 lex_close(&lex);
923 return result;
924 }
925
926 typedef struct {
927 const char *data;
928 size_t len;
929 size_t pos;
930 } buffer_data_t;
931
932 static int buffer_get(void *data) {
933 char c;
934 buffer_data_t *stream = data;
935 if (stream->pos >= stream->len)
936 return EOF;
937
938 c = stream->data[stream->pos];
939 stream->pos++;
940 return (unsigned char)c;
941 }
942
943 json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error) {
944 lex_t lex;
945 json_t *result;
946 buffer_data_t stream_data;
947
948 jsonp_error_init(error, "<buffer>");
949
950 if (buffer == NULL) {
951 error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
952 return NULL;
953 }
954
955 stream_data.data = buffer;
956 stream_data.pos = 0;
957 stream_data.len = buflen;
958
959 if (lex_init(&lex, buffer_get, flags, (void *)&stream_data))
960 return NULL;
961
962 result = parse_json(&lex, flags, error);
963
964 lex_close(&lex);
965 return result;
966 }
967
968 json_t *json_loadf(FILE *input, size_t flags, json_error_t *error) {
969 lex_t lex;
970 const char *source;
971 json_t *result;
972
973 if (input == stdin)
974 source = "<stdin>";
975 else
976 source = "<stream>";
977
978 jsonp_error_init(error, source);
979
980 if (input == NULL) {
981 error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
982 return NULL;
983 }
984
985 if (lex_init(&lex, (get_func)fgetc, flags, input))
986 return NULL;
987
988 result = parse_json(&lex, flags, error);
989
990 lex_close(&lex);
991 return result;
992 }
993
994 static int fd_get_func(int *fd) {
995 #ifdef HAVE_UNISTD_H
996 uint8_t c;
997 if (read(*fd, &c, 1) == 1)
998 return c;
999 #endif
1000 return EOF;
1001 }
1002
1003 json_t *json_loadfd(int input, size_t flags, json_error_t *error) {
1004 lex_t lex;
1005 const char *source;
1006 json_t *result;
1007
1008 #ifdef HAVE_UNISTD_H
1009 if (input == STDIN_FILENO)
1010 source = "<stdin>";
1011 else
1012 #endif
1013 source = "<stream>";
1014
1015 jsonp_error_init(error, source);
1016
1017 if (input < 0) {
1018 error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
1019 return NULL;
1020 }
1021
1022 if (lex_init(&lex, (get_func)fd_get_func, flags, &input))
1023 return NULL;
1024
1025 result = parse_json(&lex, flags, error);
1026
1027 lex_close(&lex);
1028 return result;
1029 }
1030
1031 json_t *json_load_file(const char *path, size_t flags, json_error_t *error) {
1032 json_t *result;
1033 FILE *fp;
1034
1035 jsonp_error_init(error, path);
1036
1037 if (path == NULL) {
1038 error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
1039 return NULL;
1040 }
1041
1042 fp = fopen(path, "rb");
1043 if (!fp) {
1044 error_set(error, NULL, json_error_cannot_open_file, "unable to open %s: %s", path,
1045 strerror(errno));
1046 return NULL;
1047 }
1048
1049 result = json_loadf(fp, flags, error);
1050
1051 fclose(fp);
1052 return result;
1053 }
1054
1055 #define MAX_BUF_LEN 1024
1056
1057 typedef struct {
1058 char data[MAX_BUF_LEN];
1059 size_t len;
1060 size_t pos;
1061 json_load_callback_t callback;
1062 void *arg;
1063 } callback_data_t;
1064
1065 static int callback_get(void *data) {
1066 char c;
1067 callback_data_t *stream = data;
1068
1069 if (stream->pos >= stream->len) {
1070 stream->pos = 0;
1071 stream->len = stream->callback(stream->data, MAX_BUF_LEN, stream->arg);
1072 if (stream->len == 0 || stream->len == (size_t)-1)
1073 return EOF;
1074 }
1075
1076 c = stream->data[stream->pos];
1077 stream->pos++;
1078 return (unsigned char)c;
1079 }
1080
1081 json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flags,
1082 json_error_t *error) {
1083 lex_t lex;
1084 json_t *result;
1085
1086 callback_data_t stream_data;
1087
1088 memset(&stream_data, 0, sizeof(stream_data));
1089 stream_data.callback = callback;
1090 stream_data.arg = arg;
1091
1092 jsonp_error_init(error, "<callback>");
1093
1094 if (callback == NULL) {
1095 error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
1096 return NULL;
1097 }
1098
1099 if (lex_init(&lex, (get_func)callback_get, flags, &stream_data))
1100 return NULL;
1101
1102 result = parse_json(&lex, flags, error);
1103
1104 lex_close(&lex);
1105 return result;
1106 }