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