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 "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"
  25 #include "qerror.h"
  26
  27 typedef struct JSONParserContext
  28 {
  29     Error *err;
  30 } JSONParserContext;
  31
  32 #define BUG_ON(cond) assert(!(cond))
  33
  34 /**
  35  * TODO
  36  *
  37  * 0) make errors meaningful again
  38  * 1) add geometry information to tokens
  39  * 3) should we return a parsed size?
  40  * 4) deal with premature EOI
  41  */
  42
  43 static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap);
  44
  45 /**
  46  * Token manipulators
  47  *
  48  * tokens are dictionaries that contain a type, a string value, and geometry information
  49  * about a token identified by the lexer.  These are routines that make working with
  50  * these objects a bit easier.
  51  */
  52 static const char *token_get_value(QObject *obj)
  53 {
  54     return qdict_get_str(qobject_to_qdict(obj), "token");
  55 }
  56
  57 static JSONTokenType token_get_type(QObject *obj)
  58 {
  59     return qdict_get_int(qobject_to_qdict(obj), "type");
  60 }
  61
  62 static int token_is_operator(QObject *obj, char op)
  63 {
  64     const char *val;
  65
  66     if (token_get_type(obj) != JSON_OPERATOR) {
  67         return 0;
  68     }
  69
  70     val = token_get_value(obj);
  71
  72     return (val[0] == op) && (val[1] == 0);
  73 }
  74
  75 static int token_is_keyword(QObject *obj, const char *value)
  76 {
  77     if (token_get_type(obj) != JSON_KEYWORD) {
  78         return 0;
  79     }
  80
  81     return strcmp(token_get_value(obj), value) == 0;
  82 }
  83
  84 static int token_is_escape(QObject *obj, const char *value)
  85 {
  86     if (token_get_type(obj) != JSON_ESCAPE) {
  87         return 0;
  88     }
  89
  90     return (strcmp(token_get_value(obj), value) == 0);
  91 }
  92
  93 /**
  94  * Error handler
  95  */
  96 static void GCC_FMT_ATTR(3, 4) parse_error(JSONParserContext *ctxt,
  97                                            QObject *token, const char *msg, ...)
  98 {
  99     va_list ap;
 100     char message[1024];
 101     va_start(ap, msg);
 102     vsnprintf(message, sizeof(message), msg, ap);
 103     va_end(ap);
 104     if (ctxt->err) {
 105         error_free(ctxt->err);
 106         ctxt->err = NULL;
 107     }
 108     error_set(&ctxt->err, QERR_JSON_PARSE_ERROR, message);
 109 }
 110
 111 /**
 112  * String helpers
 113  *
 114  * These helpers are used to unescape strings.
 115  */
 116 static void wchar_to_utf8(uint16_t wchar, char *buffer, size_t buffer_length)
 117 {
 118     if (wchar <= 0x007F) {
 119         BUG_ON(buffer_length < 2);
 120
 121         buffer[0] = wchar & 0x7F;
 122         buffer[1] = 0;
 123     } else if (wchar <= 0x07FF) {
 124         BUG_ON(buffer_length < 3);
 125
 126         buffer[0] = 0xC0 | ((wchar >> 6) & 0x1F);
 127         buffer[1] = 0x80 | (wchar & 0x3F);
 128         buffer[2] = 0;
 129     } else {
 130         BUG_ON(buffer_length < 4);
 131
 132         buffer[0] = 0xE0 | ((wchar >> 12) & 0x0F);
 133         buffer[1] = 0x80 | ((wchar >> 6) & 0x3F);
 134         buffer[2] = 0x80 | (wchar & 0x3F);
 135         buffer[3] = 0;
 136     }
 137 }
 138
 139 static int hex2decimal(char ch)
 140 {
 141     if (ch >= '0' && ch <= '9') {
 142         return (ch - '0');
 143     } else if (ch >= 'a' && ch <= 'f') {
 144         return 10 + (ch - 'a');
 145     } else if (ch >= 'A' && ch <= 'F') {
 146         return 10 + (ch - 'A');
 147     }
 148
 149     return -1;
 150 }
 151
 152 /**
 153  * parse_string(): Parse a json string and return a QObject
 154  *
 155  *  string
 156  *      ""
 157  *      " chars "
 158  *  chars
 159  *      char
 160  *      char chars
 161  *  char
 162  *      any-Unicode-character-
 163  *          except-"-or-\-or-
 164  *          control-character
 165  *      \"
 166  *      \\
 167  *      \/
 168  *      \b
 169  *      \f
 170  *      \n
 171  *      \r
 172  *      \t
 173  *      \u four-hex-digits
 174  */
 175 static QString *qstring_from_escaped_str(JSONParserContext *ctxt, QObject *token)
 176 {
 177     const char *ptr = token_get_value(token);
 178     QString *str;
 179     int double_quote = 1;
 180
 181     if (*ptr == '"') {
 182         double_quote = 1;
 183     } else {
 184         double_quote = 0;
 185     }
 186     ptr++;
 187
 188     str = qstring_new();
 189     while (*ptr &&
 190            ((double_quote && *ptr != '"') || (!double_quote && *ptr != '\''))) {
 191         if (*ptr == '\\') {
 192             ptr++;
 193
 194             switch (*ptr) {
 195             case '"':
 196                 qstring_append(str, "\"");
 197                 ptr++;
 198                 break;
 199             case '\'':
 200                 qstring_append(str, "'");
 201                 ptr++;
 202                 break;
 203             case '\\':
 204                 qstring_append(str, "\\");
 205                 ptr++;
 206                 break;
 207             case '/':
 208                 qstring_append(str, "/");
 209                 ptr++;
 210                 break;
 211             case 'b':
 212                 qstring_append(str, "\b");
 213                 ptr++;
 214                 break;
 215             case 'f':
 216                 qstring_append(str, "\f");
 217                 ptr++;
 218                 break;
 219             case 'n':
 220                 qstring_append(str, "\n");
 221                 ptr++;
 222                 break;
 223             case 'r':
 224                 qstring_append(str, "\r");
 225                 ptr++;
 226                 break;
 227             case 't':
 228                 qstring_append(str, "\t");
 229                 ptr++;
 230                 break;
 231             case 'u': {
 232                 uint16_t unicode_char = 0;
 233                 char utf8_char[4];
 234                 int i = 0;
 235
 236                 ptr++;
 237
 238                 for (i = 0; i < 4; i++) {
 239                     if (qemu_isxdigit(*ptr)) {
 240                         unicode_char |= hex2decimal(*ptr) << ((3 - i) * 4);
 241                     } else {
 242                         parse_error(ctxt, token,
 243                                     "invalid hex escape sequence in string");
 244                         goto out;
 245                     }
 246                     ptr++;
 247                 }
 248
 249                 wchar_to_utf8(unicode_char, utf8_char, sizeof(utf8_char));
 250                 qstring_append(str, utf8_char);
 251             }   break;
 252             default:
 253                 parse_error(ctxt, token, "invalid escape sequence in string");
 254                 goto out;
 255             }
 256         } else {
 257             char dummy[2];
 258
 259             dummy[0] = *ptr++;
 260             dummy[1] = 0;
 261
 262             qstring_append(str, dummy);
 263         }
 264     }
 265
 266     return str;
 267
 268 out:
 269     QDECREF(str);
 270     return NULL;
 271 }
 272
 273 /**
 274  * Parsing rules
 275  */
 276 static int parse_pair(JSONParserContext *ctxt, QDict *dict, QList **tokens, va_list *ap)
 277 {
 278     QObject *key, *token = NULL, *value, *peek;
 279     QList *working = qlist_copy(*tokens);
 280
 281     peek = qlist_peek(working);
 282     key = parse_value(ctxt, &working, ap);
 283     if (!key || qobject_type(key) != QTYPE_QSTRING) {
 284         parse_error(ctxt, peek, "key is not a string in object");
 285         goto out;
 286     }
 287
 288     token = qlist_pop(working);
 289     if (!token_is_operator(token, ':')) {
 290         parse_error(ctxt, token, "missing : in object pair");
 291         goto out;
 292     }
 293
 294     value = parse_value(ctxt, &working, ap);
 295     if (value == NULL) {
 296         parse_error(ctxt, token, "Missing value in dict");
 297         goto out;
 298     }
 299
 300     qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
 301
 302     qobject_decref(token);
 303     qobject_decref(key);
 304     QDECREF(*tokens);
 305     *tokens = working;
 306
 307     return 0;
 308
 309 out:
 310     qobject_decref(token);
 311     qobject_decref(key);
 312     QDECREF(working);
 313
 314     return -1;
 315 }
 316
 317 static QObject *parse_object(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 318 {
 319     QDict *dict = NULL;
 320     QObject *token, *peek;
 321     QList *working = qlist_copy(*tokens);
 322
 323     token = qlist_pop(working);
 324     if (!token_is_operator(token, '{')) {
 325         goto out;
 326     }
 327     qobject_decref(token);
 328     token = NULL;
 329
 330     dict = qdict_new();
 331
 332     peek = qlist_peek(working);
 333     if (!token_is_operator(peek, '}')) {
 334         if (parse_pair(ctxt, dict, &working, ap) == -1) {
 335             goto out;
 336         }
 337
 338         token = qlist_pop(working);
 339         while (!token_is_operator(token, '}')) {
 340             if (!token_is_operator(token, ',')) {
 341                 parse_error(ctxt, token, "expected separator in dict");
 342                 goto out;
 343             }
 344             qobject_decref(token);
 345             token = NULL;
 346
 347             if (parse_pair(ctxt, dict, &working, ap) == -1) {
 348                 goto out;
 349             }
 350
 351             token = qlist_pop(working);
 352         }
 353         qobject_decref(token);
 354         token = NULL;
 355     } else {
 356         token = qlist_pop(working);
 357         qobject_decref(token);
 358         token = NULL;
 359     }
 360
 361     QDECREF(*tokens);
 362     *tokens = working;
 363
 364     return QOBJECT(dict);
 365
 366 out:
 367     qobject_decref(token);
 368     QDECREF(working);
 369     QDECREF(dict);
 370     return NULL;
 371 }
 372
 373 static QObject *parse_array(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 374 {
 375     QList *list = NULL;
 376     QObject *token, *peek;
 377     QList *working = qlist_copy(*tokens);
 378
 379     token = qlist_pop(working);
 380     if (!token_is_operator(token, '[')) {
 381         goto out;
 382     }
 383     qobject_decref(token);
 384     token = NULL;
 385
 386     list = qlist_new();
 387
 388     peek = qlist_peek(working);
 389     if (!token_is_operator(peek, ']')) {
 390         QObject *obj;
 391
 392         obj = parse_value(ctxt, &working, ap);
 393         if (obj == NULL) {
 394             parse_error(ctxt, token, "expecting value");
 395             goto out;
 396         }
 397
 398         qlist_append_obj(list, obj);
 399
 400         token = qlist_pop(working);
 401         while (!token_is_operator(token, ']')) {
 402             if (!token_is_operator(token, ',')) {
 403                 parse_error(ctxt, token, "expected separator in list");
 404                 goto out;
 405             }
 406
 407             qobject_decref(token);
 408             token = NULL;
 409
 410             obj = parse_value(ctxt, &working, ap);
 411             if (obj == NULL) {
 412                 parse_error(ctxt, token, "expecting value");
 413                 goto out;
 414             }
 415
 416             qlist_append_obj(list, obj);
 417
 418             token = qlist_pop(working);
 419         }
 420
 421         qobject_decref(token);
 422         token = NULL;
 423     } else {
 424         token = qlist_pop(working);
 425         qobject_decref(token);
 426         token = NULL;
 427     }
 428
 429     QDECREF(*tokens);
 430     *tokens = working;
 431
 432     return QOBJECT(list);
 433
 434 out:
 435     qobject_decref(token);
 436     QDECREF(working);
 437     QDECREF(list);
 438     return NULL;
 439 }
 440
 441 static QObject *parse_keyword(JSONParserContext *ctxt, QList **tokens)
 442 {
 443     QObject *token, *ret;
 444     QList *working = qlist_copy(*tokens);
 445
 446     token = qlist_pop(working);
 447
 448     if (token_get_type(token) != JSON_KEYWORD) {
 449         goto out;
 450     }
 451
 452     if (token_is_keyword(token, "true")) {
 453         ret = QOBJECT(qbool_from_int(true));
 454     } else if (token_is_keyword(token, "false")) {
 455         ret = QOBJECT(qbool_from_int(false));
 456     } else {
 457         parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token));
 458         goto out;
 459     }
 460
 461     qobject_decref(token);
 462     QDECREF(*tokens);
 463     *tokens = working;
 464
 465     return ret;
 466
 467 out:
 468     qobject_decref(token);
 469     QDECREF(working);
 470
 471     return NULL;
 472 }
 473
 474 static QObject *parse_escape(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 475 {
 476     QObject *token = NULL, *obj;
 477     QList *working = qlist_copy(*tokens);
 478
 479     if (ap == NULL) {
 480         goto out;
 481     }
 482
 483     token = qlist_pop(working);
 484
 485     if (token_is_escape(token, "%p")) {
 486         obj = va_arg(*ap, QObject *);
 487     } else if (token_is_escape(token, "%i")) {
 488         obj = QOBJECT(qbool_from_int(va_arg(*ap, int)));
 489     } else if (token_is_escape(token, "%d")) {
 490         obj = QOBJECT(qint_from_int(va_arg(*ap, int)));
 491     } else if (token_is_escape(token, "%ld")) {
 492         obj = QOBJECT(qint_from_int(va_arg(*ap, long)));
 493     } else if (token_is_escape(token, "%lld") ||
 494                token_is_escape(token, "%I64d")) {
 495         obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));
 496     } else if (token_is_escape(token, "%s")) {
 497         obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
 498     } else if (token_is_escape(token, "%f")) {
 499         obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));
 500     } else {
 501         goto out;
 502     }
 503
 504     qobject_decref(token);
 505     QDECREF(*tokens);
 506     *tokens = working;
 507
 508     return obj;
 509
 510 out:
 511     qobject_decref(token);
 512     QDECREF(working);
 513
 514     return NULL;
 515 }
 516
 517 static QObject *parse_literal(JSONParserContext *ctxt, QList **tokens)
 518 {
 519     QObject *token, *obj;
 520     QList *working = qlist_copy(*tokens);
 521
 522     token = qlist_pop(working);
 523     switch (token_get_type(token)) {
 524     case JSON_STRING:
 525         obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
 526         break;
 527     case JSON_INTEGER:
 528         obj = QOBJECT(qint_from_int(strtoll(token_get_value(token), NULL, 10)));
 529         break;
 530     case JSON_FLOAT:
 531         /* FIXME dependent on locale */
 532         obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
 533         break;
 534     default:
 535         goto out;
 536     }
 537
 538     qobject_decref(token);
 539     QDECREF(*tokens);
 540     *tokens = working;
 541
 542     return obj;
 543
 544 out:
 545     qobject_decref(token);
 546     QDECREF(working);
 547
 548     return NULL;
 549 }
 550
 551 static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 552 {
 553     QObject *obj;
 554
 555     obj = parse_object(ctxt, tokens, ap);
 556     if (obj == NULL) {
 557         obj = parse_array(ctxt, tokens, ap);
 558     }
 559     if (obj == NULL) {
 560         obj = parse_escape(ctxt, tokens, ap);
 561     }
 562     if (obj == NULL) {
 563         obj = parse_keyword(ctxt, tokens);
 564     }
 565     if (obj == NULL) {
 566         obj = parse_literal(ctxt, tokens);
 567     }
 568
 569     return obj;
 570 }
 571
 572 QObject *json_parser_parse(QList *tokens, va_list *ap)
 573 {
 574     return json_parser_parse_err(tokens, ap, NULL);
 575 }
 576
 577 QObject *json_parser_parse_err(QList *tokens, va_list *ap, Error **errp)
 578 {
 579     JSONParserContext ctxt = {};
 580     QList *working = qlist_copy(tokens);
 581     QObject *result;
 582
 583     result = parse_value(&ctxt, &working, ap);
 584
 585     QDECREF(working);
 586
 587     error_propagate(errp, ctxt.err);
 588
 589     return result;
 590 }