4 * Copyright IBM, Corp. 2009
7 * Anthony Liguori <aliguori@us.ibm.com>
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.
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"
26 typedef struct JSONParserContext
36 #define BUG_ON(cond) assert(!(cond))
41 * 0) make errors meaningful again
42 * 1) add geometry information to tokens
43 * 3) should we return a parsed size?
44 * 4) deal with premature EOI
47 static QObject
*parse_value(JSONParserContext
*ctxt
, va_list *ap
);
52 * tokens are dictionaries that contain a type, a string value, and geometry information
53 * about a token identified by the lexer. These are routines that make working with
54 * these objects a bit easier.
56 static const char *token_get_value(QObject
*obj
)
58 return qdict_get_str(qobject_to_qdict(obj
), "token");
61 static JSONTokenType
token_get_type(QObject
*obj
)
63 return qdict_get_int(qobject_to_qdict(obj
), "type");
66 static int token_is_keyword(QObject
*obj
, const char *value
)
68 if (token_get_type(obj
) != JSON_KEYWORD
) {
72 return strcmp(token_get_value(obj
), value
) == 0;
75 static int token_is_escape(QObject
*obj
, const char *value
)
77 if (token_get_type(obj
) != JSON_ESCAPE
) {
81 return (strcmp(token_get_value(obj
), value
) == 0);
87 static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext
*ctxt
,
88 QObject
*token
, const char *msg
, ...)
93 vsnprintf(message
, sizeof(message
), msg
, ap
);
96 error_free(ctxt
->err
);
99 error_setg(&ctxt
->err
, "JSON parse error, %s", message
);
105 * These helpers are used to unescape strings.
107 static void wchar_to_utf8(uint16_t wchar
, char *buffer
, size_t buffer_length
)
109 if (wchar
<= 0x007F) {
110 BUG_ON(buffer_length
< 2);
112 buffer
[0] = wchar
& 0x7F;
114 } else if (wchar
<= 0x07FF) {
115 BUG_ON(buffer_length
< 3);
117 buffer
[0] = 0xC0 | ((wchar
>> 6) & 0x1F);
118 buffer
[1] = 0x80 | (wchar
& 0x3F);
121 BUG_ON(buffer_length
< 4);
123 buffer
[0] = 0xE0 | ((wchar
>> 12) & 0x0F);
124 buffer
[1] = 0x80 | ((wchar
>> 6) & 0x3F);
125 buffer
[2] = 0x80 | (wchar
& 0x3F);
130 static int hex2decimal(char ch
)
132 if (ch
>= '0' && ch
<= '9') {
134 } else if (ch
>= 'a' && ch
<= 'f') {
135 return 10 + (ch
- 'a');
136 } else if (ch
>= 'A' && ch
<= 'F') {
137 return 10 + (ch
- 'A');
144 * parse_string(): Parse a json string and return a QObject
153 * any-Unicode-character-
166 static QString
*qstring_from_escaped_str(JSONParserContext
*ctxt
, QObject
*token
)
168 const char *ptr
= token_get_value(token
);
170 int double_quote
= 1;
181 ((double_quote
&& *ptr
!= '"') || (!double_quote
&& *ptr
!= '\''))) {
187 qstring_append(str
, "\"");
191 qstring_append(str
, "'");
195 qstring_append(str
, "\\");
199 qstring_append(str
, "/");
203 qstring_append(str
, "\b");
207 qstring_append(str
, "\f");
211 qstring_append(str
, "\n");
215 qstring_append(str
, "\r");
219 qstring_append(str
, "\t");
223 uint16_t unicode_char
= 0;
229 for (i
= 0; i
< 4; i
++) {
230 if (qemu_isxdigit(*ptr
)) {
231 unicode_char
|= hex2decimal(*ptr
) << ((3 - i
) * 4);
233 parse_error(ctxt
, token
,
234 "invalid hex escape sequence in string");
240 wchar_to_utf8(unicode_char
, utf8_char
, sizeof(utf8_char
));
241 qstring_append(str
, utf8_char
);
244 parse_error(ctxt
, token
, "invalid escape sequence in string");
253 qstring_append(str
, dummy
);
264 static QObject
*parser_context_pop_token(JSONParserContext
*ctxt
)
267 g_assert(ctxt
->tokens
.pos
< ctxt
->tokens
.count
);
268 token
= ctxt
->tokens
.buf
[ctxt
->tokens
.pos
];
273 /* Note: parser_context_{peek|pop}_token do not increment the
274 * token object's refcount. In both cases the references will continue
275 * to be tracked and cleaned up in parser_context_free(), so do not
276 * attempt to free the token object.
278 static QObject
*parser_context_peek_token(JSONParserContext
*ctxt
)
281 g_assert(ctxt
->tokens
.pos
< ctxt
->tokens
.count
);
282 token
= ctxt
->tokens
.buf
[ctxt
->tokens
.pos
];
286 static JSONParserContext
parser_context_save(JSONParserContext
*ctxt
)
288 JSONParserContext saved_ctxt
= {0};
289 saved_ctxt
.tokens
.pos
= ctxt
->tokens
.pos
;
290 saved_ctxt
.tokens
.count
= ctxt
->tokens
.count
;
291 saved_ctxt
.tokens
.buf
= ctxt
->tokens
.buf
;
295 static void parser_context_restore(JSONParserContext
*ctxt
,
296 JSONParserContext saved_ctxt
)
298 ctxt
->tokens
.pos
= saved_ctxt
.tokens
.pos
;
299 ctxt
->tokens
.count
= saved_ctxt
.tokens
.count
;
300 ctxt
->tokens
.buf
= saved_ctxt
.tokens
.buf
;
303 static void tokens_append_from_iter(QObject
*obj
, void *opaque
)
305 JSONParserContext
*ctxt
= opaque
;
306 g_assert(ctxt
->tokens
.pos
< ctxt
->tokens
.count
);
307 ctxt
->tokens
.buf
[ctxt
->tokens
.pos
++] = obj
;
311 static JSONParserContext
*parser_context_new(QList
*tokens
)
313 JSONParserContext
*ctxt
;
320 count
= qlist_size(tokens
);
325 ctxt
= g_malloc0(sizeof(JSONParserContext
));
326 ctxt
->tokens
.pos
= 0;
327 ctxt
->tokens
.count
= count
;
328 ctxt
->tokens
.buf
= g_malloc(count
* sizeof(QObject
*));
329 qlist_iter(tokens
, tokens_append_from_iter
, ctxt
);
330 ctxt
->tokens
.pos
= 0;
335 /* to support error propagation, ctxt->err must be freed separately */
336 static void parser_context_free(JSONParserContext
*ctxt
)
340 for (i
= 0; i
< ctxt
->tokens
.count
; i
++) {
341 qobject_decref(ctxt
->tokens
.buf
[i
]);
343 g_free(ctxt
->tokens
.buf
);
351 static int parse_pair(JSONParserContext
*ctxt
, QDict
*dict
, va_list *ap
)
353 QObject
*key
= NULL
, *token
= NULL
, *value
, *peek
;
354 JSONParserContext saved_ctxt
= parser_context_save(ctxt
);
356 peek
= parser_context_peek_token(ctxt
);
358 parse_error(ctxt
, NULL
, "premature EOI");
362 key
= parse_value(ctxt
, ap
);
363 if (!key
|| qobject_type(key
) != QTYPE_QSTRING
) {
364 parse_error(ctxt
, peek
, "key is not a string in object");
368 token
= parser_context_pop_token(ctxt
);
370 parse_error(ctxt
, NULL
, "premature EOI");
374 if (token_get_type(token
) != JSON_COLON
) {
375 parse_error(ctxt
, token
, "missing : in object pair");
379 value
= parse_value(ctxt
, ap
);
381 parse_error(ctxt
, token
, "Missing value in dict");
385 qdict_put_obj(dict
, qstring_get_str(qobject_to_qstring(key
)), value
);
392 parser_context_restore(ctxt
, saved_ctxt
);
398 static QObject
*parse_object(JSONParserContext
*ctxt
, va_list *ap
)
401 QObject
*token
, *peek
;
402 JSONParserContext saved_ctxt
= parser_context_save(ctxt
);
404 token
= parser_context_pop_token(ctxt
);
409 if (token_get_type(token
) != JSON_LCURLY
) {
415 peek
= parser_context_peek_token(ctxt
);
417 parse_error(ctxt
, NULL
, "premature EOI");
421 if (token_get_type(peek
) != JSON_RCURLY
) {
422 if (parse_pair(ctxt
, dict
, ap
) == -1) {
426 token
= parser_context_pop_token(ctxt
);
428 parse_error(ctxt
, NULL
, "premature EOI");
432 while (token_get_type(token
) != JSON_RCURLY
) {
433 if (token_get_type(token
) != JSON_COMMA
) {
434 parse_error(ctxt
, token
, "expected separator in dict");
438 if (parse_pair(ctxt
, dict
, ap
) == -1) {
442 token
= parser_context_pop_token(ctxt
);
444 parse_error(ctxt
, NULL
, "premature EOI");
449 (void)parser_context_pop_token(ctxt
);
452 return QOBJECT(dict
);
455 parser_context_restore(ctxt
, saved_ctxt
);
460 static QObject
*parse_array(JSONParserContext
*ctxt
, va_list *ap
)
463 QObject
*token
, *peek
;
464 JSONParserContext saved_ctxt
= parser_context_save(ctxt
);
466 token
= parser_context_pop_token(ctxt
);
471 if (token_get_type(token
) != JSON_LSQUARE
) {
477 peek
= parser_context_peek_token(ctxt
);
479 parse_error(ctxt
, NULL
, "premature EOI");
483 if (token_get_type(peek
) != JSON_RSQUARE
) {
486 obj
= parse_value(ctxt
, ap
);
488 parse_error(ctxt
, token
, "expecting value");
492 qlist_append_obj(list
, obj
);
494 token
= parser_context_pop_token(ctxt
);
496 parse_error(ctxt
, NULL
, "premature EOI");
500 while (token_get_type(token
) != JSON_RSQUARE
) {
501 if (token_get_type(token
) != JSON_COMMA
) {
502 parse_error(ctxt
, token
, "expected separator in list");
506 obj
= parse_value(ctxt
, ap
);
508 parse_error(ctxt
, token
, "expecting value");
512 qlist_append_obj(list
, obj
);
514 token
= parser_context_pop_token(ctxt
);
516 parse_error(ctxt
, NULL
, "premature EOI");
521 (void)parser_context_pop_token(ctxt
);
524 return QOBJECT(list
);
527 parser_context_restore(ctxt
, saved_ctxt
);
532 static QObject
*parse_keyword(JSONParserContext
*ctxt
)
534 QObject
*token
, *ret
;
535 JSONParserContext saved_ctxt
= parser_context_save(ctxt
);
537 token
= parser_context_pop_token(ctxt
);
542 if (token_get_type(token
) != JSON_KEYWORD
) {
546 if (token_is_keyword(token
, "true")) {
547 ret
= QOBJECT(qbool_from_bool(true));
548 } else if (token_is_keyword(token
, "false")) {
549 ret
= QOBJECT(qbool_from_bool(false));
550 } else if (token_is_keyword(token
, "null")) {
553 parse_error(ctxt
, token
, "invalid keyword `%s'", token_get_value(token
));
560 parser_context_restore(ctxt
, saved_ctxt
);
565 static QObject
*parse_escape(JSONParserContext
*ctxt
, va_list *ap
)
567 QObject
*token
= NULL
, *obj
;
568 JSONParserContext saved_ctxt
= parser_context_save(ctxt
);
574 token
= parser_context_pop_token(ctxt
);
579 if (token_is_escape(token
, "%p")) {
580 obj
= va_arg(*ap
, QObject
*);
581 } else if (token_is_escape(token
, "%i")) {
582 obj
= QOBJECT(qbool_from_bool(va_arg(*ap
, int)));
583 } else if (token_is_escape(token
, "%d")) {
584 obj
= QOBJECT(qint_from_int(va_arg(*ap
, int)));
585 } else if (token_is_escape(token
, "%ld")) {
586 obj
= QOBJECT(qint_from_int(va_arg(*ap
, long)));
587 } else if (token_is_escape(token
, "%lld") ||
588 token_is_escape(token
, "%I64d")) {
589 obj
= QOBJECT(qint_from_int(va_arg(*ap
, long long)));
590 } else if (token_is_escape(token
, "%s")) {
591 obj
= QOBJECT(qstring_from_str(va_arg(*ap
, const char *)));
592 } else if (token_is_escape(token
, "%f")) {
593 obj
= QOBJECT(qfloat_from_double(va_arg(*ap
, double)));
601 parser_context_restore(ctxt
, saved_ctxt
);
606 static QObject
*parse_literal(JSONParserContext
*ctxt
)
608 QObject
*token
, *obj
;
609 JSONParserContext saved_ctxt
= parser_context_save(ctxt
);
611 token
= parser_context_pop_token(ctxt
);
616 switch (token_get_type(token
)) {
618 obj
= QOBJECT(qstring_from_escaped_str(ctxt
, token
));
621 /* A possibility exists that this is a whole-valued float where the
622 * fractional part was left out due to being 0 (.0). It's not a big
623 * deal to treat these as ints in the parser, so long as users of the
624 * resulting QObject know to expect a QInt in place of a QFloat in
627 * However, in some cases these values will overflow/underflow a
628 * QInt/int64 container, thus we should assume these are to be handled
629 * as QFloats/doubles rather than silently changing their values.
631 * strtoll() indicates these instances by setting errno to ERANGE
635 errno
= 0; /* strtoll doesn't set errno on success */
636 value
= strtoll(token_get_value(token
), NULL
, 10);
637 if (errno
!= ERANGE
) {
638 obj
= QOBJECT(qint_from_int(value
));
641 /* fall through to JSON_FLOAT */
644 /* FIXME dependent on locale */
645 obj
= QOBJECT(qfloat_from_double(strtod(token_get_value(token
), NULL
)));
654 parser_context_restore(ctxt
, saved_ctxt
);
659 static QObject
*parse_value(JSONParserContext
*ctxt
, va_list *ap
)
663 obj
= parse_object(ctxt
, ap
);
665 obj
= parse_array(ctxt
, ap
);
668 obj
= parse_escape(ctxt
, ap
);
671 obj
= parse_keyword(ctxt
);
674 obj
= parse_literal(ctxt
);
680 QObject
*json_parser_parse(QList
*tokens
, va_list *ap
)
682 return json_parser_parse_err(tokens
, ap
, NULL
);
685 QObject
*json_parser_parse_err(QList
*tokens
, va_list *ap
, Error
**errp
)
687 JSONParserContext
*ctxt
= parser_context_new(tokens
);
694 result
= parse_value(ctxt
, ap
);
696 error_propagate(errp
, ctxt
->err
);
698 parser_context_free(ctxt
);