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         json_int_t 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 static void
 117 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((unsigned char)c >= 0x80 && c != (char)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, NULL))
 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 int32_t decode_unicode_escape(const char *str)
 226 {
 227     int i;
 228     int32_t 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 == (char)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((unsigned char)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                 int32_t 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                         int32_t value2 = decode_unicode_escape(++p);
 338                         p += 5;
 339
 340                         if(0xDC00 <= value2 && value2 <= 0xDFFF) {
 341                             /* valid second surrogate */
 342                             value =
 343                                 ((value - 0xD800) << 10) +
 344                                 (value2 - 0xDC00) +
 345                                 0x10000;
 346                         }
 347                         else {
 348                             /* invalid second surrogate */
 349                             error_set(error, lex,
 350                                       "invalid Unicode '\\u%04X\\u%04X'",
 351                                       value, value2);
 352                             goto out;
 353                         }
 354                     }
 355                     else {
 356                         /* no second surrogate */
 357                         error_set(error, lex, "invalid Unicode '\\u%04X'",
 358                                   value);
 359                         goto out;
 360                     }
 361                 }
 362                 else if(0xDC00 <= value && value <= 0xDFFF) {
 363                     error_set(error, lex, "invalid Unicode '\\u%04X'", value);
 364                     goto out;
 365                 }
 366                 else if(value == 0)
 367                 {
 368                     error_set(error, lex, "\\u0000 is not allowed");
 369                     goto out;
 370                 }
 371
 372                 if(utf8_encode(value, buffer, &length))
 373                     assert(0);
 374
 375                 memcpy(t, buffer, length);
 376                 t += length;
 377             }
 378             else {
 379                 switch(*p) {
 380                     case '"': case '\\': case '/':
 381                         *t = *p; break;
 382                     case 'b': *t = '\b'; break;
 383                     case 'f': *t = '\f'; break;
 384                     case 'n': *t = '\n'; break;
 385                     case 'r': *t = '\r'; break;
 386                     case 't': *t = '\t'; break;
 387                     default: assert(0);
 388                 }
 389                 t++;
 390                 p++;
 391             }
 392         }
 393         else
 394             *(t++) = *(p++);
 395     }
 396     *t = '\0';
 397     lex->token = TOKEN_STRING;
 398     return;
 399
 400 out:
 401     free(lex->value.string);
 402 }
 403
 404 #if JSON_INTEGER_IS_LONG_LONG
 405 #define json_strtoint     strtoll
 406 #else
 407 #define json_strtoint     strtol
 408 #endif
 409
 410 static int lex_scan_number(lex_t *lex, char c, json_error_t *error)
 411 {
 412     const char *saved_text;
 413     char *end;
 414     double value;
 415
 416     lex->token = TOKEN_INVALID;
 417
 418     if(c == '-')
 419         c = lex_get_save(lex, error);
 420
 421     if(c == '0') {
 422         c = lex_get_save(lex, error);
 423         if(isdigit(c)) {
 424             lex_unget_unsave(lex, c);
 425             goto out;
 426         }
 427     }
 428     else if(isdigit(c)) {
 429         c = lex_get_save(lex, error);
 430         while(isdigit(c))
 431             c = lex_get_save(lex, error);
 432     }
 433     else {
 434       lex_unget_unsave(lex, c);
 435       goto out;
 436     }
 437
 438     if(c != '.' && c != 'E' && c != 'e') {
 439         json_int_t value;
 440
 441         lex_unget_unsave(lex, c);
 442
 443         saved_text = strbuffer_value(&lex->saved_text);
 444
 445         errno = 0;
 446         value = json_strtoint(saved_text, &end, 10);
 447         if(errno == ERANGE) {
 448             if(value < 0)
 449                 error_set(error, lex, "too big negative integer");
 450             else
 451                 error_set(error, lex, "too big integer");
 452             goto out;
 453         }
 454
 455         assert(end == saved_text + lex->saved_text.length);
 456
 457         lex->token = TOKEN_INTEGER;
 458         lex->value.integer = value;
 459         return 0;
 460     }
 461
 462     if(c == '.') {
 463         c = lex_get(lex, error);
 464         if(!isdigit(c))
 465             goto out;
 466         lex_save(lex, c);
 467
 468         c = lex_get_save(lex, error);
 469         while(isdigit(c))
 470             c = lex_get_save(lex, error);
 471     }
 472
 473     if(c == 'E' || c == 'e') {
 474         c = lex_get_save(lex, error);
 475         if(c == '+' || c == '-')
 476             c = lex_get_save(lex, error);
 477
 478         if(!isdigit(c)) {
 479             lex_unget_unsave(lex, c);
 480             goto out;
 481         }
 482
 483         c = lex_get_save(lex, error);
 484         while(isdigit(c))
 485             c = lex_get_save(lex, error);
 486     }
 487
 488     lex_unget_unsave(lex, c);
 489
 490     saved_text = strbuffer_value(&lex->saved_text);
 491     value = strtod(saved_text, &end);
 492     assert(end == saved_text + lex->saved_text.length);
 493
 494     if(errno == ERANGE && value != 0) {
 495         error_set(error, lex, "real number overflow");
 496         goto out;
 497     }
 498
 499     lex->token = TOKEN_REAL;
 500     lex->value.real = value;
 501     return 0;
 502
 503 out:
 504     return -1;
 505 }
 506
 507 static int lex_scan(lex_t *lex, json_error_t *error)
 508 {
 509     char c;
 510
 511     strbuffer_clear(&lex->saved_text);
 512
 513     if(lex->token == TOKEN_STRING) {
 514         free(lex->value.string);
 515         lex->value.string = NULL;
 516     }
 517
 518     c = lex_get(lex, error);
 519     while(c == ' ' || c == '\t' || c == '\n' || c == '\r')
 520     {
 521         if(c == '\n')
 522             lex->line++;
 523
 524         c = lex_get(lex, error);
 525     }
 526
 527     if(c == (char)EOF) {
 528         if(lex_eof(lex))
 529             lex->token = TOKEN_EOF;
 530         else
 531             lex->token = TOKEN_INVALID;
 532         goto out;
 533     }
 534
 535     lex_save(lex, c);
 536
 537     if(c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
 538         lex->token = c;
 539
 540     else if(c == '"')
 541         lex_scan_string(lex, error);
 542
 543     else if(isdigit(c) || c == '-') {
 544         if(lex_scan_number(lex, c, error))
 545             goto out;
 546     }
 547
 548     else if(isupper(c) || islower(c)) {
 549         /* eat up the whole identifier for clearer error messages */
 550         const char *saved_text;
 551
 552         c = lex_get_save(lex, error);
 553         while(isupper(c) || islower(c))
 554             c = lex_get_save(lex, error);
 555         lex_unget_unsave(lex, c);
 556
 557         saved_text = strbuffer_value(&lex->saved_text);
 558
 559         if(strcmp(saved_text, "true") == 0)
 560             lex->token = TOKEN_TRUE;
 561         else if(strcmp(saved_text, "false") == 0)
 562             lex->token = TOKEN_FALSE;
 563         else if(strcmp(saved_text, "null") == 0)
 564             lex->token = TOKEN_NULL;
 565         else
 566             lex->token = TOKEN_INVALID;
 567     }
 568
 569     else {
 570         /* save the rest of the input UTF-8 sequence to get an error
 571            message of valid UTF-8 */
 572         lex_save_cached(lex);
 573         lex->token = TOKEN_INVALID;
 574     }
 575
 576 out:
 577     return lex->token;
 578 }
 579
 580 static char *lex_steal_string(lex_t *lex)
 581 {
 582     char *result = NULL;
 583     if(lex->token == TOKEN_STRING)
 584     {
 585         result = lex->value.string;
 586         lex->value.string = NULL;
 587     }
 588     return result;
 589 }
 590
 591 static int lex_init(lex_t *lex, get_func get, eof_func eof, void *data)
 592 {
 593     stream_init(&lex->stream, get, eof, data);
 594     if(strbuffer_init(&lex->saved_text))
 595         return -1;
 596
 597     lex->token = TOKEN_INVALID;
 598     lex->line = 1;
 599
 600     return 0;
 601 }
 602
 603 static void lex_close(lex_t *lex)
 604 {
 605     if(lex->token == TOKEN_STRING)
 606         free(lex->value.string);
 607     strbuffer_close(&lex->saved_text);
 608 }
 609
 610
 611 /*** parser ***/
 612
 613 static json_t *parse_value(lex_t *lex, json_error_t *error);
 614
 615 static json_t *parse_object(lex_t *lex, json_error_t *error)
 616 {
 617     json_t *object = json_object();
 618     if(!object)
 619         return NULL;
 620
 621     lex_scan(lex, error);
 622     if(lex->token == '}')
 623         return object;
 624
 625     while(1) {
 626         char *key;
 627         json_t *value;
 628
 629         if(lex->token != TOKEN_STRING) {
 630             error_set(error, lex, "string or '}' expected");
 631             goto error;
 632         }
 633
 634         key = lex_steal_string(lex);
 635         if(!key)
 636             return NULL;
 637
 638         lex_scan(lex, error);
 639         if(lex->token != ':') {
 640             free(key);
 641             error_set(error, lex, "':' expected");
 642             goto error;
 643         }
 644
 645         lex_scan(lex, error);
 646         value = parse_value(lex, error);
 647         if(!value) {
 648             free(key);
 649             goto error;
 650         }
 651
 652         if(json_object_set_nocheck(object, key, value)) {
 653             free(key);
 654             json_decref(value);
 655             goto error;
 656         }
 657
 658         json_decref(value);
 659         free(key);
 660
 661         lex_scan(lex, error);
 662         if(lex->token != ',')
 663             break;
 664
 665         lex_scan(lex, error);
 666     }
 667
 668     if(lex->token != '}') {
 669         error_set(error, lex, "'}' expected");
 670         goto error;
 671     }
 672
 673     return object;
 674
 675 error:
 676     json_decref(object);
 677     return NULL;
 678 }
 679
 680 static json_t *parse_array(lex_t *lex, json_error_t *error)
 681 {
 682     json_t *array = json_array();
 683     if(!array)
 684         return NULL;
 685
 686     lex_scan(lex, error);
 687     if(lex->token == ']')
 688         return array;
 689
 690     while(lex->token) {
 691         json_t *elem = parse_value(lex, error);
 692         if(!elem)
 693             goto error;
 694
 695         if(json_array_append(array, elem)) {
 696             json_decref(elem);
 697             goto error;
 698         }
 699         json_decref(elem);
 700
 701         lex_scan(lex, error);
 702         if(lex->token != ',')
 703             break;
 704
 705         lex_scan(lex, error);
 706     }
 707
 708     if(lex->token != ']') {
 709         error_set(error, lex, "']' expected");
 710         goto error;
 711     }
 712
 713     return array;
 714
 715 error:
 716     json_decref(array);
 717     return NULL;
 718 }
 719
 720 static json_t *parse_value(lex_t *lex, json_error_t *error)
 721 {
 722     json_t *json;
 723
 724     switch(lex->token) {
 725         case TOKEN_STRING: {
 726             json = json_string_nocheck(lex->value.string);
 727             break;
 728         }
 729
 730         case TOKEN_INTEGER: {
 731             json = json_integer(lex->value.integer);
 732             break;
 733         }
 734
 735         case TOKEN_REAL: {
 736             json = json_real(lex->value.real);
 737             break;
 738         }
 739
 740         case TOKEN_TRUE:
 741             json = json_true();
 742             break;
 743
 744         case TOKEN_FALSE:
 745             json = json_false();
 746             break;
 747
 748         case TOKEN_NULL:
 749             json = json_null();
 750             break;
 751
 752         case '{':
 753             json = parse_object(lex, error);
 754             break;
 755
 756         case '[':
 757             json = parse_array(lex, error);
 758             break;
 759
 760         case TOKEN_INVALID:
 761             error_set(error, lex, "invalid token");
 762             return NULL;
 763
 764         default:
 765             error_set(error, lex, "unexpected token");
 766             return NULL;
 767     }
 768
 769     if(!json)
 770         return NULL;
 771
 772     return json;
 773 }
 774
 775 static json_t *parse_json(lex_t *lex, json_error_t *error)
 776 {
 777     error_init(error);
 778
 779     lex_scan(lex, error);
 780     if(lex->token != '[' && lex->token != '{') {
 781         error_set(error, lex, "'[' or '{' expected");
 782         return NULL;
 783     }
 784
 785     return parse_value(lex, error);
 786 }
 787
 788 typedef struct
 789 {
 790     const char *data;
 791     int pos;
 792 } string_data_t;
 793
 794 static int string_get(void *data)
 795 {
 796     char c;
 797     string_data_t *stream = (string_data_t *)data;
 798     c = stream->data[stream->pos];
 799     if(c == '\0')
 800         return EOF;
 801     else
 802     {
 803         stream->pos++;
 804         return c;
 805     }
 806 }
 807
 808 static int string_eof(void *data)
 809 {
 810     string_data_t *stream = (string_data_t *)data;
 811     return (stream->data[stream->pos] == '\0');
 812 }
 813
 814 json_t *json_loads(const char *string, size_t flags, json_error_t *error)
 815 {
 816     lex_t lex;
 817     json_t *result;
 818     (void)flags; /* unused */
 819
 820     string_data_t stream_data = {string, 0};
 821
 822     if(lex_init(&lex, string_get, string_eof, (void *)&stream_data))
 823         return NULL;
 824
 825     result = parse_json(&lex, error);
 826     if(!result)
 827         goto out;
 828
 829     lex_scan(&lex, error);
 830     if(lex.token != TOKEN_EOF) {
 831         error_set(error, &lex, "end of file expected");
 832         json_decref(result);
 833         result = NULL;
 834     }
 835
 836 out:
 837     lex_close(&lex);
 838     return result;
 839 }
 840
 841 json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
 842 {
 843     lex_t lex;
 844     json_t *result;
 845     (void)flags; /* unused */
 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, size_t flags, 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, flags, error);
 882
 883     fclose(fp);
 884     return result;
 885 }