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     char buffer[5];
  36     int buffer_pos;
  37 } stream_t;
  38
  39
  40 typedef struct {
  41     stream_t stream;
  42     strbuffer_t saved_text;
  43     int token;
  44     int line, column;
  45     union {
  46         char *string;
  47         int integer;
  48         double real;
  49     } value;
  50 } lex_t;
  51
  52
  53 /*** error reporting ***/
  54
  55 static void error_set(json_error_t *error, const lex_t *lex,
  56                       const char *msg, ...)
  57 {
  58     va_list ap;
  59     char text[JSON_ERROR_TEXT_LENGTH];
  60
  61     if(!error)
  62         return;
  63
  64     va_start(ap, msg);
  65     vsnprintf(text, JSON_ERROR_TEXT_LENGTH, msg, ap);
  66     va_end(ap);
  67
  68     if(lex)
  69     {
  70         const char *saved_text = strbuffer_value(&lex->saved_text);
  71         error->line = lex->line;
  72         if(saved_text && saved_text[0])
  73         {
  74             snprintf(error->text, JSON_ERROR_TEXT_LENGTH,
  75                      "%s near '%s'", text, saved_text);
  76         }
  77         else
  78         {
  79             snprintf(error->text, JSON_ERROR_TEXT_LENGTH,
  80                      "%s near end of file", text);
  81         }
  82     }
  83     else
  84     {
  85         error->line = -1;
  86         snprintf(error->text, JSON_ERROR_TEXT_LENGTH, "%s", text);
  87     }
  88 }
  89
  90
  91 /*** lexical analyzer ***/
  92
  93 void stream_init(stream_t *stream, get_func get, eof_func eof, void *data)
  94 {
  95     stream->get = get;
  96     stream->eof = eof;
  97     stream->data = data;
  98     stream->buffer[0] = '\0';
  99     stream->buffer_pos = 0;
 100 }
 101
 102 static char stream_get(stream_t *stream)
 103 {
 104     if(!stream->buffer[stream->buffer_pos])
 105     {
 106         char c;
 107
 108         stream->buffer[0] = stream->get(stream->data);
 109         stream->buffer_pos = 0;
 110
 111         c = stream->buffer[0];
 112
 113         if(c == EOF && stream->eof(stream->data))
 114             return EOF;
 115
 116         if(c < 0)
 117         {
 118             /* multi-byte UTF-8 sequence */
 119             int i, count;
 120
 121             count = utf8_check_first(c);
 122             if(!count)
 123                 return 0;
 124
 125             assert(count >= 2);
 126
 127             for(i = 1; i < count; i++)
 128                 stream->buffer[i] = stream->get(stream->data);
 129
 130             if(!utf8_check_full(stream->buffer, count))
 131                 return 0;
 132
 133             stream->buffer[count] = '\0';
 134         }
 135         else
 136             stream->buffer[1] = '\0';
 137     }
 138
 139     return (char)stream->buffer[stream->buffer_pos++];
 140 }
 141
 142 static void stream_unget(stream_t *stream, char c)
 143 {
 144     assert(stream->buffer_pos > 0);
 145     stream->buffer_pos--;
 146     assert(stream->buffer[stream->buffer_pos] == (unsigned char)c);
 147 }
 148
 149
 150 static int lex_get(lex_t *lex)
 151 {
 152     return stream_get(&lex->stream);
 153 }
 154
 155 static int lex_eof(lex_t *lex)
 156 {
 157     return lex->stream.eof(lex->stream.data);
 158 }
 159
 160 static void lex_save(lex_t *lex, char c)
 161 {
 162     strbuffer_append_byte(&lex->saved_text, c);
 163 }
 164
 165 static int lex_get_save(lex_t *lex)
 166 {
 167     char c = stream_get(&lex->stream);
 168     lex_save(lex, c);
 169     return c;
 170 }
 171
 172 static void lex_unget_unsave(lex_t *lex, char c)
 173 {
 174     char d;
 175     stream_unget(&lex->stream, c);
 176     d = strbuffer_pop(&lex->saved_text);
 177     assert(c == d);
 178 }
 179
 180 static void lex_scan_string(lex_t *lex)
 181 {
 182     char c;
 183     const char *p;
 184     char *t;
 185
 186     lex->token = TOKEN_INVALID;
 187
 188     /* skip the " */
 189     c = lex_get_save(lex);
 190
 191     while(c != '"') {
 192         if(c == EOF && lex_eof(lex))
 193             goto out;
 194
 195         else if(0 <= c && c <= 0x1F) {
 196             /* control character */
 197             lex_unget_unsave(lex, c);
 198             goto out;
 199         }
 200
 201         else if(c == '\\') {
 202             c = lex_get_save(lex);
 203             if(c == 'u') {
 204                 c = lex_get_save(lex);
 205                 for(int i = 0; i < 4; i++) {
 206                     if(!isxdigit(c)) {
 207                         lex_unget_unsave(lex, c);
 208                         goto out;
 209                     }
 210                     c = lex_get_save(lex);
 211                 }
 212             }
 213             else if(c == '"' || c == '\\' || c == '/' || c == 'b' ||
 214                     c == 'f' || c == 'n' || c == 'r' || c == 't')
 215                 c = lex_get_save(lex);
 216             else {
 217                 lex_unget_unsave(lex, c);
 218                 goto out;
 219             }
 220         }
 221         else
 222             c = lex_get_save(lex);
 223     }
 224
 225     /* the actual value is at most of the same length as the source
 226        string, because:
 227          - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
 228          - a single \uXXXX escape (length 6) is converted to at most 3 bytes
 229          - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
 230            are converted to 4 bytes
 231     */
 232     lex->value.string = malloc(lex->saved_text.length + 1);
 233     if(!lex->value.string) {
 234         /* this is not very nice, since TOKEN_INVALID is returned */
 235         goto out;
 236     }
 237
 238     /* the target */
 239     t = lex->value.string;
 240
 241     /* + 1 to skip the " */
 242     p = strbuffer_value(&lex->saved_text) + 1;
 243
 244     while(*p != '"') {
 245         if(*p == '\\') {
 246             p++;
 247             if(*p == 'u') {
 248                 /* TODO: \uXXXX not supported yet */
 249                 free(lex->value.string);
 250                 lex->value.string = NULL;
 251                 goto out;
 252             } else {
 253                 switch(*p) {
 254                     case '"': case '\\': case '/':
 255                         *t = *p; break;
 256                     case 'b': *t = '\b'; break;
 257                     case 'f': *t = '\f'; break;
 258                     case 'n': *t = '\n'; break;
 259                     case 'r': *t = '\r'; break;
 260                     case 't': *t = '\t'; break;
 261                     default: assert(0);
 262                 }
 263             }
 264         }
 265         else
 266             *t = *p;
 267
 268         t++;
 269         p++;
 270     }
 271     *t = '\0';
 272     lex->token = TOKEN_STRING;
 273
 274 out:
 275     return;
 276 }
 277
 278 static void lex_scan_number(lex_t *lex, char c)
 279 {
 280     const char *saved_text;
 281     char *end;
 282
 283     lex->token = TOKEN_INVALID;
 284
 285     if(c == '-')
 286         c = lex_get_save(lex);
 287
 288     if(c == '0') {
 289         c = lex_get_save(lex);
 290         if(isdigit(c)) {
 291             lex_unget_unsave(lex, c);
 292             goto out;
 293         }
 294     }
 295     else /* c != '0' */ {
 296         c = lex_get_save(lex);
 297         while(isdigit(c))
 298             c = lex_get_save(lex);
 299     }
 300
 301     if(c != '.' && c != 'E' && c != 'e') {
 302         lex_unget_unsave(lex, c);
 303         lex->token = TOKEN_INTEGER;
 304
 305         saved_text = strbuffer_value(&lex->saved_text);
 306         lex->value.integer = strtol(saved_text, &end, 10);
 307         assert(end == saved_text + lex->saved_text.length);
 308
 309         return;
 310     }
 311
 312     if(c == '.') {
 313         c = lex_get(lex);
 314         if(!isdigit(c))
 315             goto out;
 316         lex_save(lex, c);
 317
 318         c = lex_get_save(lex);
 319         while(isdigit(c))
 320             c = lex_get_save(lex);
 321     }
 322
 323     if(c == 'E' || c == 'e') {
 324         c = lex_get_save(lex);
 325         if(c == '+' || c == '-')
 326             c = lex_get_save(lex);
 327
 328         if(!isdigit(c)) {
 329             lex_unget_unsave(lex, c);
 330             goto out;
 331         }
 332
 333         c = lex_get_save(lex);
 334         while(isdigit(c))
 335             c = lex_get_save(lex);
 336     }
 337
 338     lex_unget_unsave(lex, c);
 339     lex->token = TOKEN_REAL;
 340
 341     saved_text = strbuffer_value(&lex->saved_text);
 342     lex->value.real = strtod(saved_text, &end);
 343     assert(end == saved_text + lex->saved_text.length);
 344
 345 out:
 346     return;
 347 }
 348
 349 static int lex_scan(lex_t *lex)
 350 {
 351     char c;
 352
 353     strbuffer_clear(&lex->saved_text);
 354
 355     if(lex->token == TOKEN_STRING) {
 356       free(lex->value.string);
 357       lex->value.string = NULL;
 358     }
 359
 360     c = lex_get(lex);
 361     while(c == ' ' || c == '\t' || c == '\n' || c == '\r')
 362     {
 363         if(c == '\n')
 364             lex->line++;
 365
 366         c = lex_get(lex);
 367     }
 368
 369     if(c == EOF && lex_eof(lex)) {
 370         lex->token = TOKEN_EOF;
 371         goto out;
 372     }
 373
 374     lex_save(lex, c);
 375
 376     if(c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
 377         lex->token = c;
 378
 379     else if(c == '"')
 380         lex_scan_string(lex);
 381
 382     else if(isdigit(c) || c == '-')
 383         lex_scan_number(lex, c);
 384
 385     else if(isupper(c) || islower(c)) {
 386         /* eat up the whole identifier for clearer error messages */
 387         const char *saved_text;
 388
 389         c = lex_get_save(lex);
 390         while(isupper(c) || islower(c))
 391             c = lex_get_save(lex);
 392         lex_unget_unsave(lex, c);
 393
 394         saved_text = strbuffer_value(&lex->saved_text);
 395
 396         if(strcmp(saved_text, "true") == 0)
 397             lex->token = TOKEN_TRUE;
 398         else if(strcmp(saved_text, "false") == 0)
 399             lex->token = TOKEN_FALSE;
 400         else if(strcmp(saved_text, "null") == 0)
 401             lex->token = TOKEN_NULL;
 402         else
 403             lex->token = TOKEN_INVALID;
 404     }
 405
 406     else
 407         lex->token = TOKEN_INVALID;
 408
 409 out:
 410     return lex->token;
 411 }
 412
 413 static int lex_init(lex_t *lex, get_func get, eof_func eof, void *data)
 414 {
 415     stream_init(&lex->stream, get, eof, data);
 416     if(strbuffer_init(&lex->saved_text))
 417         return -1;
 418
 419     lex->token = TOKEN_INVALID;
 420     lex->line = 1;
 421
 422     return 0;
 423 }
 424
 425 static void lex_close(lex_t *lex)
 426 {
 427     if(lex->token == TOKEN_STRING)
 428         free(lex->value.string);
 429 }
 430
 431
 432 /*** parser ***/
 433
 434 static json_t *parse_value(lex_t *lex, json_error_t *error);
 435
 436 static json_t *parse_object(lex_t *lex, json_error_t *error)
 437 {
 438     json_t *object = json_object();
 439     if(!object)
 440         return NULL;
 441
 442     lex_scan(lex);
 443     if(lex->token == '}')
 444         return object;
 445
 446     while(1) {
 447         char *key;
 448         json_t *value;
 449
 450         if(lex->token != TOKEN_STRING) {
 451             error_set(error, lex, "string or '}' expected");
 452             goto error;
 453         }
 454
 455         key = strdup(lex->value.string);
 456         if(!key)
 457             return NULL;
 458
 459         lex_scan(lex);
 460         if(lex->token != ':') {
 461             free(key);
 462             error_set(error, lex, "':' expected");
 463             goto error;
 464         }
 465
 466         lex_scan(lex);
 467         value = parse_value(lex, error);
 468         if(!value) {
 469             free(key);
 470             goto error;
 471         }
 472
 473         if(json_object_set_nocheck(object, key, value)) {
 474             free(key);
 475             json_decref(value);
 476             goto error;
 477         }
 478
 479         json_decref(value);
 480         free(key);
 481
 482         lex_scan(lex);
 483         if(lex->token != ',')
 484             break;
 485
 486         lex_scan(lex);
 487     }
 488
 489     if(lex->token != '}') {
 490         error_set(error, lex, "'}' expected");
 491         goto error;
 492     }
 493
 494     return object;
 495
 496 error:
 497     json_decref(object);
 498     return NULL;
 499 }
 500
 501 static json_t *parse_array(lex_t *lex, json_error_t *error)
 502 {
 503     json_t *array = json_array();
 504     if(!array)
 505         return NULL;
 506
 507     lex_scan(lex);
 508     if(lex->token == ']')
 509         return array;
 510
 511     while(lex->token) {
 512         json_t *elem = parse_value(lex, error);
 513         if(!elem)
 514             goto error;
 515
 516         if(json_array_append(array, elem)) {
 517             json_decref(elem);
 518             goto error;
 519         }
 520         json_decref(elem);
 521
 522         lex_scan(lex);
 523         if(lex->token != ',')
 524             break;
 525
 526         lex_scan(lex);
 527     }
 528
 529     if(lex->token != ']') {
 530         error_set(error, lex, "']' expected");
 531         goto error;
 532     }
 533
 534     return array;
 535
 536 error:
 537     json_decref(array);
 538     return NULL;
 539 }
 540
 541 static json_t *parse_value(lex_t *lex, json_error_t *error)
 542 {
 543     json_t *json;
 544
 545     switch(lex->token) {
 546         case TOKEN_STRING: {
 547             json = json_string_nocheck(lex->value.string);
 548             break;
 549         }
 550
 551         case TOKEN_INTEGER: {
 552             json = json_integer(lex->value.integer);
 553             break;
 554         }
 555
 556         case TOKEN_REAL: {
 557             json = json_real(lex->value.real);
 558             break;
 559         }
 560
 561         case TOKEN_TRUE:
 562             json = json_true();
 563             break;
 564
 565         case TOKEN_FALSE:
 566             json = json_false();
 567             break;
 568
 569         case TOKEN_NULL:
 570             json = json_null();
 571             break;
 572
 573         case '{':
 574           json = parse_object(lex, error);
 575             break;
 576
 577         case '[':
 578             json = parse_array(lex, error);
 579             break;
 580
 581         case TOKEN_INVALID:
 582             error_set(error, lex, "invalid token");
 583             return NULL;
 584
 585         default:
 586             error_set(error, lex, "unexpected token");
 587             return NULL;
 588     }
 589
 590     if(!json)
 591         return NULL;
 592
 593     return json;
 594 }
 595
 596 json_t *parse_json(lex_t *lex, json_error_t *error)
 597 {
 598     lex_scan(lex);
 599
 600     if(lex->token != '[' && lex->token != '{') {
 601         error_set(error, lex, "'[' or '{' expected");
 602         return NULL;
 603     }
 604
 605     return parse_value(lex, error);
 606 }
 607
 608 json_t *json_load(const char *path, json_error_t *error)
 609 {
 610     json_t *result;
 611     FILE *fp;
 612
 613     fp = fopen(path, "r");
 614     if(!fp)
 615     {
 616         error_set(error, NULL, "unable to open %s: %s",
 617                   path, strerror(errno));
 618         return NULL;
 619     }
 620
 621     result = json_loadf(fp, error);
 622
 623     fclose(fp);
 624     return result;
 625 }
 626
 627 typedef struct
 628 {
 629     const char *data;
 630     int pos;
 631 } string_data_t;
 632
 633 static int string_get(void *data)
 634 {
 635     char c;
 636     string_data_t *stream = (string_data_t *)data;
 637     c = stream->data[stream->pos++];
 638     if(c == '\0')
 639         return EOF;
 640     else
 641         return c;
 642 }
 643
 644 static int string_eof(void *data)
 645 {
 646     string_data_t *stream = (string_data_t *)data;
 647     return (stream->data[stream->pos] == '\0');
 648 }
 649
 650 json_t *json_loads(const char *string, json_error_t *error)
 651 {
 652     lex_t lex;
 653     json_t *result;
 654
 655     string_data_t stream_data = {
 656         .data = string,
 657         .pos = 0
 658     };
 659
 660     if(lex_init(&lex, string_get, string_eof, (void *)&stream_data))
 661         return NULL;
 662
 663     result = parse_json(&lex, error);
 664     if(!result)
 665         goto out;
 666
 667     lex_scan(&lex);
 668     if(lex.token != TOKEN_EOF) {
 669         error_set(error, &lex, "end of file expected");
 670         json_decref(result);
 671         result = NULL;
 672     }
 673
 674 out:
 675     lex_close(&lex);
 676     return result;
 677 }
 678
 679 json_t *json_loadf(FILE *input, json_error_t *error)
 680 {
 681     lex_t lex;
 682     json_t *result;
 683
 684     if(lex_init(&lex, (get_func)fgetc, (eof_func)feof, input))
 685         return NULL;
 686
 687     result = parse_json(&lex, error);
 688
 689     lex_close(&lex);
 690     return result;
 691 }