application/json.c

   1 /*
   2  * Copyright 2022 Olaf Wintermann
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  20  * DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26
  27 #include "json.h"
  28
  29 /*
  30  * RFC 8259
  31  * https://tools.ietf.org/html/rfc8259
  32  */
  33
  34 #define PARSER_STATES_ALLOC 32
  35
  36 JSONParser* json_parser_new(void) {
  37     JSONParser *parser = calloc(1, sizeof(JSONParser));
  38     if(!parser) {
  39         return NULL;
  40     }
  41
  42     parser->states_alloc = PARSER_STATES_ALLOC;
  43     parser->states = calloc(PARSER_STATES_ALLOC, sizeof(int));
  44     if(!parser->states) {
  45         free(parser);
  46         return NULL;
  47     }
  48
  49     parser->reader_array_alloc = 8;
  50
  51     return parser;
  52 }
  53
  54 void json_parser_fill(JSONParser *p, const char *buf, size_t size) {
  55     p->buffer = buf;
  56     p->size = size;
  57     p->pos = 0;
  58 }
  59
  60
  61 static JSONToken nulltoken = { JSON_NO_TOKEN, NULL, 0, 0 };
  62
  63 int token_append(JSONToken *token, const char *buf, size_t len) {
  64     if(len == 0) {
  65         return 0;
  66     }
  67
  68     size_t newlen = token->length + len;
  69     if(token->alloc < newlen) {
  70         char *newbuf = realloc(
  71                 token->alloc == 0 ? NULL : (char*)token->content,
  72                 newlen);
  73         if(!newbuf) {
  74             return 1;
  75         }
  76         token->content = newbuf;
  77         token->alloc = newlen;
  78     }
  79
  80     memcpy((char*)token->content+token->length, buf, len);
  81     token->length = newlen;
  82     return 0;
  83 }
  84
  85 JSONToken get_content(JSONParser *p, size_t start, size_t end) {
  86     JSONToken token = nulltoken;
  87     size_t part2 = end - start;
  88     if(p->uncompleted.tokentype == JSON_NO_TOKEN) {
  89         token.content = p->buffer + start;
  90         token.length = part2;
  91     } else if(part2 == 0) {
  92         token = p->uncompleted;
  93     } else {
  94         if(token_append(&p->uncompleted, p->buffer+start, end - start)) {
  95             return nulltoken;
  96         }
  97         token = p->uncompleted;
  98     }
  99     p->uncompleted = nulltoken;
 100     return token;
 101 }
 102
 103 int token_isliteral(const char *content, size_t length) {
 104     if(length == 4) {
 105         if(!memcmp(content, "true", 4)) {
 106             return 1;
 107         } else if(!memcmp(content, "null", 4)) {
 108             return 1;
 109         }
 110     } else if(length == 5 && !memcmp(content, "false", 5)) {
 111         return 1;
 112     }
 113     return 0;
 114 }
 115
 116 static int num_isexp(const char *content, size_t length, size_t pos) {
 117     if(pos >= length) {
 118         return 0;
 119     }
 120
 121     int ok = 0;
 122     for(size_t i=pos;i<length;i++) {
 123         int c = content[i];
 124         if(isdigit(c)) {
 125             ok = 1;
 126         } else if(i == pos) {
 127             if(!(c == '+' || c == '-')) {
 128                 return 0;
 129             }
 130         } else {
 131             return 0;
 132         }
 133     }
 134
 135     return ok;
 136 }
 137
 138 JSONTokenType token_numbertype(const char *content, size_t length) {
 139     if(length == 0) return JSON_TOKEN_ERROR;
 140
 141     if(content[0] != '-' && !isdigit(content[0])) {
 142         return JSON_TOKEN_ERROR;
 143     }
 144
 145     JSONTokenType type = JSON_TOKEN_INTEGER;
 146     for(size_t i=1;i<length;i++) {
 147         if(content[i] == '.') {
 148             if(type == JSON_TOKEN_NUMBER) {
 149                 return JSON_TOKEN_ERROR; // more than one decimal separator
 150             }
 151             type = JSON_TOKEN_NUMBER;
 152         } else if(content[i] == 'e' || content[i] == 'E') {
 153             return num_isexp(content, length, i+1) ? JSON_TOKEN_NUMBER : JSON_TOKEN_ERROR;
 154         } else if(!isdigit(content[i])) {
 155             return JSON_TOKEN_ERROR; // char is not a diget, decimal separator or exponent sep
 156         }
 157     }
 158
 159     return type;
 160 }
 161
 162 JSONToken get_token(JSONParser *p, size_t start, size_t end) {
 163     JSONToken token = get_content(p, start, end);
 164     if(token_isliteral(token.content, token.length)) {
 165         token.tokentype = JSON_TOKEN_LITERAL;
 166     } else {
 167         token.tokentype = token_numbertype(token.content, token.length);
 168     }
 169     p->pos = end;
 170     return token;
 171 }
 172
 173 static JSONTokenType char2ttype(char c) {
 174     switch(c) {
 175         case '[': {
 176             return JSON_TOKEN_BEGIN_ARRAY;
 177         }
 178         case '{': {
 179             return JSON_TOKEN_BEGIN_OBJECT;
 180         }
 181         case ']': {
 182             return JSON_TOKEN_END_ARRAY;
 183         }
 184         case '}': {
 185             return JSON_TOKEN_END_OBJECT;
 186         }
 187         case ':': {
 188             return JSON_TOKEN_NAME_SEPARATOR;
 189         }
 190         case ',': {
 191             return JSON_TOKEN_VALUE_SEPARATOR;
 192         }
 193         case '"': {
 194             return JSON_TOKEN_STRING;
 195         }
 196         default: {
 197             if(isspace(c)) {
 198                 return JSON_TOKEN_SPACE;
 199             }
 200         }
 201     }
 202     return JSON_NO_TOKEN;
 203 }
 204
 205 JSONToken json_parser_next_token(JSONParser *p) {
 206     // current token type and start index
 207     JSONTokenType ttype = p->uncompleted.tokentype;
 208     size_t token_start = p->pos;
 209
 210     for(size_t i=p->pos;i<p->size;i++) {
 211         char c = p->buffer[i];
 212         if(ttype != JSON_TOKEN_STRING) {
 213             // currently non-string token
 214
 215             JSONTokenType ctype = char2ttype(c); // start of new token?
 216
 217             if(ttype == JSON_NO_TOKEN) {
 218                 if(ctype == JSON_TOKEN_SPACE) {
 219                     continue;
 220                 } else if(ctype == JSON_TOKEN_STRING) {
 221                     // begin string
 222                     ttype = JSON_TOKEN_STRING;
 223                     token_start = i;
 224                 } else if(ctype != JSON_NO_TOKEN) {
 225                     // single-char token
 226                     p->pos = i + 1;
 227                     JSONToken token = {  ctype, NULL, 0, 0};
 228                     return token;
 229                 } else {
 230                     ttype = JSON_TOKEN_LITERAL; // number or literal
 231                     token_start = i;
 232                 }
 233             } else {
 234                 // finish token
 235                 if(ctype != JSON_NO_TOKEN) {
 236                     return get_token(p, token_start, i);
 237                 }
 238             }
 239         } else {
 240             // currently inside a string
 241             if(!p->tokenizer_escape) {
 242                 if(c == '"') {
 243                     JSONToken ret = get_content(p, token_start, i+1);
 244                     ret.tokentype = JSON_TOKEN_STRING;
 245                     p->pos = i+1;
 246                     return ret;
 247                 } else if(c == '\\') {
 248                     p->tokenizer_escape = 1;
 249                 }
 250             } else {
 251                 p->tokenizer_escape = 0;
 252             }
 253         }
 254     }
 255
 256     if(ttype != JSON_NO_TOKEN) {
 257         // uncompleted token
 258         size_t uncompeted_len = p->size - token_start;
 259         if(p->uncompleted.tokentype == JSON_NO_TOKEN) {
 260             // current token is uncompleted
 261             // save current token content in p->uncompleted
 262             JSONToken uncompleted;
 263             uncompleted.tokentype = ttype;
 264             uncompleted.length = uncompeted_len;
 265             uncompleted.alloc = uncompeted_len + 16;
 266             char *tmp = malloc(uncompleted.alloc);
 267             if(tmp) {
 268                 memcpy(tmp, p->buffer+token_start, uncompeted_len);
 269                 uncompleted.content = tmp;
 270                 p->uncompleted = uncompleted;
 271             } else {
 272                 p->error = 1;
 273             }
 274         } else {
 275             // previously we also had an uncompleted token
 276             // combine the uncompleted token with the current token
 277             if(token_append(&p->uncompleted, p->buffer+token_start, uncompeted_len)) {
 278                 p->error = 1;
 279             }
 280         }
 281     }
 282
 283     JSONToken ret = { JSON_NO_TOKEN, NULL, 0, 0};
 284     return ret;
 285 }
 286
 287 static int create_string(JSONToken token, JSONValue **value) {
 288     JSONValue *v = malloc(sizeof(JSONValue));
 289     if(!v) {
 290         *value = NULL;
 291         return -1;
 292     }
 293     v->type = JSON_STRING;
 294
 295     char *str = malloc(token.length+1);
 296     if(!str) {
 297         free(v);
 298         *value = NULL;
 299         return -1;
 300     }
 301     memcpy(str, token.content, token.length);
 302     str[token.length] = 0;
 303
 304     v->type = JSON_STRING;
 305     v->value.string.string = str;
 306     v->value.string.length = token.length;
 307     *value = v;
 308     return 0;
 309 }
 310
 311 typedef struct json_ustr {
 312     char *ptr;
 313     size_t length;
 314 } json_ustr;
 315 static json_ustr unescape_string(const char *str, size_t len) {
 316     char *newstr = malloc(len+1);
 317     if(!newstr) {
 318         json_ustr r;
 319         r.ptr = NULL;
 320         r.length = 0;
 321         return r;
 322     }
 323
 324     int j = 0;
 325     int u = 0;
 326     for(int i=1;i<len-1;i++) {
 327         char c = str[i];
 328         if(!u) {
 329             if(c == '\\') {
 330                 u = 1;
 331             } else {
 332                 newstr[j++] = c;
 333             }
 334         } else {
 335             u = 0;
 336             if(c == 'n') {
 337                 c = '\n';
 338             } else if(c == 't') {
 339                 c = '\t';
 340             }
 341             newstr[j++] = c;
 342         }
 343     }
 344     newstr[j] = 0;
 345
 346     json_ustr r;
 347     r.ptr = newstr;
 348     r.length = j;
 349     return r;
 350 }
 351
 352 static int parse_integer(const char *str, size_t len, int64_t *value) {
 353     char *endptr = NULL;
 354     char buf[32];
 355     if(len > 30) {
 356         return 1;
 357     }
 358     memcpy(buf, str, len);
 359     buf[len] = 0;
 360
 361     long long v = strtoll(buf, &endptr, 10);
 362     if(endptr != &buf[len]) {
 363         return 1;
 364     }
 365     *value = (int64_t)v;
 366
 367     return 0;
 368 }
 369
 370 static int parse_number(const char *str, size_t len, double *value) {
 371     char *endptr = NULL;
 372     char buf[32];
 373     if(len > 30) {
 374         return 1;
 375     }
 376     memcpy(buf, str, len);
 377     buf[len] = 0;
 378
 379     double v = strtod(buf, &endptr);
 380     if(endptr != &buf[len]) {
 381         return 1;
 382     }
 383     *value = v;
 384
 385     return 0;
 386 }
 387
 388 static int add_state(JSONParser *p, int state) {
 389     if(p->nstates >= p->states_alloc) {
 390         p->states_alloc += PARSER_STATES_ALLOC;
 391         p->states = realloc(p->states, p->states_alloc * sizeof(int));
 392         if(!p->states) {
 393             return 1;
 394         }
 395     }
 396     p->states[++p->nstates] = state;
 397     return 0;
 398 }
 399
 400 static void end_elm(JSONParser *p, JSONReaderType type) {
 401     p->reader_type = type;
 402     p->nstates--;
 403 }
 404
 405 #define JP_STATE_VALUE_BEGIN        0
 406 #define JP_STATE_VALUE_BEGIN_OBJ    1
 407 #define JP_STATE_VALUE_BEGIN_AR     2
 408 #define JP_STATE_ARRAY_SEP_OR_CLOSE 3
 409 #define JP_STATE_OBJ_NAME_OR_CLOSE  4
 410 #define JP_STATE_OBJ_NAME           5
 411 #define JP_STATE_OBJ_COLON          6
 412 #define JP_STATE_OBJ_SEP_OR_CLOSE   7
 413
 414 static int next_state_after_value(int current) {
 415     switch(current) {
 416         default: return -1;
 417         // after value JSON complete, expect nothing
 418         case JP_STATE_VALUE_BEGIN: return -1;
 419         // after obj value, expect ',' or '}'
 420         case JP_STATE_VALUE_BEGIN_OBJ: return JP_STATE_OBJ_SEP_OR_CLOSE;
 421         // after array value, expect ',' or ']'
 422         case JP_STATE_VALUE_BEGIN_AR: return JP_STATE_ARRAY_SEP_OR_CLOSE;
 423     }
 424 }
 425
 426 static void clear_valuename(JSONParser *p) {
 427     if(p->value_name) free(p->value_name);
 428     p->value_name = NULL;
 429     p->value_name_len = 0;
 430 }
 431
 432 static void clear_values(JSONParser *p) {
 433     if(p->value_str) free(p->value_str);
 434     p->value_str = NULL;
 435     p->value_str_len = 0;
 436     p->value_int = 0;
 437     p->value_double = 0;
 438 }
 439
 440 int json_read(JSONParser *p) {
 441     int state = p->states[p->nstates];
 442     clear_values(p);
 443     JSONToken token = json_parser_next_token(p);
 444     p->reader_token = token;
 445
 446
 447     p->value_ready = 0;
 448
 449     if(token.tokentype == JSON_NO_TOKEN) {
 450         return 0;
 451     }
 452
 453     int ret = 1;
 454
 455     // 0 JP_STATE_VALUE_BEGIN          value begin
 456     // 1 JP_STATE_VALUE_BEGIN_OBJ      value begin (inside object)
 457     // 2 JP_STATE_VALUE_BEGIN_AR       value begin (inside array)
 458     // 3 JP_STATE_ARRAY_SEP_OR_CLOSE   array, expect separator or arrayclose
 459     // 4 JP_STATE_OBJ_NAME_OR_CLOSE    object, expect name or objclose
 460     // 5 JP_STATE_OBJ_NAME             object, expect name
 461     // 6 JP_STATE_OBJ_COLON            object, expect ':'
 462     // 7 JP_STATE_OBJ_SEP_OR_CLOSE     object, expect separator, objclose
 463
 464     if(state == JP_STATE_VALUE_BEGIN_AR || state == JP_STATE_OBJ_SEP_OR_CLOSE) {
 465         clear_valuename(p);
 466     }
 467
 468     if(state < 3) {
 469         // expect value
 470         p->states[p->nstates] = next_state_after_value(state);
 471         p->value_ready = 1;
 472         switch(token.tokentype) {
 473             case JSON_TOKEN_BEGIN_ARRAY: {
 474                 p->reader_type = JSON_READER_ARRAY_BEGIN;
 475                 if(add_state(p, JP_STATE_VALUE_BEGIN_AR)) return -1;
 476                 return 1;
 477                 //return json_read(p);
 478             }
 479             case JSON_TOKEN_BEGIN_OBJECT: {
 480                 p->reader_type = JSON_READER_OBJECT_BEGIN;
 481                 if(add_state(p, JP_STATE_OBJ_NAME_OR_CLOSE)) return -1;
 482                 return 1;
 483                 //return json_read(p);
 484             }
 485             case JSON_TOKEN_END_ARRAY: {
 486                 p->value_ready = 0;
 487                 end_elm(p, JSON_READER_ARRAY_END);
 488                 break;
 489             }
 490             case JSON_TOKEN_END_OBJECT: {
 491                 p->value_ready = 0;
 492                 end_elm(p, JSON_READER_OBJECT_END);
 493                 break;
 494             }
 495             case JSON_TOKEN_STRING: {
 496                 p->reader_type = JSON_READER_STRING;
 497                 json_ustr str = unescape_string(token.content, token.length);
 498                 if(str.ptr) {
 499                     p->value_str = str.ptr;
 500                     p->value_str_len = str.length;
 501                 } else {
 502                     return -1;
 503                 }
 504                 break;
 505             }
 506             case JSON_TOKEN_INTEGER: {
 507                 p->reader_type = JSON_READER_INTEGER;
 508                 int64_t value;
 509                 if(parse_integer(token.content, token.length, &value)) {
 510                     return -1;
 511                 }
 512                 p->value_int = value;
 513                 p->value_double = (double)value;
 514                 break;
 515             }
 516             case JSON_TOKEN_NUMBER: {
 517                 p->reader_type = JSON_READER_NUMBER;
 518                 double value;
 519                 if(parse_number(token.content, token.length, &value)) {
 520                     return -1;
 521                 }
 522                 p->value_double = value;
 523                 p->value_int = (int64_t)value;
 524                 break;
 525             }
 526             case JSON_TOKEN_LITERAL: {
 527                 p->reader_type = JSON_READER_LITERAL;
 528                 break;
 529             }
 530             default: return -1;
 531         }
 532     } else if(state == JP_STATE_ARRAY_SEP_OR_CLOSE) {
 533         // expect ',' or ']'
 534         if(token.tokentype == JSON_TOKEN_VALUE_SEPARATOR) {
 535             p->states[p->nstates] = JP_STATE_VALUE_BEGIN_AR;
 536             return json_read(p);
 537         } else if(token.tokentype == JSON_TOKEN_END_ARRAY) {
 538             end_elm(p, JSON_READER_ARRAY_END);
 539         } else {
 540             return -1;
 541         }
 542     } else if(state == JP_STATE_OBJ_NAME_OR_CLOSE || state == JP_STATE_OBJ_NAME) {
 543         if(state == JP_STATE_OBJ_NAME_OR_CLOSE && token.tokentype == JSON_TOKEN_END_OBJECT) {
 544             clear_valuename(p);
 545             end_elm(p, JSON_READER_OBJECT_END);
 546         } else {
 547             // expect string
 548             if(token.tokentype != JSON_TOKEN_STRING) return -1;
 549
 550             if(p->value_name) free(p->value_name);
 551             json_ustr valname = unescape_string(token.content, token.length);
 552             p->value_name = valname.ptr;
 553             p->value_name_len = valname.length;
 554
 555             // next state
 556             p->states[p->nstates] = JP_STATE_OBJ_COLON;
 557             return json_read(p);
 558         }
 559     } else if(state == JP_STATE_OBJ_COLON) {
 560         // expect ':'
 561         if(token.tokentype != JSON_TOKEN_NAME_SEPARATOR) return -1;
 562         // next state
 563         p->states[p->nstates] = 1;
 564         return json_read(p);
 565     } else if(state == 7) {
 566         // expect ',' or '}]'
 567         if(token.tokentype == JSON_TOKEN_VALUE_SEPARATOR) {
 568             p->states[p->nstates] = JP_STATE_OBJ_NAME;
 569             return json_read(p);
 570         } else if(token.tokentype == JSON_TOKEN_END_OBJECT) {
 571             end_elm(p, JSON_READER_OBJECT_END);
 572         } else {
 573             return -1;
 574         }
 575     }
 576
 577     return ret;
 578 }
 579
 580
 581 JSONReaderType json_reader_type(JSONParser *p) {
 582     return p->reader_type;
 583 }
 584
 585 const char* json_reader_name(JSONParser *p, size_t *opt_len) {
 586     if(opt_len) *opt_len = p->value_name_len;
 587     return p->value_name;
 588 }
 589
 590 const char* json_reader_string(JSONParser *p, size_t *opt_len) {
 591     if(opt_len) *opt_len = p->value_str_len;
 592
 593     if(p->reader_token.tokentype != JSON_TOKEN_STRING) {
 594         return NULL;
 595     }
 596
 597     return p->value_str;
 598 }
 599
 600 int64_t json_reader_int(JSONParser *p) {
 601     return p->value_int;
 602 }
 603
 604 double json_reader_double(JSONParser *p) {
 605     return p->value_double;
 606 }
 607
 608 int json_reader_isnull(JSONParser *p) {
 609     if(p->reader_token.tokentype == JSON_TOKEN_LITERAL && p->reader_token.length == 4) {
 610         return !memcmp(p->reader_token.content, "null", 4);
 611     }
 612     return 0;
 613 }
 614
 615 JSONLiteralType json_reader_literal(JSONParser *p) {
 616     const char *l = p->reader_token.content;
 617     size_t token_len = p->reader_token.length;
 618     if(token_len == 4 && !memcmp(l, "true", 4)) {
 619         return JSON_TRUE;
 620     } else if(token_len == 5 && !memcmp(l, "false", 5)) {
 621         return JSON_FALSE;
 622     }
 623     return JSON_NULL;
 624 }
 625
 626 int json_reader_bool(JSONParser *p) {
 627     JSONLiteralType lt = json_reader_literal(p);
 628     return lt == JSON_TRUE ? 1 : 0;
 629 }
 630
 631
 632 /* -------------------- read value functions -------------------- */
 633
 634 static JSONValue* init_value(JSONParser *p) {
 635     JSONValue *value = malloc(sizeof(JSONValue));
 636     if(!value) {
 637         return NULL;
 638     }
 639     memset(value, 0, sizeof(JSONValue));
 640     return value;
 641 }
 642
 643 static int setup_read_value(JSONParser *p) {
 644     p->readvalue_alloc = PARSER_STATES_ALLOC;
 645     p->readvalue_nelm = 0;
 646     p->readvalue_stack = calloc(PARSER_STATES_ALLOC, sizeof(JSONValue*));
 647     if(!p->readvalue_stack) return -1;
 648
 649     p->read_value = NULL;
 650     p->readvalue_stack[0] = NULL;
 651
 652     return 0;
 653 }
 654
 655 static int obj_init_values(JSONParser *p, JSONValue *v) {
 656     v->value.object.values = calloc(sizeof(JSONObjValue), p->reader_array_alloc);
 657     if(!v->value.object.values) {
 658         return -1;
 659     }
 660     v->value.object.alloc = p->reader_array_alloc;
 661     v->value.object.size = 0;
 662
 663     return 0;
 664 }
 665
 666 static int obj_add_value(JSONParser *p, JSONValue *parent, JSONObjValue v) {
 667     if(!parent->value.object.values) {
 668         if(obj_init_values(p, parent)) {
 669             return -1;
 670         }
 671     }
 672
 673     if(parent->value.object.size == parent->value.object.alloc) {
 674         parent->value.object.alloc *= 2;
 675         parent->value.object.values = realloc(parent->value.object.values, sizeof(JSONObjValue) * parent->value.object.alloc);
 676         if(!parent->value.object.values) {
 677             return -1;
 678         }
 679     }
 680
 681     parent->value.object.values[parent->value.object.size++] = v;
 682
 683     return 0;
 684 }
 685
 686 static int array_init(JSONParser *p, JSONValue *v) {
 687     v->value.array.array = calloc(sizeof(JSONValue*), p->reader_array_alloc);
 688     if(!v->value.array.array) {
 689         return -1;
 690     }
 691     v->value.array.alloc = p->reader_array_alloc;
 692     v->value.array.size = 0;
 693
 694     return 0;
 695 }
 696
 697 static int array_add_value(JSONParser *p, JSONValue *parent, JSONValue *v) {
 698     if(!parent->value.array.array) {
 699         if(array_init(p, parent)) {
 700             return -1;
 701         }
 702     }
 703
 704     if(parent->value.array.size == parent->value.array.alloc) {
 705         parent->value.array.alloc *= 2;
 706         parent->value.array.array = realloc(parent->value.array.array, sizeof(JSONValue*) * parent->value.array.alloc);
 707         if(!parent->value.array.array) {
 708             return -1;
 709         }
 710     }
 711
 712     parent->value.array.array[parent->value.array.size++] = v;
 713
 714     return 0;
 715 }
 716
 717 static int add_to_parent(JSONParser *p, JSONValue *parent, JSONValue *v) {
 718     if(!parent) {
 719         return -1; // shouldn't happen but who knows
 720     }
 721
 722     int ret = 0;
 723     if(parent->type == JSON_OBJECT) {
 724         if(!p->value_name || p->value_name_len == 0) {
 725             return -1;
 726         }
 727         char *valuename = p->value_name;
 728         p->value_name = NULL;
 729
 730         JSONObjValue newvalue;
 731         newvalue.name = valuename;
 732         newvalue.value = v;
 733
 734         ret = obj_add_value(p, parent, newvalue);
 735     } else if(parent->type == JSON_ARRAY) {
 736         ret = array_add_value(p, parent, v);
 737     } else {
 738         ret = -1; // should also never happen
 739     }
 740
 741     return ret;
 742 }
 743
 744
 745 static int readvaluestack_add(JSONParser *p, JSONValue *v) {
 746     if(p->readvalue_nelm == p->readvalue_alloc) {
 747         p->readvalue_alloc *= 2;
 748         p->readvalue_stack = realloc(p->readvalue_stack, sizeof(JSONValue*) * p->readvalue_alloc);
 749         if(!p->readvalue_stack) {
 750             return -1;
 751         }
 752     }
 753     p->readvalue_stack[p->readvalue_nelm++] = v;
 754     return 0;
 755 }
 756
 757 int json_read_value(JSONParser *p, JSONValue **value) {
 758     *value = NULL;
 759     if(!p->readvalue_stack) {
 760         if(setup_read_value(p)) return -1;
 761     }
 762
 763     while(p->readvalue_nelm > 0 || !p->read_value) {
 764         //JSONValue *s = p->readvalue_stack[p->readvalue_nelm];
 765         if(p->value_ready) {
 766             // value available without another read
 767             JSONValue *v = init_value(p);
 768             if(!v) return -1;
 769
 770             if(p->readvalue_nelm > 0) {
 771                 if(add_to_parent(p, p->readvalue_stack[p->readvalue_nelm-1], v)) {
 772                     return -1;
 773                 }
 774             } else {
 775                 // set this value as root
 776                 p->read_value = v;
 777             }
 778
 779             switch(p->reader_type) {
 780                 case JSON_READER_OBJECT_BEGIN: {
 781                     v->type = JSON_OBJECT;
 782                     if(readvaluestack_add(p, v)) {
 783                         return -1;
 784                     }
 785                     break;
 786                 }
 787                 case JSON_READER_OBJECT_END: return -1; // should not happen
 788                 case JSON_READER_ARRAY_BEGIN: {
 789                     v->type = JSON_ARRAY;
 790                     if(readvaluestack_add(p, v)) {
 791                         return -1;
 792                     }
 793                     break;
 794                 }
 795                 case JSON_READER_ARRAY_END: return -1; // should not happen
 796                 case JSON_READER_STRING: {
 797                     v->type = JSON_STRING;
 798                     if(p->value_str) {
 799                         v->value.string.string = p->value_str;
 800                         v->value.string.length = p->value_str_len;
 801                         p->value_str = NULL;
 802                     }
 803                     break;
 804                 }
 805                 case JSON_READER_INTEGER: {
 806                     v->type = JSON_INTEGER;
 807                     v->value.integer.value = json_reader_int(p);
 808                     break;
 809                 }
 810                 case JSON_READER_NUMBER: {
 811                     v->type = JSON_NUMBER;
 812                     v->value.number.value = json_reader_double(p);
 813                     break;
 814                 }
 815                 case JSON_READER_LITERAL: {
 816                     v->type = JSON_LITERAL;
 817                     v->value.literal.literal = json_reader_literal(p);
 818                     break;
 819                 }
 820             }
 821         } else if(p->readvalue_initialized) {
 822             JSONReaderType rt = p->reader_type;
 823             if(rt == JSON_READER_OBJECT_END || rt == JSON_READER_ARRAY_END) {
 824                 p->readvalue_nelm--;
 825             }
 826             // else: p->value_ready is 1, this will be handled in the next run
 827         }
 828
 829         if(p->readvalue_nelm > 0 || !p->read_value) {
 830             int r = json_read(p);
 831             if(r != 1) {
 832                 p->readvalue_initialized = 0;
 833                 return r;
 834             }
 835             p->readvalue_initialized = 1;
 836         }
 837     }
 838
 839     *value = p->read_value;
 840     p->readvalue_initialized = 0;
 841     p->read_value = NULL;
 842
 843     return 1;
 844 }
 845
 846 JSONValue* json_obj_get(JSONObject *obj, const char *name) {
 847     for(size_t i=0;i<obj->size;i++) {
 848         if(!strcmp(obj->values[i].name, name)) {
 849             return obj->values[i].value;
 850         }
 851     }
 852     return NULL;
 853 }
 854
 855 JSONValue* json_array_get(JSONArray *array, size_t i) {
 856     if(i >= array->size) return NULL;
 857     return array->array[i];
 858 }
 859
 860 void json_value_free(JSONValue *value) {
 861     switch(value->type) {
 862         case JSON_OBJECT: {
 863             JSONObject obj = value->value.object;
 864             for(size_t i=0;i<obj.size;i++) {
 865                 json_value_free(obj.values[i].value);
 866                 free(obj.values[i].name);
 867             }
 868             free(obj.values);
 869             break;
 870         }
 871         case JSON_ARRAY: {
 872             JSONArray array = value->value.array;
 873             for(size_t i=0;i<array.size;i++) {
 874                 json_value_free(array.array[i]);
 875             }
 876             free(array.array);
 877             break;
 878         }
 879         case JSON_STRING: {
 880             free(value->value.string.string);
 881             break;
 882         }
 883         default: {
 884             break;
 885         }
 886     }
 887     free(value);
 888 }
 889
 890 int json_strcmp(JSONValue *jsstr, const char *str) {
 891     return json_strncmp(jsstr, str, strlen(str));
 892 }
 893
 894 int json_strncmp(JSONValue *jsstr, const char *str, size_t slen) {
 895     if(jsstr->type != JSON_STRING) {
 896         return -1;
 897     }
 898     size_t jsstrlen = jsstr->value.string.length;
 899
 900     if(jsstrlen != slen) {
 901         return jsstrlen > slen ? 1 : -1;
 902     }
 903
 904     return memcmp(jsstr->value.string.string, str, slen);
 905 }