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