src/load.c

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