Fix a few more compilation issues
[profile/ivi/jansson.git] / src / load.c
1 /*
2  * Copyright (c) 2009 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 #define _GNU_SOURCE
9 #include <ctype.h>
10 #include <errno.h>
11 #include <limits.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <stdarg.h>
16 #include <unistd.h>
17 #include <assert.h>
18
19 #include <jansson.h>
20 #include "jansson_private.h"
21 #include "strbuffer.h"
22 #include "utf.h"
23
24 #define TOKEN_INVALID         -1
25 #define TOKEN_EOF              0
26 #define TOKEN_STRING         256
27 #define TOKEN_INTEGER        257
28 #define TOKEN_REAL           258
29 #define TOKEN_TRUE           259
30 #define TOKEN_FALSE          260
31 #define TOKEN_NULL           261
32
33 /* read one byte from stream, return EOF on end of file */
34 typedef int (*get_func)(void *data);
35
36 /* return non-zero if end of file has been reached */
37 typedef int (*eof_func)(void *data);
38
39 typedef struct {
40     get_func get;
41     eof_func eof;
42     void *data;
43     int stream_pos;
44     char buffer[5];
45     int buffer_pos;
46 } stream_t;
47
48
49 typedef struct {
50     stream_t stream;
51     strbuffer_t saved_text;
52     int token;
53     int line, column;
54     union {
55         char *string;
56         int integer;
57         double real;
58     } value;
59 } lex_t;
60
61
62 /*** error reporting ***/
63
64 static void error_init(json_error_t *error)
65 {
66     if(error)
67     {
68         error->text[0] = '\0';
69         error->line = -1;
70     }
71 }
72
73 static void error_set(json_error_t *error, const lex_t *lex,
74                       const char *msg, ...)
75 {
76     va_list ap;
77     char text[JSON_ERROR_TEXT_LENGTH];
78
79     if(!error || error->text[0] != '\0') {
80         /* error already set */
81         return;
82     }
83
84     va_start(ap, msg);
85     vsnprintf(text, JSON_ERROR_TEXT_LENGTH, msg, ap);
86     va_end(ap);
87
88     if(lex)
89     {
90         const char *saved_text = strbuffer_value(&lex->saved_text);
91         error->line = lex->line;
92         if(saved_text && saved_text[0])
93         {
94             if(lex->saved_text.length <= 20) {
95                 snprintf(error->text, JSON_ERROR_TEXT_LENGTH,
96                          "%s near '%s'", text, saved_text);
97             }
98             else
99                 snprintf(error->text, JSON_ERROR_TEXT_LENGTH, "%s", text);
100         }
101         else
102         {
103             snprintf(error->text, JSON_ERROR_TEXT_LENGTH,
104                      "%s near end of file", text);
105         }
106     }
107     else
108     {
109         error->line = -1;
110         snprintf(error->text, JSON_ERROR_TEXT_LENGTH, "%s", text);
111     }
112 }
113
114
115 /*** lexical analyzer ***/
116
117 void stream_init(stream_t *stream, get_func get, eof_func eof, void *data)
118 {
119     stream->get = get;
120     stream->eof = eof;
121     stream->data = data;
122     stream->stream_pos = 0;
123     stream->buffer[0] = '\0';
124     stream->buffer_pos = 0;
125 }
126
127 static char stream_get(stream_t *stream, json_error_t *error)
128 {
129     char c;
130
131     if(!stream->buffer[stream->buffer_pos])
132     {
133         stream->buffer[0] = stream->get(stream->data);
134         stream->buffer_pos = 0;
135
136         c = stream->buffer[0];
137
138         if((unsigned char)c >= 0x80 && c != (char)EOF)
139         {
140             /* multi-byte UTF-8 sequence */
141             int i, count;
142
143             count = utf8_check_first(c);
144             if(!count)
145                 goto out;
146
147             assert(count >= 2);
148
149             for(i = 1; i < count; i++)
150                 stream->buffer[i] = stream->get(stream->data);
151
152             if(!utf8_check_full(stream->buffer, count))
153                 goto out;
154
155             stream->stream_pos += count;
156             stream->buffer[count] = '\0';
157         }
158         else {
159             stream->buffer[1] = '\0';
160             stream->stream_pos++;
161         }
162     }
163
164     return stream->buffer[stream->buffer_pos++];
165
166 out:
167     error_set(error, NULL, "unable to decode byte 0x%x at position %d",
168               (unsigned char)c, stream->stream_pos);
169
170     stream->buffer[0] = EOF;
171     stream->buffer[1] = '\0';
172     stream->buffer_pos = 1;
173
174     return EOF;
175 }
176
177 static void stream_unget(stream_t *stream, char c)
178 {
179     assert(stream->buffer_pos > 0);
180     stream->buffer_pos--;
181     assert(stream->buffer[stream->buffer_pos] == c);
182 }
183
184
185 static int lex_get(lex_t *lex, json_error_t *error)
186 {
187     return stream_get(&lex->stream, error);
188 }
189
190 static int lex_eof(lex_t *lex)
191 {
192     return lex->stream.eof(lex->stream.data);
193 }
194
195 static void lex_save(lex_t *lex, char c)
196 {
197     strbuffer_append_byte(&lex->saved_text, c);
198 }
199
200 static int lex_get_save(lex_t *lex, json_error_t *error)
201 {
202     char c = stream_get(&lex->stream, error);
203     lex_save(lex, c);
204     return c;
205 }
206
207 static void lex_unget_unsave(lex_t *lex, char c)
208 {
209     char d;
210     stream_unget(&lex->stream, c);
211     d = strbuffer_pop(&lex->saved_text);
212     assert(c == d);
213 }
214
215 static void lex_save_cached(lex_t *lex)
216 {
217     while(lex->stream.buffer[lex->stream.buffer_pos] != '\0')
218     {
219         lex_save(lex, lex->stream.buffer[lex->stream.buffer_pos]);
220         lex->stream.buffer_pos++;
221     }
222 }
223
224 /* assumes that str points to 'u' plus at least 4 valid hex digits */
225 static int decode_unicode_escape(const char *str)
226 {
227     int i;
228     int value = 0;
229
230     assert(str[0] == 'u');
231
232     for(i = 1; i <= 4; i++) {
233         char c = str[i];
234         value <<= 4;
235         if(isdigit(c))
236             value += c - '0';
237         else if(islower(c))
238             value += c - 'a' + 10;
239         else if(isupper(c))
240             value += c - 'A' + 10;
241         else
242             assert(0);
243     }
244
245     return value;
246 }
247
248 static void lex_scan_string(lex_t *lex, json_error_t *error)
249 {
250     char c;
251     const char *p;
252     char *t;
253     int i;
254
255     lex->value.string = NULL;
256     lex->token = TOKEN_INVALID;
257
258     c = lex_get_save(lex, error);
259
260     while(c != '"') {
261         if(c == (char)EOF) {
262             lex_unget_unsave(lex, c);
263             if(lex_eof(lex))
264                 error_set(error, lex, "premature end of input");
265             goto out;
266         }
267
268         else if((unsigned char)c <= 0x1F) {
269             /* control character */
270             lex_unget_unsave(lex, c);
271             if(c == '\n')
272                 error_set(error, lex, "unexpected newline", c);
273             else
274                 error_set(error, lex, "control character 0x%x", c);
275             goto out;
276         }
277
278         else if(c == '\\') {
279             c = lex_get_save(lex, error);
280             if(c == 'u') {
281                 c = lex_get_save(lex, error);
282                 for(i = 0; i < 4; i++) {
283                     if(!isxdigit(c)) {
284                         lex_unget_unsave(lex, c);
285                         error_set(error, lex, "invalid escape");
286                         goto out;
287                     }
288                     c = lex_get_save(lex, error);
289                 }
290             }
291             else if(c == '"' || c == '\\' || c == '/' || c == 'b' ||
292                     c == 'f' || c == 'n' || c == 'r' || c == 't')
293                 c = lex_get_save(lex, error);
294             else {
295                 lex_unget_unsave(lex, c);
296                 error_set(error, lex, "invalid escape");
297                 goto out;
298             }
299         }
300         else
301             c = lex_get_save(lex, error);
302     }
303
304     /* the actual value is at most of the same length as the source
305        string, because:
306          - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
307          - a single \uXXXX escape (length 6) is converted to at most 3 bytes
308          - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
309            are converted to 4 bytes
310     */
311     lex->value.string = malloc(lex->saved_text.length + 1);
312     if(!lex->value.string) {
313         /* this is not very nice, since TOKEN_INVALID is returned */
314         goto out;
315     }
316
317     /* the target */
318     t = lex->value.string;
319
320     /* + 1 to skip the " */
321     p = strbuffer_value(&lex->saved_text) + 1;
322
323     while(*p != '"') {
324         if(*p == '\\') {
325             p++;
326             if(*p == 'u') {
327                 char buffer[4];
328                 int length;
329                 int value;
330
331                 value = decode_unicode_escape(p);
332                 p += 5;
333
334                 if(0xD800 <= value && value <= 0xDBFF) {
335                     /* surrogate pair */
336                     if(*p == '\\' && *(p + 1) == 'u') {
337                         int value2 = decode_unicode_escape(++p);
338                         p += 5;
339
340                         if(0xDC00 <= value2 && value2 <= 0xDFFF) {
341                             /* valid second surrogate */
342                             value = ((value - 0xD800) << 10) +
343                                     (value2 - 0xDC00) +
344                                     0x10000;
345                         }
346                         else {
347                             /* invalid second surrogate */
348                             error_set(error, lex,
349                                       "invalid Unicode '\\u%04X\\u%04X'",
350                                       value, value2);
351                             goto out;
352                         }
353                     }
354                     else {
355                         /* no second surrogate */
356                         error_set(error, lex, "invalid Unicode '\\u%04X'",
357                                   value);
358                         goto out;
359                     }
360                 }
361                 else if(0xDC00 <= value && value <= 0xDFFF) {
362                     error_set(error, lex, "invalid Unicode '\\u%04X'", value);
363                     goto out;
364                 }
365                 else if(value == 0)
366                 {
367                     error_set(error, lex, "\\u0000 is not allowed");
368                     goto out;
369                 }
370
371                 if(utf8_encode(value, buffer, &length))
372                     assert(0);
373
374                 memcpy(t, buffer, length);
375                 t += length;
376             }
377             else {
378                 switch(*p) {
379                     case '"': case '\\': case '/':
380                         *t = *p; break;
381                     case 'b': *t = '\b'; break;
382                     case 'f': *t = '\f'; break;
383                     case 'n': *t = '\n'; break;
384                     case 'r': *t = '\r'; break;
385                     case 't': *t = '\t'; break;
386                     default: assert(0);
387                 }
388                 t++;
389                 p++;
390             }
391         }
392         else
393             *(t++) = *(p++);
394     }
395     *t = '\0';
396     lex->token = TOKEN_STRING;
397     return;
398
399 out:
400     free(lex->value.string);
401 }
402
403 static int lex_scan_number(lex_t *lex, char c, json_error_t *error)
404 {
405     const char *saved_text;
406     char *end;
407     double value;
408
409     lex->token = TOKEN_INVALID;
410
411     if(c == '-')
412         c = lex_get_save(lex, error);
413
414     if(c == '0') {
415         c = lex_get_save(lex, error);
416         if(isdigit(c)) {
417             lex_unget_unsave(lex, c);
418             goto out;
419         }
420     }
421     else /* c != '0' */ {
422         c = lex_get_save(lex, error);
423         while(isdigit(c))
424             c = lex_get_save(lex, error);
425     }
426
427     if(c != '.' && c != 'E' && c != 'e') {
428         long value;
429
430         lex_unget_unsave(lex, c);
431
432         saved_text = strbuffer_value(&lex->saved_text);
433         value = strtol(saved_text, &end, 10);
434         assert(end == saved_text + lex->saved_text.length);
435
436         if((value == LONG_MAX && errno == ERANGE) || value > INT_MAX) {
437             error_set(error, lex, "too big integer");
438             goto out;
439         }
440         else if((value == LONG_MIN && errno == ERANGE) || value < INT_MIN) {
441             error_set(error, lex, "too big negative integer");
442             goto out;
443         }
444
445         lex->token = TOKEN_INTEGER;
446         lex->value.integer = (int)value;
447         return 0;
448     }
449
450     if(c == '.') {
451         c = lex_get(lex, error);
452         if(!isdigit(c))
453             goto out;
454         lex_save(lex, c);
455
456         c = lex_get_save(lex, error);
457         while(isdigit(c))
458             c = lex_get_save(lex, error);
459     }
460
461     if(c == 'E' || c == 'e') {
462         c = lex_get_save(lex, error);
463         if(c == '+' || c == '-')
464             c = lex_get_save(lex, error);
465
466         if(!isdigit(c)) {
467             lex_unget_unsave(lex, c);
468             goto out;
469         }
470
471         c = lex_get_save(lex, error);
472         while(isdigit(c))
473             c = lex_get_save(lex, error);
474     }
475
476     lex_unget_unsave(lex, c);
477
478     saved_text = strbuffer_value(&lex->saved_text);
479     value = strtod(saved_text, &end);
480     assert(end == saved_text + lex->saved_text.length);
481
482     if(value == 0 && errno == ERANGE) {
483         error_set(error, lex, "real number underflow");
484         goto out;
485     }
486
487     /* Cannot test for +/-HUGE_VAL because the HUGE_VAL constant is
488        only defined in C99 mode. So let's trust in sole errno. */
489     else if(errno == ERANGE) {
490         error_set(error, lex, "real number overflow");
491         goto out;
492     }
493
494     lex->token = TOKEN_REAL;
495     lex->value.real = value;
496     return 0;
497
498 out:
499     return -1;
500 }
501
502 static int lex_scan(lex_t *lex, json_error_t *error)
503 {
504     char c;
505
506     strbuffer_clear(&lex->saved_text);
507
508     if(lex->token == TOKEN_STRING) {
509       free(lex->value.string);
510       lex->value.string = NULL;
511     }
512
513     c = lex_get(lex, error);
514     while(c == ' ' || c == '\t' || c == '\n' || c == '\r')
515     {
516         if(c == '\n')
517             lex->line++;
518
519         c = lex_get(lex, error);
520     }
521
522     if(c == (char)EOF) {
523         if(lex_eof(lex))
524             lex->token = TOKEN_EOF;
525         else
526             lex->token = TOKEN_INVALID;
527         goto out;
528     }
529
530     lex_save(lex, c);
531
532     if(c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
533         lex->token = c;
534
535     else if(c == '"')
536         lex_scan_string(lex, error);
537
538     else if(isdigit(c) || c == '-') {
539         if(lex_scan_number(lex, c, error))
540             goto out;
541     }
542
543     else if(isupper(c) || islower(c)) {
544         /* eat up the whole identifier for clearer error messages */
545         const char *saved_text;
546
547         c = lex_get_save(lex, error);
548         while(isupper(c) || islower(c))
549             c = lex_get_save(lex, error);
550         lex_unget_unsave(lex, c);
551
552         saved_text = strbuffer_value(&lex->saved_text);
553
554         if(strcmp(saved_text, "true") == 0)
555             lex->token = TOKEN_TRUE;
556         else if(strcmp(saved_text, "false") == 0)
557             lex->token = TOKEN_FALSE;
558         else if(strcmp(saved_text, "null") == 0)
559             lex->token = TOKEN_NULL;
560         else
561             lex->token = TOKEN_INVALID;
562     }
563
564     else {
565         /* save the rest of the input UTF-8 sequence to get an error
566            message of valid UTF-8 */
567         lex_save_cached(lex);
568         lex->token = TOKEN_INVALID;
569     }
570
571 out:
572     return lex->token;
573 }
574
575 static int lex_init(lex_t *lex, get_func get, eof_func eof, void *data)
576 {
577     stream_init(&lex->stream, get, eof, data);
578     if(strbuffer_init(&lex->saved_text))
579         return -1;
580
581     lex->token = TOKEN_INVALID;
582     lex->line = 1;
583
584     return 0;
585 }
586
587 static void lex_close(lex_t *lex)
588 {
589     if(lex->token == TOKEN_STRING)
590         free(lex->value.string);
591     strbuffer_close(&lex->saved_text);
592 }
593
594
595 /*** parser ***/
596
597 static json_t *parse_value(lex_t *lex, json_error_t *error);
598
599 static json_t *parse_object(lex_t *lex, json_error_t *error)
600 {
601     json_t *object = json_object();
602     if(!object)
603         return NULL;
604
605     lex_scan(lex, error);
606     if(lex->token == '}')
607         return object;
608
609     while(1) {
610         char *key;
611         json_t *value;
612
613         if(lex->token != TOKEN_STRING) {
614             error_set(error, lex, "string or '}' expected");
615             goto error;
616         }
617
618         key = strdup(lex->value.string);
619         if(!key)
620             return NULL;
621
622         lex_scan(lex, error);
623         if(lex->token != ':') {
624             free(key);
625             error_set(error, lex, "':' expected");
626             goto error;
627         }
628
629         lex_scan(lex, error);
630         value = parse_value(lex, error);
631         if(!value) {
632             free(key);
633             goto error;
634         }
635
636         if(json_object_set_nocheck(object, key, value)) {
637             free(key);
638             json_decref(value);
639             goto error;
640         }
641
642         json_decref(value);
643         free(key);
644
645         lex_scan(lex, error);
646         if(lex->token != ',')
647             break;
648
649         lex_scan(lex, error);
650     }
651
652     if(lex->token != '}') {
653         error_set(error, lex, "'}' expected");
654         goto error;
655     }
656
657     return object;
658
659 error:
660     json_decref(object);
661     return NULL;
662 }
663
664 static json_t *parse_array(lex_t *lex, json_error_t *error)
665 {
666     json_t *array = json_array();
667     if(!array)
668         return NULL;
669
670     lex_scan(lex, error);
671     if(lex->token == ']')
672         return array;
673
674     while(lex->token) {
675         json_t *elem = parse_value(lex, error);
676         if(!elem)
677             goto error;
678
679         if(json_array_append(array, elem)) {
680             json_decref(elem);
681             goto error;
682         }
683         json_decref(elem);
684
685         lex_scan(lex, error);
686         if(lex->token != ',')
687             break;
688
689         lex_scan(lex, error);
690     }
691
692     if(lex->token != ']') {
693         error_set(error, lex, "']' expected");
694         goto error;
695     }
696
697     return array;
698
699 error:
700     json_decref(array);
701     return NULL;
702 }
703
704 static json_t *parse_value(lex_t *lex, json_error_t *error)
705 {
706     json_t *json;
707
708     switch(lex->token) {
709         case TOKEN_STRING: {
710             json = json_string_nocheck(lex->value.string);
711             break;
712         }
713
714         case TOKEN_INTEGER: {
715             json = json_integer(lex->value.integer);
716             break;
717         }
718
719         case TOKEN_REAL: {
720             json = json_real(lex->value.real);
721             break;
722         }
723
724         case TOKEN_TRUE:
725             json = json_true();
726             break;
727
728         case TOKEN_FALSE:
729             json = json_false();
730             break;
731
732         case TOKEN_NULL:
733             json = json_null();
734             break;
735
736         case '{':
737           json = parse_object(lex, error);
738             break;
739
740         case '[':
741             json = parse_array(lex, error);
742             break;
743
744         case TOKEN_INVALID:
745             error_set(error, lex, "invalid token");
746             return NULL;
747
748         default:
749             error_set(error, lex, "unexpected token");
750             return NULL;
751     }
752
753     if(!json)
754         return NULL;
755
756     return json;
757 }
758
759 json_t *parse_json(lex_t *lex, json_error_t *error)
760 {
761     error_init(error);
762
763     lex_scan(lex, error);
764     if(lex->token != '[' && lex->token != '{') {
765         error_set(error, lex, "'[' or '{' expected");
766         return NULL;
767     }
768
769     return parse_value(lex, error);
770 }
771
772 typedef struct
773 {
774     const char *data;
775     int pos;
776 } string_data_t;
777
778 static int string_get(void *data)
779 {
780     char c;
781     string_data_t *stream = (string_data_t *)data;
782     c = stream->data[stream->pos];
783     if(c == '\0')
784         return EOF;
785     else
786     {
787         stream->pos++;
788         return c;
789     }
790 }
791
792 static int string_eof(void *data)
793 {
794     string_data_t *stream = (string_data_t *)data;
795     return (stream->data[stream->pos] == '\0');
796 }
797
798 json_t *json_loads(const char *string, json_error_t *error)
799 {
800     lex_t lex;
801     json_t *result;
802
803     string_data_t stream_data = {
804         .data = string,
805         .pos = 0
806     };
807
808     if(lex_init(&lex, string_get, string_eof, (void *)&stream_data))
809         return NULL;
810
811     result = parse_json(&lex, error);
812     if(!result)
813         goto out;
814
815     lex_scan(&lex, error);
816     if(lex.token != TOKEN_EOF) {
817         error_set(error, &lex, "end of file expected");
818         json_decref(result);
819         result = NULL;
820     }
821
822 out:
823     lex_close(&lex);
824     return result;
825 }
826
827 json_t *json_loadf(FILE *input, json_error_t *error)
828 {
829     lex_t lex;
830     json_t *result;
831
832     if(lex_init(&lex, (get_func)fgetc, (eof_func)feof, input))
833         return NULL;
834
835     result = parse_json(&lex, error);
836     if(!result)
837         goto out;
838
839     lex_scan(&lex, error);
840     if(lex.token != TOKEN_EOF) {
841         error_set(error, &lex, "end of file expected");
842         json_decref(result);
843         result = NULL;
844     }
845
846 out:
847     lex_close(&lex);
848     return result;
849 }
850
851 json_t *json_load_file(const char *path, json_error_t *error)
852 {
853     json_t *result;
854     FILE *fp;
855
856     fp = fopen(path, "r");
857     if(!fp)
858     {
859         error_set(error, NULL, "unable to open %s: %s",
860                   path, strerror(errno));
861         return NULL;
862     }
863
864     result = json_loadf(fp, error);
865
866     fclose(fp);
867     return result;
868 }