src/load.c

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