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