CODING_STYLE: Reserve qemu_ prefix for library wrappers
[qemu.git] / json-parser.c
blob579928f2ee0b5fca8763a18cc98ee3c35e266395
1 /*
2 * JSON Parser
4 * Copyright IBM, Corp. 2009
6 * Authors:
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 <stdbool.h>
16 #include "qemu-common.h"
17 #include "qstring.h"
18 #include "qint.h"
19 #include "qdict.h"
20 #include "qlist.h"
21 #include "qfloat.h"
22 #include "qbool.h"
23 #include "json-parser.h"
24 #include "json-lexer.h"
26 typedef struct JSONParserContext
28 } JSONParserContext;
30 #define BUG_ON(cond) assert(!(cond))
32 /**
33 * TODO
35 * 0) make errors meaningful again
36 * 1) add geometry information to tokens
37 * 3) should we return a parsed size?
38 * 4) deal with premature EOI
41 static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap);
43 /**
44 * Token manipulators
46 * tokens are dictionaries that contain a type, a string value, and geometry information
47 * about a token identified by the lexer. These are routines that make working with
48 * these objects a bit easier.
50 static const char *token_get_value(QObject *obj)
52 return qdict_get_str(qobject_to_qdict(obj), "token");
55 static JSONTokenType token_get_type(QObject *obj)
57 return qdict_get_int(qobject_to_qdict(obj), "type");
60 static int token_is_operator(QObject *obj, char op)
62 const char *val;
64 if (token_get_type(obj) != JSON_OPERATOR) {
65 return 0;
68 val = token_get_value(obj);
70 return (val[0] == op) && (val[1] == 0);
73 static int token_is_keyword(QObject *obj, const char *value)
75 if (token_get_type(obj) != JSON_KEYWORD) {
76 return 0;
79 return strcmp(token_get_value(obj), value) == 0;
82 static int token_is_escape(QObject *obj, const char *value)
84 if (token_get_type(obj) != JSON_ESCAPE) {
85 return 0;
88 return (strcmp(token_get_value(obj), value) == 0);
91 /**
92 * Error handler
94 static void parse_error(JSONParserContext *ctxt, QObject *token, const char *msg, ...)
96 fprintf(stderr, "parse error: %s\n", msg);
99 /**
100 * String helpers
102 * These helpers are used to unescape strings.
104 static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length)
106 if (wchar <= 0x007F) {
107 BUG_ON(buffer_length < 2);
109 buffer[0] = wchar & 0x7F;
110 buffer[1] = 0;
111 } else if (wchar <= 0x07FF) {
112 BUG_ON(buffer_length < 3);
114 buffer[0] = 0xC0 | ((wchar >> 6) & 0x1F);
115 buffer[1] = 0x80 | (wchar & 0x3F);
116 buffer[2] = 0;
117 } else {
118 BUG_ON(buffer_length < 4);
120 buffer[0] = 0xE0 | ((wchar >> 12) & 0x0F);
121 buffer[1] = 0x80 | ((wchar >> 6) & 0x3F);
122 buffer[2] = 0x80 | (wchar & 0x3F);
123 buffer[3] = 0;
127 static int hex2decimal(char ch)
129 if (ch >= '0' && ch <= '9') {
130 return (ch - '0');
131 } else if (ch >= 'a' && ch <= 'f') {
132 return 10 + (ch - 'a');
133 } else if (ch >= 'A' && ch <= 'F') {
134 return 10 + (ch - 'A');
137 return -1;
141 * parse_string(): Parse a json string and return a QObject
143 * string
144 * ""
145 * " chars "
146 * chars
147 * char
148 * char chars
149 * char
150 * any-Unicode-character-
151 * except-"-or-\-or-
152 * control-character
153 * \"
154 * \\
155 * \/
156 * \b
157 * \f
158 * \n
159 * \r
160 * \t
161 * \u four-hex-digits
163 static QString *qstring_from_escaped_str(JSONParserContext *ctxt, QObject *token)
165 const char *ptr = token_get_value(token);
166 QString *str;
167 int double_quote = 1;
169 if (*ptr == '"') {
170 double_quote = 1;
171 } else {
172 double_quote = 0;
174 ptr++;
176 str = qstring_new();
177 while (*ptr &&
178 ((double_quote && *ptr != '"') || (!double_quote && *ptr != '\''))) {
179 if (*ptr == '\\') {
180 ptr++;
182 switch (*ptr) {
183 case '"':
184 qstring_append(str, "\"");
185 ptr++;
186 break;
187 case '\'':
188 qstring_append(str, "'");
189 ptr++;
190 break;
191 case '\\':
192 qstring_append(str, "\\");
193 ptr++;
194 break;
195 case '/':
196 qstring_append(str, "/");
197 ptr++;
198 break;
199 case 'b':
200 qstring_append(str, "\b");
201 ptr++;
202 break;
203 case 'n':
204 qstring_append(str, "\n");
205 ptr++;
206 break;
207 case 'r':
208 qstring_append(str, "\r");
209 ptr++;
210 break;
211 case 't':
212 qstring_append(str, "\t");
213 ptr++;
214 break;
215 case 'u': {
216 uint16_t unicode_char = 0;
217 char utf8_char[4];
218 int i = 0;
220 ptr++;
222 for (i = 0; i < 4; i++) {
223 if (qemu_isxdigit(*ptr)) {
224 unicode_char |= hex2decimal(*ptr) << ((3 - i) * 4);
225 } else {
226 parse_error(ctxt, token,
227 "invalid hex escape sequence in string");
228 goto out;
230 ptr++;
233 wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char));
234 qstring_append(str, utf8_char);
235 } break;
236 default:
237 parse_error(ctxt, token, "invalid escape sequence in string");
238 goto out;
240 } else {
241 char dummy[2];
243 dummy[0] = *ptr++;
244 dummy[1] = 0;
246 qstring_append(str, dummy);
250 return str;
252 out:
253 QDECREF(str);
254 return NULL;
258 * Parsing rules
260 static int parse_pair(JSONParserContext *ctxt, QDict *dict, QList **tokens, va_list *ap)
262 QObject *key, *token = NULL, *value, *peek;
263 QList *working = qlist_copy(*tokens);
265 peek = qlist_peek(working);
266 key = parse_value(ctxt, &working, ap);
267 if (!key || qobject_type(key) != QTYPE_QSTRING) {
268 parse_error(ctxt, peek, "key is not a string in object");
269 goto out;
272 token = qlist_pop(working);
273 if (!token_is_operator(token, ':')) {
274 parse_error(ctxt, token, "missing : in object pair");
275 goto out;
278 value = parse_value(ctxt, &working, ap);
279 if (value == NULL) {
280 parse_error(ctxt, token, "Missing value in dict");
281 goto out;
284 qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
286 qobject_decref(token);
287 qobject_decref(key);
288 QDECREF(*tokens);
289 *tokens = working;
291 return 0;
293 out:
294 qobject_decref(token);
295 qobject_decref(key);
296 QDECREF(working);
298 return -1;
301 static QObject *parse_object(JSONParserContext *ctxt, QList **tokens, va_list *ap)
303 QDict *dict = NULL;
304 QObject *token, *peek;
305 QList *working = qlist_copy(*tokens);
307 token = qlist_pop(working);
308 if (!token_is_operator(token, '{')) {
309 goto out;
311 qobject_decref(token);
312 token = NULL;
314 dict = qdict_new();
316 peek = qlist_peek(working);
317 if (!token_is_operator(peek, '}')) {
318 if (parse_pair(ctxt, dict, &working, ap) == -1) {
319 goto out;
322 token = qlist_pop(working);
323 while (!token_is_operator(token, '}')) {
324 if (!token_is_operator(token, ',')) {
325 parse_error(ctxt, token, "expected separator in dict");
326 goto out;
328 qobject_decref(token);
329 token = NULL;
331 if (parse_pair(ctxt, dict, &working, ap) == -1) {
332 goto out;
335 token = qlist_pop(working);
337 qobject_decref(token);
338 token = NULL;
339 } else {
340 token = qlist_pop(working);
341 qobject_decref(token);
342 token = NULL;
345 QDECREF(*tokens);
346 *tokens = working;
348 return QOBJECT(dict);
350 out:
351 qobject_decref(token);
352 QDECREF(working);
353 QDECREF(dict);
354 return NULL;
357 static QObject *parse_array(JSONParserContext *ctxt, QList **tokens, va_list *ap)
359 QList *list = NULL;
360 QObject *token, *peek;
361 QList *working = qlist_copy(*tokens);
363 token = qlist_pop(working);
364 if (!token_is_operator(token, '[')) {
365 goto out;
367 qobject_decref(token);
368 token = NULL;
370 list = qlist_new();
372 peek = qlist_peek(working);
373 if (!token_is_operator(peek, ']')) {
374 QObject *obj;
376 obj = parse_value(ctxt, &working, ap);
377 if (obj == NULL) {
378 parse_error(ctxt, token, "expecting value");
379 goto out;
382 qlist_append_obj(list, obj);
384 token = qlist_pop(working);
385 while (!token_is_operator(token, ']')) {
386 if (!token_is_operator(token, ',')) {
387 parse_error(ctxt, token, "expected separator in list");
388 goto out;
391 qobject_decref(token);
392 token = NULL;
394 obj = parse_value(ctxt, &working, ap);
395 if (obj == NULL) {
396 parse_error(ctxt, token, "expecting value");
397 goto out;
400 qlist_append_obj(list, obj);
402 token = qlist_pop(working);
405 qobject_decref(token);
406 token = NULL;
407 } else {
408 token = qlist_pop(working);
409 qobject_decref(token);
410 token = NULL;
413 QDECREF(*tokens);
414 *tokens = working;
416 return QOBJECT(list);
418 out:
419 qobject_decref(token);
420 QDECREF(working);
421 QDECREF(list);
422 return NULL;
425 static QObject *parse_keyword(JSONParserContext *ctxt, QList **tokens)
427 QObject *token, *ret;
428 QList *working = qlist_copy(*tokens);
430 token = qlist_pop(working);
432 if (token_get_type(token) != JSON_KEYWORD) {
433 goto out;
436 if (token_is_keyword(token, "true")) {
437 ret = QOBJECT(qbool_from_int(true));
438 } else if (token_is_keyword(token, "false")) {
439 ret = QOBJECT(qbool_from_int(false));
440 } else {
441 parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token));
442 goto out;
445 qobject_decref(token);
446 QDECREF(*tokens);
447 *tokens = working;
449 return ret;
451 out:
452 qobject_decref(token);
453 QDECREF(working);
455 return NULL;
458 static QObject *parse_escape(JSONParserContext *ctxt, QList **tokens, va_list *ap)
460 QObject *token = NULL, *obj;
461 QList *working = qlist_copy(*tokens);
463 if (ap == NULL) {
464 goto out;
467 token = qlist_pop(working);
469 if (token_is_escape(token, "%p")) {
470 obj = va_arg(*ap, QObject *);
471 } else if (token_is_escape(token, "%i")) {
472 obj = QOBJECT(qbool_from_int(va_arg(*ap, int)));
473 } else if (token_is_escape(token, "%d")) {
474 obj = QOBJECT(qint_from_int(va_arg(*ap, int)));
475 } else if (token_is_escape(token, "%ld")) {
476 obj = QOBJECT(qint_from_int(va_arg(*ap, long)));
477 } else if (token_is_escape(token, "%lld") ||
478 token_is_escape(token, "%I64d")) {
479 obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));
480 } else if (token_is_escape(token, "%s")) {
481 obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
482 } else if (token_is_escape(token, "%f")) {
483 obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));
484 } else {
485 goto out;
488 qobject_decref(token);
489 QDECREF(*tokens);
490 *tokens = working;
492 return obj;
494 out:
495 qobject_decref(token);
496 QDECREF(working);
498 return NULL;
501 static QObject *parse_literal(JSONParserContext *ctxt, QList **tokens)
503 QObject *token, *obj;
504 QList *working = qlist_copy(*tokens);
506 token = qlist_pop(working);
507 switch (token_get_type(token)) {
508 case JSON_STRING:
509 obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
510 break;
511 case JSON_INTEGER:
512 obj = QOBJECT(qint_from_int(strtoll(token_get_value(token), NULL, 10)));
513 break;
514 case JSON_FLOAT:
515 /* FIXME dependent on locale */
516 obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
517 break;
518 default:
519 goto out;
522 qobject_decref(token);
523 QDECREF(*tokens);
524 *tokens = working;
526 return obj;
528 out:
529 qobject_decref(token);
530 QDECREF(working);
532 return NULL;
535 static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap)
537 QObject *obj;
539 obj = parse_object(ctxt, tokens, ap);
540 if (obj == NULL) {
541 obj = parse_array(ctxt, tokens, ap);
543 if (obj == NULL) {
544 obj = parse_escape(ctxt, tokens, ap);
546 if (obj == NULL) {
547 obj = parse_keyword(ctxt, tokens);
549 if (obj == NULL) {
550 obj = parse_literal(ctxt, tokens);
553 return obj;
556 QObject *json_parser_parse(QList *tokens, va_list *ap)
558 JSONParserContext ctxt = {};
559 QList *working = qlist_copy(tokens);
560 QObject *result;
562 result = parse_value(&ctxt, &working, ap);
564 QDECREF(working);
566 return result;