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     char msg_with_context[JSON_ERROR_TEXT_LENGTH];
  73
  74     int line = -1, col = -1;
  75     size_t pos = 0;
  76     const char *result = msg_text;
  77
  78     if(!error)
  79         return;
  80
  81     va_start(ap, msg);
  82     vsnprintf(msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap);
  83     va_end(ap);
  84
  85     if(lex)
  86     {
  87         const char *saved_text = strbuffer_value(&lex->saved_text);
  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     if(jsonp_strtod(&lex->saved_text, &value)) {
 528         error_set(error, lex, "real number overflow");
 529         goto out;
 530     }
 531
 532     lex->token = TOKEN_REAL;
 533     lex->value.real = value;
 534     return 0;
 535
 536 out:
 537     return -1;
 538 }
 539
 540 static int lex_scan(lex_t *lex, json_error_t *error)
 541 {
 542     int c;
 543
 544     strbuffer_clear(&lex->saved_text);
 545
 546     if(lex->token == TOKEN_STRING) {
 547         jsonp_free(lex->value.string);
 548         lex->value.string = NULL;
 549     }
 550
 551     c = lex_get(lex, error);
 552     while(c == ' ' || c == '\t' || c == '\n' || c == '\r')
 553         c = lex_get(lex, error);
 554
 555     if(c == STREAM_STATE_EOF) {
 556         lex->token = TOKEN_EOF;
 557         goto out;
 558     }
 559
 560     if(c == STREAM_STATE_ERROR) {
 561         lex->token = TOKEN_INVALID;
 562         goto out;
 563     }
 564
 565     lex_save(lex, c);
 566
 567     if(c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
 568         lex->token = c;
 569
 570     else if(c == '"')
 571         lex_scan_string(lex, error);
 572
 573     else if(isdigit(c) || c == '-') {
 574         if(lex_scan_number(lex, c, error))
 575             goto out;
 576     }
 577
 578     else if(isupper(c) || islower(c)) {
 579         /* eat up the whole identifier for clearer error messages */
 580         const char *saved_text;
 581
 582         c = lex_get_save(lex, error);
 583         while(isupper(c) || islower(c))
 584             c = lex_get_save(lex, error);
 585         lex_unget_unsave(lex, c);
 586
 587         saved_text = strbuffer_value(&lex->saved_text);
 588
 589         if(strcmp(saved_text, "true") == 0)
 590             lex->token = TOKEN_TRUE;
 591         else if(strcmp(saved_text, "false") == 0)
 592             lex->token = TOKEN_FALSE;
 593         else if(strcmp(saved_text, "null") == 0)
 594             lex->token = TOKEN_NULL;
 595         else
 596             lex->token = TOKEN_INVALID;
 597     }
 598
 599     else {
 600         /* save the rest of the input UTF-8 sequence to get an error
 601            message of valid UTF-8 */
 602         lex_save_cached(lex);
 603         lex->token = TOKEN_INVALID;
 604     }
 605
 606 out:
 607     return lex->token;
 608 }
 609
 610 static char *lex_steal_string(lex_t *lex)
 611 {
 612     char *result = NULL;
 613     if(lex->token == TOKEN_STRING)
 614     {
 615         result = lex->value.string;
 616         lex->value.string = NULL;
 617     }
 618     return result;
 619 }
 620
 621 static int lex_init(lex_t *lex, get_func get, void *data)
 622 {
 623     stream_init(&lex->stream, get, data);
 624     if(strbuffer_init(&lex->saved_text))
 625         return -1;
 626
 627     lex->token = TOKEN_INVALID;
 628     return 0;
 629 }
 630
 631 static void lex_close(lex_t *lex)
 632 {
 633     if(lex->token == TOKEN_STRING)
 634         jsonp_free(lex->value.string);
 635     strbuffer_close(&lex->saved_text);
 636 }
 637
 638
 639 /*** parser ***/
 640
 641 static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error);
 642
 643 static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
 644 {
 645     json_t *object = json_object();
 646     if(!object)
 647         return NULL;
 648
 649     lex_scan(lex, error);
 650     if(lex->token == '}')
 651         return object;
 652
 653     while(1) {
 654         char *key;
 655         json_t *value;
 656
 657         if(lex->token != TOKEN_STRING) {
 658             error_set(error, lex, "string or '}' expected");
 659             goto error;
 660         }
 661
 662         key = lex_steal_string(lex);
 663         if(!key)
 664             return NULL;
 665
 666         if(flags & JSON_REJECT_DUPLICATES) {
 667             if(json_object_get(object, key)) {
 668                 jsonp_free(key);
 669                 error_set(error, lex, "duplicate object key");
 670                 goto error;
 671             }
 672         }
 673
 674         lex_scan(lex, error);
 675         if(lex->token != ':') {
 676             jsonp_free(key);
 677             error_set(error, lex, "':' expected");
 678             goto error;
 679         }
 680
 681         lex_scan(lex, error);
 682         value = parse_value(lex, flags, error);
 683         if(!value) {
 684             jsonp_free(key);
 685             goto error;
 686         }
 687
 688         if(json_object_set_nocheck(object, key, value)) {
 689             jsonp_free(key);
 690             json_decref(value);
 691             goto error;
 692         }
 693
 694         json_decref(value);
 695         jsonp_free(key);
 696
 697         lex_scan(lex, error);
 698         if(lex->token != ',')
 699             break;
 700
 701         lex_scan(lex, error);
 702     }
 703
 704     if(lex->token != '}') {
 705         error_set(error, lex, "'}' expected");
 706         goto error;
 707     }
 708
 709     return object;
 710
 711 error:
 712     json_decref(object);
 713     return NULL;
 714 }
 715
 716 static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error)
 717 {
 718     json_t *array = json_array();
 719     if(!array)
 720         return NULL;
 721
 722     lex_scan(lex, error);
 723     if(lex->token == ']')
 724         return array;
 725
 726     while(lex->token) {
 727         json_t *elem = parse_value(lex, flags, error);
 728         if(!elem)
 729             goto error;
 730
 731         if(json_array_append(array, elem)) {
 732             json_decref(elem);
 733             goto error;
 734         }
 735         json_decref(elem);
 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, "']' expected");
 746         goto error;
 747     }
 748
 749     return array;
 750
 751 error:
 752     json_decref(array);
 753     return NULL;
 754 }
 755
 756 static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
 757 {
 758     json_t *json;
 759
 760     switch(lex->token) {
 761         case TOKEN_STRING: {
 762             json = json_string_nocheck(lex->value.string);
 763             break;
 764         }
 765
 766         case TOKEN_INTEGER: {
 767             json = json_integer(lex->value.integer);
 768             break;
 769         }
 770
 771         case TOKEN_REAL: {
 772             json = json_real(lex->value.real);
 773             break;
 774         }
 775
 776         case TOKEN_TRUE:
 777             json = json_true();
 778             break;
 779
 780         case TOKEN_FALSE:
 781             json = json_false();
 782             break;
 783
 784         case TOKEN_NULL:
 785             json = json_null();
 786             break;
 787
 788         case '{':
 789             json = parse_object(lex, flags, error);
 790             break;
 791
 792         case '[':
 793             json = parse_array(lex, flags, error);
 794             break;
 795
 796         case TOKEN_INVALID:
 797             error_set(error, lex, "invalid token");
 798             return NULL;
 799
 800         default:
 801             error_set(error, lex, "unexpected token");
 802             return NULL;
 803     }
 804
 805     if(!json)
 806         return NULL;
 807
 808     return json;
 809 }
 810
 811 static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
 812 {
 813     json_t *result;
 814
 815     lex_scan(lex, error);
 816     if(lex->token != '[' && lex->token != '{') {
 817         error_set(error, lex, "'[' or '{' expected");
 818         return NULL;
 819     }
 820
 821     result = parse_value(lex, flags, error);
 822     if(!result)
 823         return NULL;
 824
 825     if(!(flags & JSON_DISABLE_EOF_CHECK)) {
 826         lex_scan(lex, error);
 827         if(lex->token != TOKEN_EOF) {
 828             error_set(error, lex, "end of file expected");
 829             json_decref(result);
 830             result = NULL;
 831         }
 832     }
 833
 834     return result;
 835 }
 836
 837 typedef struct
 838 {
 839     const char *data;
 840     int pos;
 841 } string_data_t;
 842
 843 static int string_get(void *data)
 844 {
 845     char c;
 846     string_data_t *stream = (string_data_t *)data;
 847     c = stream->data[stream->pos];
 848     if(c == '\0')
 849         return EOF;
 850     else
 851     {
 852         stream->pos++;
 853         return (unsigned char)c;
 854     }
 855 }
 856
 857 json_t *json_loads(const char *string, size_t flags, json_error_t *error)
 858 {
 859     lex_t lex;
 860     json_t *result;
 861     string_data_t stream_data;
 862
 863     stream_data.data = string;
 864     stream_data.pos = 0;
 865
 866     if(lex_init(&lex, string_get, (void *)&stream_data))
 867         return NULL;
 868
 869     jsonp_error_init(error, "<string>");
 870     result = parse_json(&lex, flags, error);
 871
 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     result = parse_json(&lex, flags, error);
 910
 911     lex_close(&lex);
 912     return result;
 913 }
 914
 915 json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
 916 {
 917     lex_t lex;
 918     const char *source;
 919     json_t *result;
 920
 921     if(lex_init(&lex, (get_func)fgetc, input))
 922         return NULL;
 923
 924     if(input == stdin)
 925         source = "<stdin>";
 926     else
 927         source = "<stream>";
 928
 929     jsonp_error_init(error, source);
 930     result = parse_json(&lex, flags, error);
 931
 932     lex_close(&lex);
 933     return result;
 934 }
 935
 936 json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
 937 {
 938     json_t *result;
 939     FILE *fp;
 940
 941     jsonp_error_init(error, path);
 942
 943     fp = fopen(path, "r");
 944     if(!fp)
 945     {
 946         error_set(error, NULL, "unable to open %s: %s",
 947                   path, strerror(errno));
 948         return NULL;
 949     }
 950
 951     result = json_loadf(fp, flags, error);
 952
 953     fclose(fp);
 954     return result;
 955 }