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 = NULL, *token = NULL, *value, *peek;
 279     QList *working = qlist_copy(*tokens);
 280
 281     peek = qlist_peek(working);
 282     if (peek == NULL) {
 283         parse_error(ctxt, NULL, "premature EOI");
 284         goto out;
 285     }
 286
 287     key = parse_value(ctxt, &working, ap);
 288     if (!key || qobject_type(key) != QTYPE_QSTRING) {
 289         parse_error(ctxt, peek, "key is not a string in object");
 290         goto out;
 291     }
 292
 293     token = qlist_pop(working);
 294     if (token == NULL) {
 295         parse_error(ctxt, NULL, "premature EOI");
 296         goto out;
 297     }
 298
 299     if (!token_is_operator(token, ':')) {
 300         parse_error(ctxt, token, "missing : in object pair");
 301         goto out;
 302     }
 303
 304     value = parse_value(ctxt, &working, ap);
 305     if (value == NULL) {
 306         parse_error(ctxt, token, "Missing value in dict");
 307         goto out;
 308     }
 309
 310     qdict_put_obj(dict, qstring_get_str(qobject_to_qstring(key)), value);
 311
 312     qobject_decref(token);
 313     qobject_decref(key);
 314     QDECREF(*tokens);
 315     *tokens = working;
 316
 317     return 0;
 318
 319 out:
 320     qobject_decref(token);
 321     qobject_decref(key);
 322     QDECREF(working);
 323
 324     return -1;
 325 }
 326
 327 static QObject *parse_object(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 328 {
 329     QDict *dict = NULL;
 330     QObject *token, *peek;
 331     QList *working = qlist_copy(*tokens);
 332
 333     token = qlist_pop(working);
 334     if (token == NULL) {
 335         goto out;
 336     }
 337
 338     if (!token_is_operator(token, '{')) {
 339         goto out;
 340     }
 341     qobject_decref(token);
 342     token = NULL;
 343
 344     dict = qdict_new();
 345
 346     peek = qlist_peek(working);
 347     if (peek == NULL) {
 348         parse_error(ctxt, NULL, "premature EOI");
 349         goto out;
 350     }
 351
 352     if (!token_is_operator(peek, '}')) {
 353         if (parse_pair(ctxt, dict, &working, ap) == -1) {
 354             goto out;
 355         }
 356
 357         token = qlist_pop(working);
 358         if (token == NULL) {
 359             parse_error(ctxt, NULL, "premature EOI");
 360             goto out;
 361         }
 362
 363         while (!token_is_operator(token, '}')) {
 364             if (!token_is_operator(token, ',')) {
 365                 parse_error(ctxt, token, "expected separator in dict");
 366                 goto out;
 367             }
 368             qobject_decref(token);
 369             token = NULL;
 370
 371             if (parse_pair(ctxt, dict, &working, ap) == -1) {
 372                 goto out;
 373             }
 374
 375             token = qlist_pop(working);
 376             if (token == NULL) {
 377                 parse_error(ctxt, NULL, "premature EOI");
 378                 goto out;
 379             }
 380         }
 381         qobject_decref(token);
 382         token = NULL;
 383     } else {
 384         token = qlist_pop(working);
 385         qobject_decref(token);
 386         token = NULL;
 387     }
 388
 389     QDECREF(*tokens);
 390     *tokens = working;
 391
 392     return QOBJECT(dict);
 393
 394 out:
 395     qobject_decref(token);
 396     QDECREF(working);
 397     QDECREF(dict);
 398     return NULL;
 399 }
 400
 401 static QObject *parse_array(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 402 {
 403     QList *list = NULL;
 404     QObject *token, *peek;
 405     QList *working = qlist_copy(*tokens);
 406
 407     token = qlist_pop(working);
 408     if (token == NULL) {
 409         goto out;
 410     }
 411
 412     if (!token_is_operator(token, '[')) {
 413         goto out;
 414     }
 415     qobject_decref(token);
 416     token = NULL;
 417
 418     list = qlist_new();
 419
 420     peek = qlist_peek(working);
 421     if (peek == NULL) {
 422         parse_error(ctxt, NULL, "premature EOI");
 423         goto out;
 424     }
 425
 426     if (!token_is_operator(peek, ']')) {
 427         QObject *obj;
 428
 429         obj = parse_value(ctxt, &working, ap);
 430         if (obj == NULL) {
 431             parse_error(ctxt, token, "expecting value");
 432             goto out;
 433         }
 434
 435         qlist_append_obj(list, obj);
 436
 437         token = qlist_pop(working);
 438         if (token == NULL) {
 439             parse_error(ctxt, NULL, "premature EOI");
 440             goto out;
 441         }
 442
 443         while (!token_is_operator(token, ']')) {
 444             if (!token_is_operator(token, ',')) {
 445                 parse_error(ctxt, token, "expected separator in list");
 446                 goto out;
 447             }
 448
 449             qobject_decref(token);
 450             token = NULL;
 451
 452             obj = parse_value(ctxt, &working, ap);
 453             if (obj == NULL) {
 454                 parse_error(ctxt, token, "expecting value");
 455                 goto out;
 456             }
 457
 458             qlist_append_obj(list, obj);
 459
 460             token = qlist_pop(working);
 461             if (token == NULL) {
 462                 parse_error(ctxt, NULL, "premature EOI");
 463                 goto out;
 464             }
 465         }
 466
 467         qobject_decref(token);
 468         token = NULL;
 469     } else {
 470         token = qlist_pop(working);
 471         qobject_decref(token);
 472         token = NULL;
 473     }
 474
 475     QDECREF(*tokens);
 476     *tokens = working;
 477
 478     return QOBJECT(list);
 479
 480 out:
 481     qobject_decref(token);
 482     QDECREF(working);
 483     QDECREF(list);
 484     return NULL;
 485 }
 486
 487 static QObject *parse_keyword(JSONParserContext *ctxt, QList **tokens)
 488 {
 489     QObject *token, *ret;
 490     QList *working = qlist_copy(*tokens);
 491
 492     token = qlist_pop(working);
 493     if (token == NULL) {
 494         goto out;
 495     }
 496
 497     if (token_get_type(token) != JSON_KEYWORD) {
 498         goto out;
 499     }
 500
 501     if (token_is_keyword(token, "true")) {
 502         ret = QOBJECT(qbool_from_int(true));
 503     } else if (token_is_keyword(token, "false")) {
 504         ret = QOBJECT(qbool_from_int(false));
 505     } else {
 506         parse_error(ctxt, token, "invalid keyword `%s'", token_get_value(token));
 507         goto out;
 508     }
 509
 510     qobject_decref(token);
 511     QDECREF(*tokens);
 512     *tokens = working;
 513
 514     return ret;
 515
 516 out:
 517     qobject_decref(token);
 518     QDECREF(working);
 519
 520     return NULL;
 521 }
 522
 523 static QObject *parse_escape(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 524 {
 525     QObject *token = NULL, *obj;
 526     QList *working = qlist_copy(*tokens);
 527
 528     if (ap == NULL) {
 529         goto out;
 530     }
 531
 532     token = qlist_pop(working);
 533     if (token == NULL) {
 534         goto out;
 535     }
 536
 537     if (token_is_escape(token, "%p")) {
 538         obj = va_arg(*ap, QObject *);
 539     } else if (token_is_escape(token, "%i")) {
 540         obj = QOBJECT(qbool_from_int(va_arg(*ap, int)));
 541     } else if (token_is_escape(token, "%d")) {
 542         obj = QOBJECT(qint_from_int(va_arg(*ap, int)));
 543     } else if (token_is_escape(token, "%ld")) {
 544         obj = QOBJECT(qint_from_int(va_arg(*ap, long)));
 545     } else if (token_is_escape(token, "%lld") ||
 546                token_is_escape(token, "%I64d")) {
 547         obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));
 548     } else if (token_is_escape(token, "%s")) {
 549         obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
 550     } else if (token_is_escape(token, "%f")) {
 551         obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));
 552     } else {
 553         goto out;
 554     }
 555
 556     qobject_decref(token);
 557     QDECREF(*tokens);
 558     *tokens = working;
 559
 560     return obj;
 561
 562 out:
 563     qobject_decref(token);
 564     QDECREF(working);
 565
 566     return NULL;
 567 }
 568
 569 static QObject *parse_literal(JSONParserContext *ctxt, QList **tokens)
 570 {
 571     QObject *token, *obj;
 572     QList *working = qlist_copy(*tokens);
 573
 574     token = qlist_pop(working);
 575     if (token == NULL) {
 576         goto out;
 577     }
 578
 579     switch (token_get_type(token)) {
 580     case JSON_STRING:
 581         obj = QOBJECT(qstring_from_escaped_str(ctxt, token));
 582         break;
 583     case JSON_INTEGER:
 584         obj = QOBJECT(qint_from_int(strtoll(token_get_value(token), NULL, 10)));
 585         break;
 586     case JSON_FLOAT:
 587         /* FIXME dependent on locale */
 588         obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL)));
 589         break;
 590     default:
 591         goto out;
 592     }
 593
 594     qobject_decref(token);
 595     QDECREF(*tokens);
 596     *tokens = working;
 597
 598     return obj;
 599
 600 out:
 601     qobject_decref(token);
 602     QDECREF(working);
 603
 604     return NULL;
 605 }
 606
 607 static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap)
 608 {
 609     QObject *obj;
 610
 611     obj = parse_object(ctxt, tokens, ap);
 612     if (obj == NULL) {
 613         obj = parse_array(ctxt, tokens, ap);
 614     }
 615     if (obj == NULL) {
 616         obj = parse_escape(ctxt, tokens, ap);
 617     }
 618     if (obj == NULL) {
 619         obj = parse_keyword(ctxt, tokens);
 620     }
 621     if (obj == NULL) {
 622         obj = parse_literal(ctxt, tokens);
 623     }
 624
 625     return obj;
 626 }
 627
 628 QObject *json_parser_parse(QList *tokens, va_list *ap)
 629 {
 630     return json_parser_parse_err(tokens, ap, NULL);
 631 }
 632
 633 QObject *json_parser_parse_err(QList *tokens, va_list *ap, Error **errp)
 634 {
 635     JSONParserContext ctxt = {};
 636     QList *working;
 637     QObject *result;
 638
 639     if (!tokens) {
 640         return NULL;
 641     }
 642     working = qlist_copy(tokens);
 643     result = parse_value(&ctxt, &working, ap);
 644
 645     QDECREF(working);
 646
 647     error_propagate(errp, ctxt.err);
 648
 649     return result;
 650 }