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