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