src/load.c

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