src/load.c

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