]>
git.proxmox.com Git - mirror_qemu.git/blob - qobject/json-parser.c
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.
14 #include "qemu/osdep.h"
15 #include "qemu/cutils.h"
16 #include "qemu/unicode.h"
17 #include "qapi/error.h"
18 #include "qemu-common.h"
19 #include "qapi/qmp/qbool.h"
20 #include "qapi/qmp/qdict.h"
21 #include "qapi/qmp/qlist.h"
22 #include "qapi/qmp/qnull.h"
23 #include "qapi/qmp/qnum.h"
24 #include "qapi/qmp/qstring.h"
25 #include "qapi/qmp/json-parser.h"
26 #include "qapi/qmp/json-lexer.h"
27 #include "qapi/qmp/json-streamer.h"
29 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 static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext
*ctxt
,
53 JSONToken
*token
, const char *msg
, ...)
62 vsnprintf(message
, sizeof(message
), msg
, ap
);
64 error_setg(&ctxt
->err
, "JSON parse error, %s", message
);
70 * These helpers are used to unescape strings.
72 static void wchar_to_utf8(uint16_t wchar
, char *buffer
, size_t buffer_length
)
74 if (wchar
<= 0x007F) {
75 BUG_ON(buffer_length
< 2);
77 buffer
[0] = wchar
& 0x7F;
79 } else if (wchar
<= 0x07FF) {
80 BUG_ON(buffer_length
< 3);
82 buffer
[0] = 0xC0 | ((wchar
>> 6) & 0x1F);
83 buffer
[1] = 0x80 | (wchar
& 0x3F);
86 BUG_ON(buffer_length
< 4);
88 buffer
[0] = 0xE0 | ((wchar
>> 12) & 0x0F);
89 buffer
[1] = 0x80 | ((wchar
>> 6) & 0x3F);
90 buffer
[2] = 0x80 | (wchar
& 0x3F);
95 static int hex2decimal(char ch
)
97 if (ch
>= '0' && ch
<= '9') {
99 } else if (ch
>= 'a' && ch
<= 'f') {
100 return 10 + (ch
- 'a');
101 } else if (ch
>= 'A' && ch
<= 'F') {
102 return 10 + (ch
- 'A');
109 * parse_string(): Parse a json string and return a QObject
118 * any-Unicode-character-
131 static QString
*qstring_from_escaped_str(JSONParserContext
*ctxt
,
134 const char *ptr
= token
->str
;
142 assert(*ptr
== '"' || *ptr
== '\'');
146 while (*ptr
!= quote
) {
152 qstring_append(str
, "\"");
155 qstring_append(str
, "'");
158 qstring_append(str
, "\\");
161 qstring_append(str
, "/");
164 qstring_append(str
, "\b");
167 qstring_append(str
, "\f");
170 qstring_append(str
, "\n");
173 qstring_append(str
, "\r");
176 qstring_append(str
, "\t");
179 uint16_t unicode_char
= 0;
183 for (i
= 0; i
< 4; i
++) {
184 if (qemu_isxdigit(*ptr
)) {
185 unicode_char
|= hex2decimal(*ptr
) << ((3 - i
) * 4);
187 parse_error(ctxt
, token
,
188 "invalid hex escape sequence in string");
194 wchar_to_utf8(unicode_char
, utf8_char
, sizeof(utf8_char
));
195 qstring_append(str
, utf8_char
);
198 parse_error(ctxt
, token
, "invalid escape sequence in string");
202 cp
= mod_utf8_codepoint(ptr
, 6, &end
);
204 parse_error(ctxt
, token
, "invalid UTF-8 sequence in string");
208 len
= mod_utf8_encode(utf8_buf
, sizeof(utf8_buf
), cp
);
210 qstring_append(str
, utf8_buf
);
221 /* Note: the token object returned by parser_context_peek_token or
222 * parser_context_pop_token is deleted as soon as parser_context_pop_token
225 static JSONToken
*parser_context_pop_token(JSONParserContext
*ctxt
)
227 g_free(ctxt
->current
);
228 assert(!g_queue_is_empty(ctxt
->buf
));
229 ctxt
->current
= g_queue_pop_head(ctxt
->buf
);
230 return ctxt
->current
;
233 static JSONToken
*parser_context_peek_token(JSONParserContext
*ctxt
)
235 assert(!g_queue_is_empty(ctxt
->buf
));
236 return g_queue_peek_head(ctxt
->buf
);
239 static JSONParserContext
*parser_context_new(GQueue
*tokens
)
241 JSONParserContext
*ctxt
;
247 ctxt
= g_malloc0(sizeof(JSONParserContext
));
253 /* to support error propagation, ctxt->err must be freed separately */
254 static void parser_context_free(JSONParserContext
*ctxt
)
257 while (!g_queue_is_empty(ctxt
->buf
)) {
258 parser_context_pop_token(ctxt
);
260 g_free(ctxt
->current
);
261 g_queue_free(ctxt
->buf
);
269 static int parse_pair(JSONParserContext
*ctxt
, QDict
*dict
, va_list *ap
)
273 JSONToken
*peek
, *token
;
275 peek
= parser_context_peek_token(ctxt
);
277 parse_error(ctxt
, NULL
, "premature EOI");
281 key
= qobject_to(QString
, parse_value(ctxt
, ap
));
283 parse_error(ctxt
, peek
, "key is not a string in object");
287 token
= parser_context_pop_token(ctxt
);
289 parse_error(ctxt
, NULL
, "premature EOI");
293 if (token
->type
!= JSON_COLON
) {
294 parse_error(ctxt
, token
, "missing : in object pair");
298 value
= parse_value(ctxt
, ap
);
300 parse_error(ctxt
, token
, "Missing value in dict");
304 qdict_put_obj(dict
, qstring_get_str(key
), value
);
316 static QObject
*parse_object(JSONParserContext
*ctxt
, va_list *ap
)
319 JSONToken
*token
, *peek
;
321 token
= parser_context_pop_token(ctxt
);
322 assert(token
&& token
->type
== JSON_LCURLY
);
326 peek
= parser_context_peek_token(ctxt
);
328 parse_error(ctxt
, NULL
, "premature EOI");
332 if (peek
->type
!= JSON_RCURLY
) {
333 if (parse_pair(ctxt
, dict
, ap
) == -1) {
337 token
= parser_context_pop_token(ctxt
);
339 parse_error(ctxt
, NULL
, "premature EOI");
343 while (token
->type
!= JSON_RCURLY
) {
344 if (token
->type
!= JSON_COMMA
) {
345 parse_error(ctxt
, token
, "expected separator in dict");
349 if (parse_pair(ctxt
, dict
, ap
) == -1) {
353 token
= parser_context_pop_token(ctxt
);
355 parse_error(ctxt
, NULL
, "premature EOI");
360 (void)parser_context_pop_token(ctxt
);
363 return QOBJECT(dict
);
370 static QObject
*parse_array(JSONParserContext
*ctxt
, va_list *ap
)
373 JSONToken
*token
, *peek
;
375 token
= parser_context_pop_token(ctxt
);
376 assert(token
&& token
->type
== JSON_LSQUARE
);
380 peek
= parser_context_peek_token(ctxt
);
382 parse_error(ctxt
, NULL
, "premature EOI");
386 if (peek
->type
!= JSON_RSQUARE
) {
389 obj
= parse_value(ctxt
, ap
);
391 parse_error(ctxt
, token
, "expecting value");
395 qlist_append_obj(list
, obj
);
397 token
= parser_context_pop_token(ctxt
);
399 parse_error(ctxt
, NULL
, "premature EOI");
403 while (token
->type
!= JSON_RSQUARE
) {
404 if (token
->type
!= JSON_COMMA
) {
405 parse_error(ctxt
, token
, "expected separator in list");
409 obj
= parse_value(ctxt
, ap
);
411 parse_error(ctxt
, token
, "expecting value");
415 qlist_append_obj(list
, obj
);
417 token
= parser_context_pop_token(ctxt
);
419 parse_error(ctxt
, NULL
, "premature EOI");
424 (void)parser_context_pop_token(ctxt
);
427 return QOBJECT(list
);
434 static QObject
*parse_keyword(JSONParserContext
*ctxt
)
438 token
= parser_context_pop_token(ctxt
);
439 assert(token
&& token
->type
== JSON_KEYWORD
);
441 if (!strcmp(token
->str
, "true")) {
442 return QOBJECT(qbool_from_bool(true));
443 } else if (!strcmp(token
->str
, "false")) {
444 return QOBJECT(qbool_from_bool(false));
445 } else if (!strcmp(token
->str
, "null")) {
446 return QOBJECT(qnull());
448 parse_error(ctxt
, token
, "invalid keyword '%s'", token
->str
);
452 static QObject
*parse_escape(JSONParserContext
*ctxt
, va_list *ap
)
460 token
= parser_context_pop_token(ctxt
);
461 assert(token
&& token
->type
== JSON_ESCAPE
);
463 if (!strcmp(token
->str
, "%p")) {
464 return va_arg(*ap
, QObject
*);
465 } else if (!strcmp(token
->str
, "%i")) {
466 return QOBJECT(qbool_from_bool(va_arg(*ap
, int)));
467 } else if (!strcmp(token
->str
, "%d")) {
468 return QOBJECT(qnum_from_int(va_arg(*ap
, int)));
469 } else if (!strcmp(token
->str
, "%ld")) {
470 return QOBJECT(qnum_from_int(va_arg(*ap
, long)));
471 } else if (!strcmp(token
->str
, "%lld") ||
472 !strcmp(token
->str
, "%I64d")) {
473 return QOBJECT(qnum_from_int(va_arg(*ap
, long long)));
474 } else if (!strcmp(token
->str
, "%u")) {
475 return QOBJECT(qnum_from_uint(va_arg(*ap
, unsigned int)));
476 } else if (!strcmp(token
->str
, "%lu")) {
477 return QOBJECT(qnum_from_uint(va_arg(*ap
, unsigned long)));
478 } else if (!strcmp(token
->str
, "%llu") ||
479 !strcmp(token
->str
, "%I64u")) {
480 return QOBJECT(qnum_from_uint(va_arg(*ap
, unsigned long long)));
481 } else if (!strcmp(token
->str
, "%s")) {
482 return QOBJECT(qstring_from_str(va_arg(*ap
, const char *)));
483 } else if (!strcmp(token
->str
, "%f")) {
484 return QOBJECT(qnum_from_double(va_arg(*ap
, double)));
489 static QObject
*parse_literal(JSONParserContext
*ctxt
)
493 token
= parser_context_pop_token(ctxt
);
496 switch (token
->type
) {
498 return QOBJECT(qstring_from_escaped_str(ctxt
, token
));
501 * Represent JSON_INTEGER as QNUM_I64 if possible, else as
502 * QNUM_U64, else as QNUM_DOUBLE. Note that qemu_strtoi64()
503 * and qemu_strtou64() fail with ERANGE when it's not
506 * qnum_get_int() will then work for any signed 64-bit
507 * JSON_INTEGER, qnum_get_uint() for any unsigned 64-bit
508 * integer, and qnum_get_double() both for any JSON_INTEGER
509 * and any JSON_FLOAT (with precision loss for integers beyond
516 ret
= qemu_strtoi64(token
->str
, NULL
, 10, &value
);
518 return QOBJECT(qnum_from_int(value
));
520 assert(ret
== -ERANGE
);
522 if (token
->str
[0] != '-') {
523 ret
= qemu_strtou64(token
->str
, NULL
, 10, &uvalue
);
525 return QOBJECT(qnum_from_uint(uvalue
));
527 assert(ret
== -ERANGE
);
529 /* fall through to JSON_FLOAT */
532 /* FIXME dependent on locale; a pervasive issue in QEMU */
533 /* FIXME our lexer matches RFC 7159 in forbidding Inf or NaN,
534 * but those might be useful extensions beyond JSON */
535 return QOBJECT(qnum_from_double(strtod(token
->str
, NULL
)));
541 static QObject
*parse_value(JSONParserContext
*ctxt
, va_list *ap
)
545 token
= parser_context_peek_token(ctxt
);
547 parse_error(ctxt
, NULL
, "premature EOI");
551 switch (token
->type
) {
553 return parse_object(ctxt
, ap
);
555 return parse_array(ctxt
, ap
);
557 return parse_escape(ctxt
, ap
);
561 return parse_literal(ctxt
);
563 return parse_keyword(ctxt
);
565 parse_error(ctxt
, token
, "expecting value");
570 QObject
*json_parser_parse(GQueue
*tokens
, va_list *ap
)
572 return json_parser_parse_err(tokens
, ap
, NULL
);
575 QObject
*json_parser_parse_err(GQueue
*tokens
, va_list *ap
, Error
**errp
)
577 JSONParserContext
*ctxt
= parser_context_new(tokens
);
584 result
= parse_value(ctxt
, ap
);
586 error_propagate(errp
, ctxt
->err
);
588 parser_context_free(ctxt
);