RedfishPkg/Library/JsonLib/load.c

   1 /*
   2  * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
   3  *
   4  * Jansson is free software; you can redistribute it and/or modify
   5  * it under the terms of the MIT license. See LICENSE for details.
   6
   7  (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
   8
   9     SPDX-License-Identifier: BSD-2-Clause-Patent AND MIT
  10  */
  11
  12 #ifndef _GNU_SOURCE
  13 #define _GNU_SOURCE
  14 #endif
  15
  16 #include "jansson_private.h"
  17
  18 #include <assert.h>
  19 #include <errno.h>
  20 #include <limits.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #ifdef HAVE_UNISTD_H
  25   #include <unistd.h>
  26 #endif
  27
  28 #include "jansson.h"
  29 #include "strbuffer.h"
  30 #include "utf.h"
  31
  32 #define STREAM_STATE_OK     0
  33 #define STREAM_STATE_EOF    -1
  34 #define STREAM_STATE_ERROR  -2
  35
  36 #define TOKEN_INVALID  -1
  37 #define TOKEN_EOF      0
  38 #define TOKEN_STRING   256
  39 #define TOKEN_INTEGER  257
  40 #define TOKEN_REAL     258
  41 #define TOKEN_TRUE     259
  42 #define TOKEN_FALSE    260
  43 #define TOKEN_NULL     261
  44
  45 /* Locale independent versions of isxxx() functions */
  46 #define l_isupper(c)  ('A' <= (c) && (c) <= 'Z')
  47 #define l_islower(c)  ('a' <= (c) && (c) <= 'z')
  48 #define l_isalpha(c)  (l_isupper(c) || l_islower(c))
  49 #define l_isdigit(c)  ('0' <= (c) && (c) <= '9')
  50 #define l_isxdigit(c)                                                                    \
  51     (l_isdigit(c) || ('A' <= (c) && (c) <= 'F') || ('a' <= (c) && (c) <= 'f'))
  52
  53 /* Read one byte from stream, convert to unsigned char, then int, and
  54    return. return EOF on end of file. This corresponds to the
  55    behaviour of fgetc(). */
  56 typedef int (*get_func)(
  57   void  *data
  58   );
  59
  60 typedef struct {
  61   get_func    get;
  62   void        *data;
  63   char        buffer[5];
  64   size_t      buffer_pos;
  65   int         state;
  66   int         line;
  67   int         column, last_column;
  68   size_t      position;
  69 } stream_t;
  70
  71 typedef struct {
  72   stream_t       stream;
  73   strbuffer_t    saved_text;
  74   size_t         flags;
  75   size_t         depth;
  76   int            token;
  77   union {
  78     struct {
  79       char      *val;
  80       size_t    len;
  81     } string;
  82     json_int_t    integer;
  83     double        real;
  84   } value;
  85 } lex_t;
  86
  87 #define stream_to_lex(stream)  container_of(stream, lex_t, stream)
  88
  89 /*** error reporting ***/
  90
  91 static void
  92 error_set (
  93   json_error_t          *error,
  94   const lex_t           *lex,
  95   enum json_error_code  code,
  96   const char            *msg,
  97   ...
  98   )
  99 {
 100   va_list  ap;
 101   char     msg_text[JSON_ERROR_TEXT_LENGTH];
 102   char     msg_with_context[JSON_ERROR_TEXT_LENGTH];
 103
 104   int         line = -1, col = -1;
 105   size_t      pos     = 0;
 106   const char  *result = msg_text;
 107
 108   if (!error) {
 109     return;
 110   }
 111
 112   va_start (ap, msg);
 113   vsnprintf (msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap);
 114   msg_text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
 115   va_end (ap);
 116
 117   if (lex) {
 118     const char  *saved_text = strbuffer_value (&lex->saved_text);
 119
 120     line = lex->stream.line;
 121     col  = lex->stream.column;
 122     pos  = lex->stream.position;
 123
 124     if (saved_text && saved_text[0]) {
 125       if (lex->saved_text.length <= 20) {
 126         snprintf (
 127           msg_with_context,
 128           JSON_ERROR_TEXT_LENGTH,
 129           "%s near '%s'",
 130           msg_text,
 131           saved_text
 132           );
 133         msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
 134         result                                       = msg_with_context;
 135       }
 136     } else {
 137       if (code == json_error_invalid_syntax) {
 138         /* More specific error code for premature end of file. */
 139         code = json_error_premature_end_of_input;
 140       }
 141
 142       if (lex->stream.state == STREAM_STATE_ERROR) {
 143         /* No context for UTF-8 decoding errors */
 144         result = msg_text;
 145       } else {
 146         snprintf (
 147           msg_with_context,
 148           JSON_ERROR_TEXT_LENGTH,
 149           "%s near end of file",
 150           msg_text
 151           );
 152         msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
 153         result                                       = msg_with_context;
 154       }
 155     }
 156   }
 157
 158   jsonp_error_set (error, line, col, pos, code, "%s", result);
 159 }
 160
 161 /*** lexical analyzer ***/
 162
 163 static void
 164 stream_init (
 165   stream_t  *stream,
 166   get_func  get,
 167   void      *data
 168   )
 169 {
 170   stream->get        = get;
 171   stream->data       = data;
 172   stream->buffer[0]  = '\0';
 173   stream->buffer_pos = 0;
 174
 175   stream->state    = STREAM_STATE_OK;
 176   stream->line     = 1;
 177   stream->column   = 0;
 178   stream->position = 0;
 179 }
 180
 181 static int
 182 stream_get (
 183   stream_t      *stream,
 184   json_error_t  *error
 185   )
 186 {
 187   int  c;
 188
 189   if (stream->state != STREAM_STATE_OK) {
 190     return stream->state;
 191   }
 192
 193   if (!stream->buffer[stream->buffer_pos]) {
 194     c = stream->get (stream->data);
 195     if (c == EOF) {
 196       stream->state = STREAM_STATE_EOF;
 197       return STREAM_STATE_EOF;
 198     }
 199
 200     stream->buffer[0]  = c;
 201     stream->buffer_pos = 0;
 202
 203     if ((0x80 <= c) && (c <= 0xFF)) {
 204       /* multi-byte UTF-8 sequence */
 205       size_t  i, count;
 206
 207       count = utf8_check_first (c);
 208       if (!count) {
 209         goto out;
 210       }
 211
 212       assert (count >= 2);
 213
 214       for (i = 1; i < count; i++) {
 215         stream->buffer[i] = stream->get (stream->data);
 216       }
 217
 218       if (!utf8_check_full (stream->buffer, count, NULL)) {
 219         goto out;
 220       }
 221
 222       stream->buffer[count] = '\0';
 223     } else {
 224       stream->buffer[1] = '\0';
 225     }
 226   }
 227
 228   c = stream->buffer[stream->buffer_pos++];
 229
 230   stream->position++;
 231   if (c == '\n') {
 232     stream->line++;
 233     stream->last_column = stream->column;
 234     stream->column      = 0;
 235   } else if (utf8_check_first (c)) {
 236     /* track the Unicode character column, so increment only if
 237        this is the first character of a UTF-8 sequence */
 238     stream->column++;
 239   }
 240
 241   return c;
 242
 243 out:
 244   stream->state = STREAM_STATE_ERROR;
 245   error_set (
 246     error,
 247     stream_to_lex (stream),
 248     json_error_invalid_utf8,
 249     "unable to decode byte 0x%x",
 250     c
 251     );
 252   return STREAM_STATE_ERROR;
 253 }
 254
 255 static void
 256 stream_unget (
 257   stream_t  *stream,
 258   int       c
 259   )
 260 {
 261   if ((c == STREAM_STATE_EOF) || (c == STREAM_STATE_ERROR)) {
 262     return;
 263   }
 264
 265   stream->position--;
 266   if (c == '\n') {
 267     stream->line--;
 268     stream->column = stream->last_column;
 269   } else if (utf8_check_first (c)) {
 270     stream->column--;
 271   }
 272
 273   assert (stream->buffer_pos > 0);
 274   stream->buffer_pos--;
 275   assert (stream->buffer[stream->buffer_pos] == c);
 276 }
 277
 278 static int
 279 lex_get (
 280   lex_t         *lex,
 281   json_error_t  *error
 282   )
 283 {
 284   return stream_get (&lex->stream, error);
 285 }
 286
 287 static void
 288 lex_save (
 289   lex_t  *lex,
 290   int    c
 291   )
 292 {
 293   strbuffer_append_byte (&lex->saved_text, c);
 294 }
 295
 296 static int
 297 lex_get_save (
 298   lex_t         *lex,
 299   json_error_t  *error
 300   )
 301 {
 302   int  c = stream_get (&lex->stream, error);
 303
 304   if ((c != STREAM_STATE_EOF) && (c != STREAM_STATE_ERROR)) {
 305     lex_save (lex, c);
 306   }
 307
 308   return c;
 309 }
 310
 311 static void
 312 lex_unget (
 313   lex_t  *lex,
 314   int    c
 315   )
 316 {
 317   stream_unget (&lex->stream, c);
 318 }
 319
 320 static void
 321 lex_unget_unsave (
 322   lex_t  *lex,
 323   int    c
 324   )
 325 {
 326   if ((c != STREAM_STATE_EOF) && (c != STREAM_STATE_ERROR)) {
 327     /* Since we treat warnings as errors, when assertions are turned
 328      * off the "d" variable would be set but never used. Which is
 329      * treated as an error by GCC.
 330      */
 331  #ifndef NDEBUG
 332     char  d;
 333  #endif
 334     stream_unget (&lex->stream, c);
 335  #ifndef NDEBUG
 336     d =
 337  #endif
 338     strbuffer_pop (&lex->saved_text);
 339     assert (c == d);
 340   }
 341 }
 342
 343 static void
 344 lex_save_cached (
 345   lex_t  *lex
 346   )
 347 {
 348   while (lex->stream.buffer[lex->stream.buffer_pos] != '\0') {
 349     lex_save (lex, lex->stream.buffer[lex->stream.buffer_pos]);
 350     lex->stream.buffer_pos++;
 351     lex->stream.position++;
 352   }
 353 }
 354
 355 static void
 356 lex_free_string (
 357   lex_t  *lex
 358   )
 359 {
 360   jsonp_free (lex->value.string.val);
 361   lex->value.string.val = NULL;
 362   lex->value.string.len = 0;
 363 }
 364
 365 /* assumes that str points to 'u' plus at least 4 valid hex digits */
 366 static int32_t
 367 decode_unicode_escape (
 368   const char  *str
 369   )
 370 {
 371   int      i;
 372   int32_t  value = 0;
 373
 374   assert (str[0] == 'u');
 375
 376   for (i = 1; i <= 4; i++) {
 377     char  c = str[i];
 378     value <<= 4;
 379     if (l_isdigit (c)) {
 380       value += c - '0';
 381     } else if (l_islower (c)) {
 382       value += c - 'a' + 10;
 383     } else if (l_isupper (c)) {
 384       value += c - 'A' + 10;
 385     } else {
 386       return -1;
 387     }
 388   }
 389
 390   return value;
 391 }
 392
 393 static void
 394 lex_scan_string (
 395   lex_t         *lex,
 396   json_error_t  *error
 397   )
 398 {
 399   int         c;
 400   const char  *p;
 401   char        *t;
 402   int         i;
 403
 404   lex->value.string.val = NULL;
 405   lex->token            = TOKEN_INVALID;
 406
 407   c = lex_get_save (lex, error);
 408
 409   while (c != '"') {
 410     if (c == STREAM_STATE_ERROR) {
 411       goto out;
 412     } else if (c == STREAM_STATE_EOF) {
 413       error_set (
 414         error,
 415         lex,
 416         json_error_premature_end_of_input,
 417         "premature end of input"
 418         );
 419       goto out;
 420     } else if ((0 <= c) && (c <= 0x1F)) {
 421       /* control character */
 422       lex_unget_unsave (lex, c);
 423       if (c == '\n') {
 424         error_set (error, lex, json_error_invalid_syntax, "unexpected newline");
 425       } else {
 426         error_set (
 427           error,
 428           lex,
 429           json_error_invalid_syntax,
 430           "control character 0x%x",
 431           c
 432           );
 433       }
 434
 435       goto out;
 436     } else if (c == '\\') {
 437       c = lex_get_save (lex, error);
 438       if (c == 'u') {
 439         c = lex_get_save (lex, error);
 440         for (i = 0; i < 4; i++) {
 441           if (!l_isxdigit (c)) {
 442             error_set (
 443               error,
 444               lex,
 445               json_error_invalid_syntax,
 446               "invalid escape"
 447               );
 448             goto out;
 449           }
 450
 451           c = lex_get_save (lex, error);
 452         }
 453       } else if ((c == '"') || (c == '\\') || (c == '/') || (c == 'b') || (c == 'f') ||
 454                  (c == 'n') || (c == 'r') || (c == 't'))
 455       {
 456         c = lex_get_save (lex, error);
 457       } else {
 458         error_set (error, lex, json_error_invalid_syntax, "invalid escape");
 459         goto out;
 460       }
 461     } else {
 462       c = lex_get_save (lex, error);
 463     }
 464   }
 465
 466   /* the actual value is at most of the same length as the source
 467      string, because:
 468        - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
 469        - a single \uXXXX escape (length 6) is converted to at most 3 bytes
 470        - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
 471          are converted to 4 bytes
 472   */
 473   t = jsonp_malloc (lex->saved_text.length + 1);
 474   if (!t) {
 475     /* this is not very nice, since TOKEN_INVALID is returned */
 476     goto out;
 477   }
 478
 479   lex->value.string.val = t;
 480
 481   /* + 1 to skip the " */
 482   p = strbuffer_value (&lex->saved_text) + 1;
 483
 484   while (*p != '"') {
 485     if (*p == '\\') {
 486       p++;
 487       if (*p == 'u') {
 488         size_t   length;
 489         int32_t  value;
 490
 491         value = decode_unicode_escape (p);
 492         if (value < 0) {
 493           error_set (
 494             error,
 495             lex,
 496             json_error_invalid_syntax,
 497             "invalid Unicode escape '%.6s'",
 498             p - 1
 499             );
 500           goto out;
 501         }
 502
 503         p += 5;
 504
 505         if ((0xD800 <= value) && (value <= 0xDBFF)) {
 506           /* surrogate pair */
 507           if ((*p == '\\') && (*(p + 1) == 'u')) {
 508             int32_t  value2 = decode_unicode_escape (++p);
 509             if (value2 < 0) {
 510               error_set (
 511                 error,
 512                 lex,
 513                 json_error_invalid_syntax,
 514                 "invalid Unicode escape '%.6s'",
 515                 p - 1
 516                 );
 517               goto out;
 518             }
 519
 520             p += 5;
 521
 522             if ((0xDC00 <= value2) && (value2 <= 0xDFFF)) {
 523               /* valid second surrogate */
 524               value =
 525                 ((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000;
 526             } else {
 527               /* invalid second surrogate */
 528               error_set (
 529                 error,
 530                 lex,
 531                 json_error_invalid_syntax,
 532                 "invalid Unicode '\\u%04X\\u%04X'",
 533                 value,
 534                 value2
 535                 );
 536               goto out;
 537             }
 538           } else {
 539             /* no second surrogate */
 540             error_set (
 541               error,
 542               lex,
 543               json_error_invalid_syntax,
 544               "invalid Unicode '\\u%04X'",
 545               value
 546               );
 547             goto out;
 548           }
 549         } else if ((0xDC00 <= value) && (value <= 0xDFFF)) {
 550           error_set (
 551             error,
 552             lex,
 553             json_error_invalid_syntax,
 554             "invalid Unicode '\\u%04X'",
 555             value
 556             );
 557           goto out;
 558         }
 559
 560         if (utf8_encode (value, t, &length)) {
 561           assert (0);
 562         }
 563
 564         t += length;
 565       } else {
 566         switch (*p) {
 567           case '"':
 568           case '\\':
 569           case '/':
 570             *t = *p;
 571             break;
 572           case 'b':
 573             *t = '\b';
 574             break;
 575           case 'f':
 576             *t = '\f';
 577             break;
 578           case 'n':
 579             *t = '\n';
 580             break;
 581           case 'r':
 582             *t = '\r';
 583             break;
 584           case 't':
 585             *t = '\t';
 586             break;
 587           default:
 588             assert (0);
 589         }
 590
 591         t++;
 592         p++;
 593       }
 594     } else {
 595       *(t++) = *(p++);
 596     }
 597   }
 598
 599   *t                    = '\0';
 600   lex->value.string.len = t - lex->value.string.val;
 601   lex->token            = TOKEN_STRING;
 602   return;
 603
 604 out:
 605   lex_free_string (lex);
 606 }
 607
 608 #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
 609   #if JSON_INTEGER_IS_LONG_LONG
 610     #ifdef _MSC_VER /* Microsoft Visual Studio */
 611 #define json_strtoint  _strtoi64
 612     #else
 613 #define json_strtoint  strtoll
 614     #endif
 615   #else
 616 #define json_strtoint  strtol
 617   #endif
 618 #endif
 619
 620 static int
 621 lex_scan_number (
 622   lex_t         *lex,
 623   int           c,
 624   json_error_t  *error
 625   )
 626 {
 627   const char  *saved_text;
 628   char        *end;
 629   double      doubleval;
 630
 631   lex->token = TOKEN_INVALID;
 632
 633   if (c == '-') {
 634     c = lex_get_save (lex, error);
 635   }
 636
 637   if (c == '0') {
 638     c = lex_get_save (lex, error);
 639     if (l_isdigit (c)) {
 640       lex_unget_unsave (lex, c);
 641       goto out;
 642     }
 643   } else if (l_isdigit (c)) {
 644     do {
 645       c = lex_get_save (lex, error);
 646     } while (l_isdigit (c));
 647   } else {
 648     lex_unget_unsave (lex, c);
 649     goto out;
 650   }
 651
 652   if (!(lex->flags & JSON_DECODE_INT_AS_REAL) && (c != '.') && (c != 'E') && (c != 'e')) {
 653     json_int_t  intval;
 654
 655     lex_unget_unsave (lex, c);
 656
 657     saved_text = strbuffer_value (&lex->saved_text);
 658
 659     errno  = 0;
 660     intval = json_strtoint (saved_text, &end, 10);
 661     if (errno == ERANGE) {
 662       if (intval < 0) {
 663         error_set (
 664           error,
 665           lex,
 666           json_error_numeric_overflow,
 667           "too big negative integer"
 668           );
 669       } else {
 670         error_set (error, lex, json_error_numeric_overflow, "too big integer");
 671       }
 672
 673       goto out;
 674     }
 675
 676     assert (end == saved_text + lex->saved_text.length);
 677
 678     lex->token         = TOKEN_INTEGER;
 679     lex->value.integer = intval;
 680     return 0;
 681   }
 682
 683   if (c == '.') {
 684     c = lex_get (lex, error);
 685     if (!l_isdigit (c)) {
 686       lex_unget (lex, c);
 687       goto out;
 688     }
 689
 690     lex_save (lex, c);
 691
 692     do {
 693       c = lex_get_save (lex, error);
 694     } while (l_isdigit (c));
 695   }
 696
 697   if ((c == 'E') || (c == 'e')) {
 698     c = lex_get_save (lex, error);
 699     if ((c == '+') || (c == '-')) {
 700       c = lex_get_save (lex, error);
 701     }
 702
 703     if (!l_isdigit (c)) {
 704       lex_unget_unsave (lex, c);
 705       goto out;
 706     }
 707
 708     do {
 709       c = lex_get_save (lex, error);
 710     } while (l_isdigit (c));
 711   }
 712
 713   lex_unget_unsave (lex, c);
 714
 715   if (jsonp_strtod (&lex->saved_text, &doubleval)) {
 716     error_set (error, lex, json_error_numeric_overflow, "real number overflow");
 717     goto out;
 718   }
 719
 720   lex->token      = TOKEN_REAL;
 721   lex->value.real = doubleval;
 722   return 0;
 723
 724 out:
 725   return -1;
 726 }
 727
 728 static int
 729 lex_scan (
 730   lex_t         *lex,
 731   json_error_t  *error
 732   )
 733 {
 734   int  c;
 735
 736   strbuffer_clear (&lex->saved_text);
 737
 738   if (lex->token == TOKEN_STRING) {
 739     lex_free_string (lex);
 740   }
 741
 742   do {
 743     c = lex_get (lex, error);
 744   } while (c == ' ' || c == '\t' || c == '\n' || c == '\r');
 745
 746   if (c == STREAM_STATE_EOF) {
 747     lex->token = TOKEN_EOF;
 748     goto out;
 749   }
 750
 751   if (c == STREAM_STATE_ERROR) {
 752     lex->token = TOKEN_INVALID;
 753     goto out;
 754   }
 755
 756   lex_save (lex, c);
 757
 758   if ((c == '{') || (c == '}') || (c == '[') || (c == ']') || (c == ':') || (c == ',')) {
 759     lex->token = c;
 760   } else if (c == '"') {
 761     lex_scan_string (lex, error);
 762   } else if (l_isdigit (c) || (c == '-')) {
 763     if (lex_scan_number (lex, c, error)) {
 764       goto out;
 765     }
 766   } else if (l_isalpha (c)) {
 767     /* eat up the whole identifier for clearer error messages */
 768     const char  *saved_text;
 769
 770     do {
 771       c = lex_get_save (lex, error);
 772     } while (l_isalpha (c));
 773
 774     lex_unget_unsave (lex, c);
 775
 776     saved_text = strbuffer_value (&lex->saved_text);
 777
 778     if (strcmp (saved_text, "true") == 0) {
 779       lex->token = TOKEN_TRUE;
 780     } else if (strcmp (saved_text, "false") == 0) {
 781       lex->token = TOKEN_FALSE;
 782     } else if (strcmp (saved_text, "null") == 0) {
 783       lex->token = TOKEN_NULL;
 784     } else {
 785       lex->token = TOKEN_INVALID;
 786     }
 787   } else {
 788     /* save the rest of the input UTF-8 sequence to get an error
 789        message of valid UTF-8 */
 790     lex_save_cached (lex);
 791     lex->token = TOKEN_INVALID;
 792   }
 793
 794 out:
 795   return lex->token;
 796 }
 797
 798 static char *
 799 lex_steal_string (
 800   lex_t   *lex,
 801   size_t  *out_len
 802   )
 803 {
 804   char  *result = NULL;
 805
 806   if (lex->token == TOKEN_STRING) {
 807     result                = lex->value.string.val;
 808     *out_len              = lex->value.string.len;
 809     lex->value.string.val = NULL;
 810     lex->value.string.len = 0;
 811   }
 812
 813   return result;
 814 }
 815
 816 static int
 817 lex_init (
 818   lex_t     *lex,
 819   get_func  get,
 820   size_t    flags,
 821   void      *data
 822   )
 823 {
 824   stream_init (&lex->stream, get, data);
 825   if (strbuffer_init (&lex->saved_text)) {
 826     return -1;
 827   }
 828
 829   lex->flags = flags;
 830   lex->token = TOKEN_INVALID;
 831   return 0;
 832 }
 833
 834 static void
 835 lex_close (
 836   lex_t  *lex
 837   )
 838 {
 839   if (lex->token == TOKEN_STRING) {
 840     lex_free_string (lex);
 841   }
 842
 843   strbuffer_close (&lex->saved_text);
 844 }
 845
 846 /*** parser ***/
 847
 848 static json_t *
 849 parse_value (
 850   lex_t         *lex,
 851   size_t        flags,
 852   json_error_t  *error
 853   );
 854
 855 static json_t *
 856 parse_object (
 857   lex_t         *lex,
 858   size_t        flags,
 859   json_error_t  *error
 860   )
 861 {
 862   json_t  *object = json_object ();
 863
 864   if (!object) {
 865     return NULL;
 866   }
 867
 868   lex_scan (lex, error);
 869   if (lex->token == '}') {
 870     return object;
 871   }
 872
 873   while (1) {
 874     char    *key;
 875     size_t  len;
 876     json_t  *value;
 877
 878     if (lex->token != TOKEN_STRING) {
 879       error_set (error, lex, json_error_invalid_syntax, "string or '}' expected");
 880       goto error;
 881     }
 882
 883     key = lex_steal_string (lex, &len);
 884     if (!key) {
 885       return NULL;
 886     }
 887
 888     if (memchr (key, '\0', len)) {
 889       jsonp_free (key);
 890       error_set (
 891         error,
 892         lex,
 893         json_error_null_byte_in_key,
 894         "NUL byte in object key not supported"
 895         );
 896       goto error;
 897     }
 898
 899     if (flags & JSON_REJECT_DUPLICATES) {
 900       if (json_object_get (object, key)) {
 901         jsonp_free (key);
 902         error_set (error, lex, json_error_duplicate_key, "duplicate object key");
 903         goto error;
 904       }
 905     }
 906
 907     lex_scan (lex, error);
 908     if (lex->token != ':') {
 909       jsonp_free (key);
 910       error_set (error, lex, json_error_invalid_syntax, "':' expected");
 911       goto error;
 912     }
 913
 914     lex_scan (lex, error);
 915     value = parse_value (lex, flags, error);
 916     if (!value) {
 917       jsonp_free (key);
 918       goto error;
 919     }
 920
 921     if (json_object_set_new_nocheck (object, key, value)) {
 922       jsonp_free (key);
 923       goto error;
 924     }
 925
 926     jsonp_free (key);
 927
 928     lex_scan (lex, error);
 929     if (lex->token != ',') {
 930       break;
 931     }
 932
 933     lex_scan (lex, error);
 934   }
 935
 936   if (lex->token != '}') {
 937     error_set (error, lex, json_error_invalid_syntax, "'}' expected");
 938     goto error;
 939   }
 940
 941   return object;
 942
 943 error:
 944   json_decref (object);
 945   return NULL;
 946 }
 947
 948 static json_t *
 949 parse_array (
 950   lex_t         *lex,
 951   size_t        flags,
 952   json_error_t  *error
 953   )
 954 {
 955   json_t  *array = json_array ();
 956
 957   if (!array) {
 958     return NULL;
 959   }
 960
 961   lex_scan (lex, error);
 962   if (lex->token == ']') {
 963     return array;
 964   }
 965
 966   while (lex->token) {
 967     json_t  *elem = parse_value (lex, flags, error);
 968     if (!elem) {
 969       goto error;
 970     }
 971
 972     if (json_array_append_new (array, elem)) {
 973       goto error;
 974     }
 975
 976     lex_scan (lex, error);
 977     if (lex->token != ',') {
 978       break;
 979     }
 980
 981     lex_scan (lex, error);
 982   }
 983
 984   if (lex->token != ']') {
 985     error_set (error, lex, json_error_invalid_syntax, "']' expected");
 986     goto error;
 987   }
 988
 989   return array;
 990
 991 error:
 992   json_decref (array);
 993   return NULL;
 994 }
 995
 996 static json_t *
 997 parse_value (
 998   lex_t         *lex,
 999   size_t        flags,
1000   json_error_t  *error
1001   )
1002 {
1003   json_t  *json;
1004
1005   lex->depth++;
1006   if (lex->depth > JSON_PARSER_MAX_DEPTH) {
1007     error_set (error, lex, json_error_stack_overflow, "maximum parsing depth reached");
1008     return NULL;
1009   }
1010
1011   switch (lex->token) {
1012     case TOKEN_STRING:
1013     {
1014       const char  *value = lex->value.string.val;
1015       size_t      len    = lex->value.string.len;
1016
1017       if (!(flags & JSON_ALLOW_NUL)) {
1018         if (memchr (value, '\0', len)) {
1019           error_set (
1020             error,
1021             lex,
1022             json_error_null_character,
1023             "\\u0000 is not allowed without JSON_ALLOW_NUL"
1024             );
1025           return NULL;
1026         }
1027       }
1028
1029       json                  = jsonp_stringn_nocheck_own (value, len);
1030       lex->value.string.val = NULL;
1031       lex->value.string.len = 0;
1032       break;
1033     }
1034
1035     case TOKEN_INTEGER:
1036     {
1037       json = json_integer (lex->value.integer);
1038       break;
1039     }
1040
1041     case TOKEN_REAL:
1042     {
1043       json = json_real (lex->value.real);
1044       break;
1045     }
1046
1047     case TOKEN_TRUE:
1048       json = json_true ();
1049       break;
1050
1051     case TOKEN_FALSE:
1052       json = json_false ();
1053       break;
1054
1055     case TOKEN_NULL:
1056       json = json_null ();
1057       break;
1058
1059     case '{':
1060       json = parse_object (lex, flags, error);
1061       break;
1062
1063     case '[':
1064       json = parse_array (lex, flags, error);
1065       break;
1066
1067     case TOKEN_INVALID:
1068       error_set (error, lex, json_error_invalid_syntax, "invalid token");
1069       return NULL;
1070
1071     default:
1072       error_set (error, lex, json_error_invalid_syntax, "unexpected token");
1073       return NULL;
1074   }
1075
1076   if (!json) {
1077     return NULL;
1078   }
1079
1080   lex->depth--;
1081   return json;
1082 }
1083
1084 static json_t *
1085 parse_json (
1086   lex_t         *lex,
1087   size_t        flags,
1088   json_error_t  *error
1089   )
1090 {
1091   json_t  *result;
1092
1093   lex->depth = 0;
1094
1095   lex_scan (lex, error);
1096   if (!(flags & JSON_DECODE_ANY)) {
1097     if ((lex->token != '[') && (lex->token != '{')) {
1098       error_set (error, lex, json_error_invalid_syntax, "'[' or '{' expected");
1099       return NULL;
1100     }
1101   }
1102
1103   result = parse_value (lex, flags, error);
1104   if (!result) {
1105     return NULL;
1106   }
1107
1108   if (!(flags & JSON_DISABLE_EOF_CHECK)) {
1109     lex_scan (lex, error);
1110     if (lex->token != TOKEN_EOF) {
1111       error_set (
1112         error,
1113         lex,
1114         json_error_end_of_input_expected,
1115         "end of file expected"
1116         );
1117       json_decref (result);
1118       return NULL;
1119     }
1120   }
1121
1122   if (error) {
1123     /* Save the position even though there was no error */
1124     error->position = (int)lex->stream.position;
1125   }
1126
1127   return result;
1128 }
1129
1130 typedef struct {
1131   const char    *data;
1132   size_t        pos;
1133 } string_data_t;
1134
1135 static int
1136 string_get (
1137   void  *data
1138   )
1139 {
1140   char           c;
1141   string_data_t  *stream = (string_data_t *)data;
1142
1143   c = stream->data[stream->pos];
1144   if (c == '\0') {
1145     return EOF;
1146   } else {
1147     stream->pos++;
1148     return (unsigned char)c;
1149   }
1150 }
1151
1152 json_t *
1153 json_loads (
1154   const char    *string,
1155   size_t        flags,
1156   json_error_t  *error
1157   )
1158 {
1159   lex_t          lex;
1160   json_t         *result;
1161   string_data_t  stream_data;
1162
1163   jsonp_error_init (error, "<string>");
1164
1165   if (string == NULL) {
1166     error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
1167     return NULL;
1168   }
1169
1170   stream_data.data = string;
1171   stream_data.pos  = 0;
1172
1173   if (lex_init (&lex, string_get, flags, (void *)&stream_data)) {
1174     return NULL;
1175   }
1176
1177   result = parse_json (&lex, flags, error);
1178
1179   lex_close (&lex);
1180   return result;
1181 }
1182
1183 typedef struct {
1184   const char    *data;
1185   size_t        len;
1186   size_t        pos;
1187 } buffer_data_t;
1188
1189 static int
1190 buffer_get (
1191   void  *data
1192   )
1193 {
1194   char           c;
1195   buffer_data_t  *stream = data;
1196
1197   if (stream->pos >= stream->len) {
1198     return EOF;
1199   }
1200
1201   c = stream->data[stream->pos];
1202   stream->pos++;
1203   return (unsigned char)c;
1204 }
1205
1206 json_t *
1207 json_loadb (
1208   const char    *buffer,
1209   size_t        buflen,
1210   size_t        flags,
1211   json_error_t  *error
1212   )
1213 {
1214   lex_t          lex;
1215   json_t         *result;
1216   buffer_data_t  stream_data;
1217
1218   jsonp_error_init (error, "<buffer>");
1219
1220   if (buffer == NULL) {
1221     error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
1222     return NULL;
1223   }
1224
1225   stream_data.data = buffer;
1226   stream_data.pos  = 0;
1227   stream_data.len  = buflen;
1228
1229   if (lex_init (&lex, buffer_get, flags, (void *)&stream_data)) {
1230     return NULL;
1231   }
1232
1233   result = parse_json (&lex, flags, error);
1234
1235   lex_close (&lex);
1236   return result;
1237 }
1238
1239 json_t *
1240 json_loadf (
1241   FILE          *input,
1242   size_t        flags,
1243   json_error_t  *error
1244   )
1245 {
1246   lex_t       lex;
1247   const char  *source;
1248   json_t      *result;
1249
1250  #ifdef HAVE_UNISTD_H
1251   if (input == stdin) {
1252     source = "<stdin>";
1253   } else
1254  #endif
1255   source = "<stream>";
1256
1257   jsonp_error_init (error, source);
1258
1259   if (input == NULL) {
1260     error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
1261     return NULL;
1262   }
1263
1264   if (lex_init (&lex, (get_func)fgetc, flags, input)) {
1265     return NULL;
1266   }
1267
1268   result = parse_json (&lex, flags, error);
1269
1270   lex_close (&lex);
1271   return result;
1272 }
1273
1274 static int
1275 fd_get_func (
1276   int  *fd
1277   )
1278 {
1279  #ifdef HAVE_UNISTD_H
1280   uint8_t  c;
1281   if (read (*fd, &c, 1) == 1) {
1282     return c;
1283   }
1284
1285  #endif
1286   return EOF;
1287 }
1288
1289 json_t *
1290 json_loadfd (
1291   int           input,
1292   size_t        flags,
1293   json_error_t  *error
1294   )
1295 {
1296   lex_t       lex;
1297   const char  *source;
1298   json_t      *result;
1299
1300  #ifdef HAVE_UNISTD_H
1301   if (input == STDIN_FILENO) {
1302     source = "<stdin>";
1303   } else
1304  #endif
1305   source = "<stream>";
1306
1307   jsonp_error_init (error, source);
1308
1309   if (input < 0) {
1310     error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
1311     return NULL;
1312   }
1313
1314   if (lex_init (&lex, (get_func)fd_get_func, flags, &input)) {
1315     return NULL;
1316   }
1317
1318   result = parse_json (&lex, flags, error);
1319
1320   lex_close (&lex);
1321   return result;
1322 }
1323
1324 json_t *
1325 json_load_file (
1326   const char    *path,
1327   size_t        flags,
1328   json_error_t  *error
1329   )
1330 {
1331   json_t  *result;
1332   FILE    *fp;
1333
1334   jsonp_error_init (error, path);
1335
1336   if (path == NULL) {
1337     error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
1338     return NULL;
1339   }
1340
1341   fp = fopen (path, "rb");
1342   if (!fp) {
1343     error_set (
1344       error,
1345       NULL,
1346       json_error_cannot_open_file,
1347       "unable to open %s: %s",
1348       path,
1349       strerror (errno)
1350       );
1351     return NULL;
1352   }
1353
1354   result = json_loadf (fp, flags, error);
1355
1356   fclose (fp);
1357   return result;
1358 }
1359
1360 #define MAX_BUF_LEN  1024
1361
1362 typedef struct {
1363   char                    data[MAX_BUF_LEN];
1364   size_t                  len;
1365   size_t                  pos;
1366   json_load_callback_t    callback;
1367   void                    *arg;
1368 } callback_data_t;
1369
1370 static int
1371 callback_get (
1372   void  *data
1373   )
1374 {
1375   char             c;
1376   callback_data_t  *stream = data;
1377
1378   if (stream->pos >= stream->len) {
1379     stream->pos = 0;
1380     stream->len = stream->callback (stream->data, MAX_BUF_LEN, stream->arg);
1381     if ((stream->len == 0) || (stream->len == (size_t)-1)) {
1382       return EOF;
1383     }
1384   }
1385
1386   c = stream->data[stream->pos];
1387   stream->pos++;
1388   return (unsigned char)c;
1389 }
1390
1391 json_t *
1392 json_load_callback (
1393   json_load_callback_t  callback,
1394   void                  *arg,
1395   size_t                flags,
1396   json_error_t          *error
1397   )
1398 {
1399   lex_t   lex;
1400   json_t  *result;
1401
1402   callback_data_t  stream_data;
1403
1404   memset (&stream_data, 0, sizeof (stream_data));
1405   stream_data.callback = callback;
1406   stream_data.arg      = arg;
1407
1408   jsonp_error_init (error, "<callback>");
1409
1410   if (callback == NULL) {
1411     error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
1412     return NULL;
1413   }
1414
1415   if (lex_init (&lex, (get_func)callback_get, flags, &stream_data)) {
1416     return NULL;
1417   }
1418
1419   result = parse_json (&lex, flags, error);
1420
1421   lex_close (&lex);
1422   return result;
1423 }