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