src/load.c

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