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