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