Merge remote-tracking branch 'remotes/kraxel/tags/pull-seabios-1.7.5.1-20141113-1...
[qemu.git] / qobject / json-parser.c
1 /*
2 * JSON Parser
3 *
4 * Copyright IBM, Corp. 2009
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10 * See the COPYING.LIB file in the top-level directory.
11 *
12 */
13
14 #include <stdarg.h>
15
16 #include "qemu-common.h"
17 #include "qapi/qmp/qstring.h"
18 #include "qapi/qmp/qint.h"
19 #include "qapi/qmp/qdict.h"
20 #include "qapi/qmp/qlist.h"
21 #include "qapi/qmp/qfloat.h"
22 #include "qapi/qmp/qbool.h"
23 #include "qapi/qmp/json-parser.h"
24 #include "qapi/qmp/json-lexer.h"
25 #include "qapi/qmp/qerror.h"
26
27 typedef struct JSONParserContext
28 {
29 Error *err;
30 struct {
31 QObject **buf;
32 size_t pos;
33 size_t count;
34 } tokens;
35 } JSONParserContext;
36
37 #define BUG_ON(cond) assert(!(cond))
38
39 /**
40 * TODO
41 *
42 * 0) make errors meaningful again
43 * 1) add geometry information to tokens
44 * 3) should we return a parsed size?
45 * 4) deal with premature EOI
46 */
47
48 static QObject *parse_value(JSONParserContext *ctxt, va_list *ap);
49
50 /**
51 * Token manipulators
52 *
53 * tokens are dictionaries that contain a type, a string value, and geometry information
54 * about a token identified by the lexer. These are routines that make working with
55 * these objects a bit easier.
56 */
57 static const char *token_get_value(QObject *obj)
58 {
59 return qdict_get_str(qobject_to_qdict(obj), "token");
60 }
61
62 static JSONTokenType token_get_type(QObject *obj)
63 {
64 return qdict_get_int(qobject_to_qdict(obj), "type");
65 }
66
67 static int token_is_operator(QObject *obj, char op)
68 {
69 const char *val;
70
71 if (token_get_type(obj) != JSON_OPERATOR) {
72 return 0;
73 }
74
75 val = token_get_value(obj);
76
77 return (val[0] == op) && (val[1] == 0);
78 }
79
80 static int token_is_keyword(QObject *obj, const char *value)
81 {
82 if (token_get_type(obj) != JSON_KEYWORD) {
83 return 0;
84 }
85
86 return strcmp(token_get_value(obj), value) == 0;
87 }
88
89 static int token_is_escape(QObject *obj, const char *value)
90 {
91 if (token_get_type(obj) != JSON_ESCAPE) {
92 return 0;
93 }
94
95 return (strcmp(token_get_value(obj), value) == 0);
96 }
97
98 /**
99 * Error handler
100 */
101 static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt,
102 QObject *token, const char *msg, ...)
103 {
104 va_list ap;
105 char message[1024];
106 va_start(ap, msg);
107 vsnprintf(message, sizeof(message), msg, ap);
108 va_end(ap);
109 if (ctxt->err) {
110 error_free(ctxt->err);
111 ctxt->err = NULL;
112 }
113 error_setg(&ctxt->err, "JSON parse error, %s", message);
114 }
115
116 /**
117 * String helpers
118 *
119 * These helpers are used to unescape strings.
120 */
121 static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length)
122 {
123 if (wchar <= 0x007F) {
124 BUG_ON(buffer_length < 2);
125
126 buffer[0] = wchar & 0x7F;
127 buffer[1] = 0;
128 } else if (wchar <= 0x07FF) {
129 BUG_ON(buffer_length < 3);
130
131 buffer[0] = 0xC0 | ((wchar >> 6) & 0x1F);
132 buffer[1] = 0x80 | (wchar & 0x3F);
133 buffer[2] = 0;
134 } else {
135 BUG_ON(buffer_length < 4);
136
137 buffer[0] = 0xE0 | ((wchar >> 12) & 0x0F);
138 buffer[1] = 0x80 | ((wchar >> 6) & 0x3F);
139 buffer[2] = 0x80 | (wchar & 0x3F);
140 buffer[3] = 0;
141 }
142 }
143
144 static int hex2decimal(char ch)
145 {
146 if (ch >= '0' && ch <= '9') {
147 return (ch - '0');
148 } else if (ch >= 'a' && ch <= 'f') {
149 return 10 + (ch - 'a');
150 } else if (ch >= 'A' && ch <= 'F') {
151 return 10 + (ch - 'A');
152 }
153
154 return -1;
155 }
156
157 /**
158 * parse_string(): Parse a json string and return a QObject
159 *
160 * string
161 * ""
162 * " chars "
163 * chars
164 * char
165 * char chars
166 * char
167 * any-Unicode-character-
168 * except-"-or-\-or-
169 * control-character
170 * \"
171 * \\
172 * \/
173 * \b
174 * \f
175 * \n
176 * \r
177 * \t
178 * \u four-hex-digits
179 */
180 static QString *qstring_from_escaped_str(JSONParserContext *ctxt, QObject *token)
181 {
182 const char *ptr = token_get_value(token);
183 QString *str;
184 int double_quote = 1;
185
186 if (*ptr == '"') {
187 double_quote = 1;
188 } else {
189 double_quote = 0;
190 }
191 ptr++;
192
193 str = qstring_new();
194 while (*ptr &&
195 ((double_quote && *ptr != '"') || (!double_quote && *ptr != '\''))) {
196 if (*ptr == '\\') {
197 ptr++;
198
199 switch (*ptr) {
200 case '"':
201 qstring_append(str, "\"");
202 ptr++;
203 break;
204 case '\'':
205 qstring_append(str, "'");
206 ptr++;
207 break;
208 case '\\':
209 qstring_append(str, "\\");
210 ptr++;
211 break;
212 case '/':
213 qstring_append(str, "/");
214 ptr++;
215 break;
216 case 'b':
217 qstring_append(str, "\b");
218 ptr++;
219 break;
220 case 'f':
221 qstring_append(str, "\f");
222 ptr++;
223 break;
224 case 'n':
225 qstring_append(str, "\n");
226 ptr++;
227 break;
228 case 'r':
229 qstring_append(str, "\r");
230 ptr++;
231 break;
232 case 't':
233 qstring_append(str, "\t");
234 ptr++;
235 break;
236 case 'u': {
237 uint16_t unicode_char = 0;
238 char utf8_char[4];
239 int i = 0;
240
241 ptr++;
242
243 for (i = 0; i < 4; i++) {
244 if (qemu_isxdigit(*ptr)) {
245 unicode_char |= hex2decimal(*ptr) << ((3 - i) * 4);
246 } else {
247 parse_error(ctxt, token,
248 "invalid hex escape sequence in string");
249 goto out;
250 }
251 ptr++;
252 }
253
254 wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char));
255 qstring_append(str, utf8_char);
256 } break;
257 default:
258 parse_error(ctxt, token, "invalid escape sequence in string");
259 goto out;
260 }
261 } else {
262 char dummy[2];
263
264 dummy[0] = *ptr++;
265 dummy[1] = 0;
266
267 qstring_append(str, dummy);
268 }
269 }
270
271 return str;
272
273 out:
274 QDECREF(str);
275 return NULL;
276 }
277
278 static QObject *parser_context_pop_token(JSONParserContext *ctxt)
279 {
280 QObject *token;
281 g_assert(ctxt->tokens.pos < ctxt->tokens.count);
282 token = ctxt->tokens.buf[ctxt->tokens.pos];
283 ctxt->tokens.pos++;
284 return token;
285 }
286
287 /* Note: parser_context_{peek|pop}_token do not increment the
288 * token object's refcount. In both cases the references will continue
289 * to be tracked and cleaned up in parser_context_free(), so do not
290 * attempt to free the token object.
291 */
292 static QObject *parser_context_peek_token(JSONParserContext *ctxt)
293 {
294 QObject *token;
295 g_assert(ctxt->tokens.pos < ctxt->tokens.count);
296 token = ctxt->tokens.buf[ctxt->tokens.pos];
297 return token;
298 }
299
300 static JSONParserContext parser_context_save(JSONParserContext *ctxt)
301 {
302 JSONParserContext saved_ctxt = {0};
303 saved_ctxt.tokens.pos = ctxt->tokens.pos;
304 saved_ctxt.tokens.count = ctxt->tokens.count;
305 saved_ctxt.tokens.buf = ctxt->tokens.buf;
306 return saved_ctxt;
307 }
308
309 static void parser_context_restore(JSONParserContext *ctxt,
310 JSONParserContext saved_ctxt)
311 {
312 ctxt->tokens.pos = saved_ctxt.tokens.pos;
313 ctxt->tokens.count = saved_ctxt.tokens.count;
314 ctxt->tokens.buf = saved_ctxt.tokens.buf;
315 }
316
317 static void tokens_append_from_iter(QObject *obj, void *opaque)
318 {
319 JSONParserContext *ctxt = opaque;
320 g_assert(ctxt->tokens.pos < ctxt->tokens.count);
321 ctxt->tokens.buf[ctxt->tokens.pos++] = obj;
322 qobject_incref(obj);
323 }
324
325 static JSONParserContext *parser_context_new(QList *tokens)
326 {
327 JSONParserContext *ctxt;
328 size_t count;
329
330 if (!tokens) {
331 return NULL;
332 }
333
334 count = qlist_size(tokens);
335 if (count == 0) {
336 return NULL;
337 }
338
339 ctxt = g_malloc0(sizeof(JSONParserContext));
340 ctxt->tokens.pos = 0;
341 ctxt->tokens.count = count;
342 ctxt->tokens.buf = g_malloc(count * sizeof(QObject *));
343 qlist_iter(tokens, tokens_append_from_iter, ctxt);
344 ctxt->tokens.pos = 0;
345
346 return ctxt;
347 }
348
349 /* to support error propagation, ctxt->err must be freed separately */
350 static void parser_context_free(JSONParserContext *ctxt)
351 {
352 int i;
353 if (ctxt) {
354 for (i = 0; i < ctxt->tokens.count; i++) {
355 qobject_decref(ctxt->tokens.buf[i]);
356 }
357 g_free(ctxt->tokens.buf);
358 g_free(ctxt);
359 }
360 }
361
362 /**
363 * Parsing rules
364 */
365 static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap)
366 {
367 QObject *key = NULL, *token = NULL, *value, *peek;
368 JSONParserContext saved_ctxt = parser_context_save(ctxt);
369
370 peek = parser_context_peek_token(ctxt);
371 if (peek == NULL) {
372 parse_error(ctxt, NULL, "premature EOI");
373 goto out;
374 }
375
376 key = parse_value(ctxt, ap);
377 if (!key || qobject_type(key) != QTYPE_QSTRING) {
378 parse_error(ctxt, peek, "key is not a string in object");
379 goto out;
380 }
381
382 token = parser_context_pop_token(ctxt);
383 if (token == NULL) {
384 parse_error(ctxt, NULL, "premature EOI");
385 goto out;
386 }
387
388 if (!token_is_operator(token, ':')) {
389 parse_error(ctxt, token, "missing : in object pair");
390 goto out;
391 }
392
393 value = parse_value(ctxt, ap);
394 if (value == NULL) {
395 parse_error(ctxt, token, "Missing value in dict");
396 goto out;
397 }
398
399 qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
400
401 qobject_decref(key);
402
403 return 0;
404
405 out:
406 parser_context_restore(ctxt, saved_ctxt);
407 qobject_decref(key);
408
409 return -1;
410 }
411
412 static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
413 {
414 QDict *dict = NULL;
415 QObject *token, *peek;
416 JSONParserContext saved_ctxt = parser_context_save(ctxt);
417
418 token = parser_context_pop_token(ctxt);
419 if (token == NULL) {
420 goto out;
421 }
422
423 if (!token_is_operator(token, '{')) {
424 goto out;
425 }
426
427 dict = qdict_new();
428
429 peek = parser_context_peek_token(ctxt);
430 if (peek == NULL) {
431 parse_error(ctxt, NULL, "premature EOI");
432 goto out;
433 }
434
435 if (!token_is_operator(peek, '}')) {
436 if (parse_pair(ctxt, dict, ap) == -1) {
437 goto out;
438 }
439
440 token = parser_context_pop_token(ctxt);
441 if (token == NULL) {
442 parse_error(ctxt, NULL, "premature EOI");
443 goto out;
444 }
445
446 while (!token_is_operator(token, '}')) {
447 if (!token_is_operator(token, ',')) {
448 parse_error(ctxt, token, "expected separator in dict");
449 goto out;
450 }
451
452 if (parse_pair(ctxt, dict, ap) == -1) {
453 goto out;
454 }
455
456 token = parser_context_pop_token(ctxt);
457 if (token == NULL) {
458 parse_error(ctxt, NULL, "premature EOI");
459 goto out;
460 }
461 }
462 } else {
463 (void)parser_context_pop_token(ctxt);
464 }
465
466 return QOBJECT(dict);
467
468 out:
469 parser_context_restore(ctxt, saved_ctxt);
470 QDECREF(dict);
471 return NULL;
472 }
473
474 static QObject *parse_array(JSONParserContext *ctxt, va_list *ap)
475 {
476 QList *list = NULL;
477 QObject *token, *peek;
478 JSONParserContext saved_ctxt = parser_context_save(ctxt);
479
480 token = parser_context_pop_token(ctxt);
481 if (token == NULL) {
482 goto out;
483 }
484
485 if (!token_is_operator(token, '[')) {
486 goto out;
487 }
488
489 list = qlist_new();
490
491 peek = parser_context_peek_token(ctxt);
492 if (peek == NULL) {
493 parse_error(ctxt, NULL, "premature EOI");
494 goto out;
495 }
496
497 if (!token_is_operator(peek, ']')) {
498 QObject *obj;
499
500 obj = parse_value(ctxt, ap);
501 if (obj == NULL) {
502 parse_error(ctxt, token, "expecting value");
503 goto out;
504 }
505
506 qlist_append_obj(list, obj);
507
508 token = parser_context_pop_token(ctxt);
509 if (token == NULL) {
510 parse_error(ctxt, NULL, "premature EOI");
511 goto out;
512 }
513
514 while (!token_is_operator(token, ']')) {
515 if (!token_is_operator(token, ',')) {
516 parse_error(ctxt, token, "expected separator in list");
517 goto out;
518 }
519
520 obj = parse_value(ctxt, ap);
521 if (obj == NULL) {
522 parse_error(ctxt, token, "expecting value");
523 goto out;
524 }
525
526 qlist_append_obj(list, obj);
527
528 token = parser_context_pop_token(ctxt);
529 if (token == NULL) {
530 parse_error(ctxt, NULL, "premature EOI");
531 goto out;
532 }
533 }
534 } else {
535 (void)parser_context_pop_token(ctxt);
536 }
537
538 return QOBJECT(list);
539
540 out:
541 parser_context_restore(ctxt, saved_ctxt);
542 QDECREF(list);
543 return NULL;
544 }
545
546 static QObject *parse_keyword(JSONParserContext *ctxt)
547 {
548 QObject *token, *ret;
549 JSONParserContext saved_ctxt = parser_context_save(ctxt);
550
551 token = parser_context_pop_token(ctxt);
552 if (token == NULL) {
553 goto out;
554 }
555
556 if (token_get_type(token) != JSON_KEYWORD) {
557 goto out;
558 }
559
560 if (token_is_keyword(token, "true")) {
561 ret = QOBJECT(qbool_from_int(true));
562 } else if (token_is_keyword(token, "false")) {
563 ret = QOBJECT(qbool_from_int(false));
564 } else {
565 parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token));
566 goto out;
567 }
568
569 return ret;
570
571 out:
572 parser_context_restore(ctxt, saved_ctxt);
573
574 return NULL;
575 }
576
577 static QObject *parse_escape(JSONParserContext *ctxt, va_list *ap)
578 {
579 QObject *token = NULL, *obj;
580 JSONParserContext saved_ctxt = parser_context_save(ctxt);
581
582 if (ap == NULL) {
583 goto out;
584 }
585
586 token = parser_context_pop_token(ctxt);
587 if (token == NULL) {
588 goto out;
589 }
590
591 if (token_is_escape(token, "%p")) {
592 obj = va_arg(*ap, QObject *);
593 } else if (token_is_escape(token, "%i")) {
594 obj = QOBJECT(qbool_from_int(va_arg(*ap, int)));
595 } else if (token_is_escape(token, "%d")) {
596 obj = QOBJECT(qint_from_int(va_arg(*ap, int)));
597 } else if (token_is_escape(token, "%ld")) {
598 obj = QOBJECT(qint_from_int(va_arg(*ap, long)));
599 } else if (token_is_escape(token, "%lld") ||
600 token_is_escape(token, "%I64d")) {
601 obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));
602 } else if (token_is_escape(token, "%s")) {
603 obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
604 } else if (token_is_escape(token, "%f")) {
605 obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));
606 } else {
607 goto out;
608 }
609
610 return obj;
611
612 out:
613 parser_context_restore(ctxt, saved_ctxt);
614
615 return NULL;
616 }
617
618 static QObject *parse_literal(JSONParserContext *ctxt)
619 {
620 QObject *token, *obj;
621 JSONParserContext saved_ctxt = parser_context_save(ctxt);
622
623 token = parser_context_pop_token(ctxt);
624 if (token == NULL) {
625 goto out;
626 }
627
628 switch (token_get_type(token)) {
629 case JSON_STRING:
630 obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
631 break;
632 case JSON_INTEGER: {
633 /* A possibility exists that this is a whole-valued float where the
634 * fractional part was left out due to being 0 (.0). It's not a big
635 * deal to treat these as ints in the parser, so long as users of the
636 * resulting QObject know to expect a QInt in place of a QFloat in
637 * cases like these.
638 *
639 * However, in some cases these values will overflow/underflow a
640 * QInt/int64 container, thus we should assume these are to be handled
641 * as QFloats/doubles rather than silently changing their values.
642 *
643 * strtoll() indicates these instances by setting errno to ERANGE
644 */
645 int64_t value;
646
647 errno = 0; /* strtoll doesn't set errno on success */
648 value = strtoll(token_get_value(token), NULL, 10);
649 if (errno != ERANGE) {
650 obj = QOBJECT(qint_from_int(value));
651 break;
652 }
653 /* fall through to JSON_FLOAT */
654 }
655 case JSON_FLOAT:
656 /* FIXME dependent on locale */
657 obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
658 break;
659 default:
660 goto out;
661 }
662
663 return obj;
664
665 out:
666 parser_context_restore(ctxt, saved_ctxt);
667
668 return NULL;
669 }
670
671 static QObject *parse_value(JSONParserContext *ctxt, va_list *ap)
672 {
673 QObject *obj;
674
675 obj = parse_object(ctxt, ap);
676 if (obj == NULL) {
677 obj = parse_array(ctxt, ap);
678 }
679 if (obj == NULL) {
680 obj = parse_escape(ctxt, ap);
681 }
682 if (obj == NULL) {
683 obj = parse_keyword(ctxt);
684 }
685 if (obj == NULL) {
686 obj = parse_literal(ctxt);
687 }
688
689 return obj;
690 }
691
692 QObject *json_parser_parse(QList *tokens, va_list *ap)
693 {
694 return json_parser_parse_err(tokens, ap, NULL);
695 }
696
697 QObject *json_parser_parse_err(QList *tokens, va_list *ap, Error **errp)
698 {
699 JSONParserContext *ctxt = parser_context_new(tokens);
700 QObject *result;
701
702 if (!ctxt) {
703 return NULL;
704 }
705
706 result = parse_value(ctxt, ap);
707
708 error_propagate(errp, ctxt->err);
709
710 parser_context_free(ctxt);
711
712 return result;
713 }