src/json.c@c26299cc9897
src/json.c
Tue, 22 Oct 2024 22:20:50 +0200
- author
- Mike Becker <universe@uap-core.de>
- date
- Tue, 22 Oct 2024 22:20:50 +0200
- changeset 944
- c26299cc9897
- parent 943
- 9f1eb30dbc84
- child 946
- b428424c0214
- permissions
- -rw-r--r--
make both gcc and clang happy with how cx_json_value_nothing is initialized
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright 2024 Mike Becker, Olaf Wintermann All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include <string.h> #include <ctype.h> #include "cx/json.h" #include "cx/allocator.h" /* * RFC 8259 * https://tools.ietf.org/html/rfc8259 */ #define PARSER_STATES_ALLOC 32 static CxJsonValue cx_json_value_nothing = {.type = CX_JSON_NOTHING}; static int token_append(CxJsonToken *token, const char *buf, size_t len) { if (len == 0) { return 0; } size_t newlen = token->length + len; if (token->alloc < newlen) { char *newbuf = realloc( token->alloc == 0 ? NULL : (char *) token->content, newlen); if (!newbuf) { return 1; } token->content = newbuf; token->alloc = newlen; } memcpy((char *) token->content + token->length, buf, len); token->length = newlen; return 0; } static CxJsonToken get_content(CxJson *p, size_t start, size_t end) { CxJsonToken token = {0}; size_t part2 = end - start; if (p->uncompleted.tokentype == CX_JSON_NO_TOKEN) { token.content = p->buffer + start; token.length = part2; } else if (part2 == 0) { token = p->uncompleted; } else { if (token_append(&p->uncompleted, p->buffer + start, end - start)) { // TODO: this does certainly not lead to correct error handling return (CxJsonToken){0}; } token = p->uncompleted; } p->uncompleted = (CxJsonToken){0}; return token; } static int token_isliteral(const char *content, size_t length) { if (length == 4) { if (!memcmp(content, "true", 4)) { return 1; } else if (!memcmp(content, "null", 4)) { return 1; } } else if (length == 5 && !memcmp(content, "false", 5)) { return 1; } return 0; } static int num_isexp(const char *content, size_t length, size_t pos) { if (pos >= length) { return 0; } int ok = 0; for (size_t i = pos; i < length; i++) { char c = content[i]; if (isdigit(c)) { ok = 1; } else if (i == pos) { if (!(c == '+' || c == '-')) { return 0; } } else { return 0; } } return ok; } static CxJsonTokenType token_numbertype(const char *content, size_t length) { if (length == 0) return CX_JSON_TOKEN_ERROR; if (content[0] != '-' && !isdigit(content[0])) { return CX_JSON_TOKEN_ERROR; } CxJsonTokenType type = CX_JSON_TOKEN_INTEGER; for (size_t i = 1; i < length; i++) { if (content[i] == '.') { if (type == CX_JSON_TOKEN_NUMBER) { return CX_JSON_TOKEN_ERROR; // more than one decimal separator } type = CX_JSON_TOKEN_NUMBER; } else if (content[i] == 'e' || content[i] == 'E') { return num_isexp(content, length, i + 1) ? CX_JSON_TOKEN_NUMBER : CX_JSON_TOKEN_ERROR; } else if (!isdigit(content[i])) { return CX_JSON_TOKEN_ERROR; // char is not a digit, decimal separator or exponent sep } } return type; } static CxJsonToken get_token(CxJson *p, size_t start, size_t end) { CxJsonToken token = get_content(p, start, end); if (token_isliteral(token.content, token.length)) { token.tokentype = CX_JSON_TOKEN_LITERAL; } else { token.tokentype = token_numbertype(token.content, token.length); } p->pos = end; return token; } static CxJsonTokenType char2ttype(char c) { switch (c) { case '[': { return CX_JSON_TOKEN_BEGIN_ARRAY; } case '{': { return CX_JSON_TOKEN_BEGIN_OBJECT; } case ']': { return CX_JSON_TOKEN_END_ARRAY; } case '}': { return CX_JSON_TOKEN_END_OBJECT; } case ':': { return CX_JSON_TOKEN_NAME_SEPARATOR; } case ',': { return CX_JSON_TOKEN_VALUE_SEPARATOR; } case '"': { return CX_JSON_TOKEN_STRING; } default: { if (isspace(c)) { return CX_JSON_TOKEN_SPACE; } } } return CX_JSON_NO_TOKEN; } static CxJsonToken json_parser_next_token(CxJson *p) { // current token type and start index CxJsonTokenType ttype = p->uncompleted.tokentype; size_t token_start = p->pos; for (size_t i = p->pos; i < p->size; i++) { char c = p->buffer[i]; if (ttype != CX_JSON_TOKEN_STRING) { // currently non-string token CxJsonTokenType ctype = char2ttype(c); // start of new token? if (ttype == CX_JSON_NO_TOKEN) { if (ctype == CX_JSON_TOKEN_SPACE) { continue; } else if (ctype == CX_JSON_TOKEN_STRING) { // begin string ttype = CX_JSON_TOKEN_STRING; token_start = i; } else if (ctype != CX_JSON_NO_TOKEN) { // single-char token p->pos = i + 1; CxJsonToken token = {ctype, NULL, 0, 0}; return token; } else { ttype = CX_JSON_TOKEN_LITERAL; // number or literal token_start = i; } } else { // finish token if (ctype != CX_JSON_NO_TOKEN) { return get_token(p, token_start, i); } } } else { // currently inside a string if (!p->tokenizer_escape) { if (c == '"') { CxJsonToken ret = get_content(p, token_start, i + 1); ret.tokentype = CX_JSON_TOKEN_STRING; p->pos = i + 1; return ret; } else if (c == '\\') { p->tokenizer_escape = 1; } } else { p->tokenizer_escape = 0; } } } if (ttype != CX_JSON_NO_TOKEN) { // uncompleted token size_t uncompeted_len = p->size - token_start; if (p->uncompleted.tokentype == CX_JSON_NO_TOKEN) { // current token is uncompleted // save current token content in p->uncompleted CxJsonToken uncompleted; uncompleted.tokentype = ttype; uncompleted.length = uncompeted_len; uncompleted.alloc = uncompeted_len + 16; char *tmp = malloc(uncompleted.alloc); if (tmp) { memcpy(tmp, p->buffer + token_start, uncompeted_len); uncompleted.content = tmp; p->uncompleted = uncompleted; } else { p->error = 1; } } else { // previously we also had an uncompleted token // combine the uncompleted token with the current token if (token_append(&p->uncompleted, p->buffer + token_start, uncompeted_len)) { p->error = 1; } } } CxJsonToken ret = {CX_JSON_NO_TOKEN, NULL, 0, 0}; return ret; } static cxmutstr unescape_string(const char *str, size_t len) { // TODO: support more escape sequences // we know that the unescaped string will be shorter by at least 2 chars cxmutstr result; result.length = 0; result.ptr = malloc(len - 1); if (result.ptr == NULL) { // TODO: check if this actually leads to correct error handling return result; } bool u = false; for (size_t i = 1; i < len - 1; i++) { char c = str[i]; if (u) { u = false; if (c == 'n') { c = '\n'; } else if (c == 't') { c = '\t'; } result.ptr[result.length++] = c; } else { if (c == '\\') { u = true; } else { result.ptr[result.length++] = c; } } } result.ptr[result.length] = 0; return result; } static int parse_integer(const char *str, size_t len, int64_t *value) { char *endptr = NULL; char buf[32]; if (len > 30) { return 1; } memcpy(buf, str, len); buf[len] = 0; long long v = strtoll(buf, &endptr, 10); if (endptr != &buf[len]) { return 1; } *value = (int64_t) v; return 0; } static int parse_number(const char *str, size_t len, double *value) { char *endptr = NULL; char buf[32]; if (len > 30) { return 1; } memcpy(buf, str, len); buf[len] = 0; double v = strtod(buf, &endptr); if (endptr != &buf[len]) { return 1; } *value = v; return 0; } static int add_state(CxJson *p, int state) { if (p->nstates >= p->states_alloc) { p->states_alloc += PARSER_STATES_ALLOC; if (cx_reallocate(&p->states, p->states_alloc * sizeof(int))) { return 1; } } p->states[++p->nstates] = state; return 0; } static void end_elm(CxJson *p, CxJsonReaderType type) { p->reader_type = type; p->nstates--; } #define JP_STATE_VALUE_BEGIN 0 #define JP_STATE_VALUE_BEGIN_OBJ 1 #define JP_STATE_VALUE_BEGIN_AR 2 #define JP_STATE_ARRAY_SEP_OR_CLOSE 3 #define JP_STATE_OBJ_NAME_OR_CLOSE 4 #define JP_STATE_OBJ_NAME 5 #define JP_STATE_OBJ_COLON 6 #define JP_STATE_OBJ_SEP_OR_CLOSE 7 static int next_state_after_value(int current) { switch (current) { default: return -1; // after value JSON complete, expect nothing case JP_STATE_VALUE_BEGIN: return -1; // after obj value, expect ',' or '}' case JP_STATE_VALUE_BEGIN_OBJ: return JP_STATE_OBJ_SEP_OR_CLOSE; // after array value, expect ',' or ']' case JP_STATE_VALUE_BEGIN_AR: return JP_STATE_ARRAY_SEP_OR_CLOSE; } } static void clear_valuename(CxJson *p) { free(p->value_name); p->value_name = NULL; p->value_name_len = 0; } static void clear_values(CxJson *p) { free(p->value_str); p->value_str = NULL; p->value_str_len = 0; p->value_int = 0; p->value_double = 0; } static int json_read(CxJson *p) { int state = p->states[p->nstates]; clear_values(p); CxJsonToken token = json_parser_next_token(p); p->reader_token = token; p->value_ready = 0; if (token.tokentype == CX_JSON_NO_TOKEN) { return 0; } int ret = 1; // 0 JP_STATE_VALUE_BEGIN value begin // 1 JP_STATE_VALUE_BEGIN_OBJ value begin (inside object) // 2 JP_STATE_VALUE_BEGIN_AR value begin (inside array) // 3 JP_STATE_ARRAY_SEP_OR_CLOSE array, expect separator or arrayclose // 4 JP_STATE_OBJ_NAME_OR_CLOSE object, expect name or objclose // 5 JP_STATE_OBJ_NAME object, expect name // 6 JP_STATE_OBJ_COLON object, expect ':' // 7 JP_STATE_OBJ_SEP_OR_CLOSE object, expect separator, objclose if (state == JP_STATE_VALUE_BEGIN_AR || state == JP_STATE_OBJ_SEP_OR_CLOSE) { clear_valuename(p); } if (state < 3) { // expect value p->states[p->nstates] = next_state_after_value(state); p->value_ready = 1; switch (token.tokentype) { case CX_JSON_TOKEN_BEGIN_ARRAY: { p->reader_type = CX_JSON_READER_ARRAY_BEGIN; ret = add_state(p, JP_STATE_VALUE_BEGIN_AR) ? -1 : 1; break; } case CX_JSON_TOKEN_BEGIN_OBJECT: { p->reader_type = CX_JSON_READER_OBJECT_BEGIN; ret = add_state(p, JP_STATE_OBJ_NAME_OR_CLOSE) ? -1 : 1; break; } case CX_JSON_TOKEN_END_ARRAY: { p->value_ready = 0; end_elm(p, CX_JSON_READER_ARRAY_END); break; } case CX_JSON_TOKEN_STRING: { p->reader_type = CX_JSON_READER_STRING; cxmutstr str = unescape_string(token.content, token.length); if (str.ptr) { p->value_str = str.ptr; p->value_str_len = str.length; } else { ret = -1; } break; } case CX_JSON_TOKEN_INTEGER: { p->reader_type = CX_JSON_READER_INTEGER; int64_t value; if (parse_integer(token.content, token.length, &value)) { ret = -1; } else { p->value_int = value; p->value_double = (double) value; } break; } case CX_JSON_TOKEN_NUMBER: { p->reader_type = CX_JSON_READER_NUMBER; double value; if (parse_number(token.content, token.length, &value)) { ret = -1; } else { p->value_double = value; p->value_int = (int64_t) value; } break; } case CX_JSON_TOKEN_LITERAL: { p->reader_type = CX_JSON_READER_LITERAL; break; } default: ret = -1; } } else if (state == JP_STATE_ARRAY_SEP_OR_CLOSE) { // expect ',' or ']' if (token.tokentype == CX_JSON_TOKEN_VALUE_SEPARATOR) { p->states[p->nstates] = JP_STATE_VALUE_BEGIN_AR; ret = json_read(p); } else if (token.tokentype == CX_JSON_TOKEN_END_ARRAY) { end_elm(p, CX_JSON_READER_ARRAY_END); } else { ret = -1; } } else if (state == JP_STATE_OBJ_NAME_OR_CLOSE || state == JP_STATE_OBJ_NAME) { if (state == JP_STATE_OBJ_NAME_OR_CLOSE && token.tokentype == CX_JSON_TOKEN_END_OBJECT) { clear_valuename(p); end_elm(p, CX_JSON_READER_OBJECT_END); } else { // expect string if (token.tokentype != CX_JSON_TOKEN_STRING) return -1; if (p->value_name) free(p->value_name); cxmutstr valname = unescape_string(token.content, token.length); p->value_name = valname.ptr; p->value_name_len = valname.length; // next state p->states[p->nstates] = JP_STATE_OBJ_COLON; ret = json_read(p); } } else if (state == JP_STATE_OBJ_COLON) { // expect ':' if (token.tokentype != CX_JSON_TOKEN_NAME_SEPARATOR) return -1; // next state p->states[p->nstates] = JP_STATE_VALUE_BEGIN_OBJ; ret = json_read(p); } else if (state == JP_STATE_OBJ_SEP_OR_CLOSE) { // expect ',' or '}' if (token.tokentype == CX_JSON_TOKEN_VALUE_SEPARATOR) { p->states[p->nstates] = JP_STATE_OBJ_NAME; ret = json_read(p); } else if (token.tokentype == CX_JSON_TOKEN_END_OBJECT) { end_elm(p, CX_JSON_READER_OBJECT_END); } else { ret = -1; } } if (token.alloc > 0) { free((char*)token.content); } return ret; } static CxJsonLiteralType json_reader_literal(CxJson *p) { const char *l = p->reader_token.content; size_t token_len = p->reader_token.length; if (token_len == 4 && !memcmp(l, "true", 4)) { return CX_JSON_TRUE; } else if (token_len == 5 && !memcmp(l, "false", 5)) { return CX_JSON_FALSE; } return CX_JSON_NULL; } /* -------------------- read value functions -------------------- */ static int setup_read_value(CxJson *p) { p->readvalue_alloc = PARSER_STATES_ALLOC; p->readvalue_nelm = 0; p->readvalue_stack = calloc(PARSER_STATES_ALLOC, sizeof(CxJsonValue *)); if (!p->readvalue_stack) return -1; p->read_value = NULL; p->readvalue_stack[0] = NULL; return 0; } static int obj_init_values(CxJson *p, CxJsonValue *v) { v->value.object.values = calloc(p->reader_array_alloc, sizeof(CxJsonObjValue)); if (!v->value.object.values) { return -1; } v->value.object.alloc = p->reader_array_alloc; v->value.object.size = 0; return 0; } static int obj_add_value(CxJson *p, CxJsonValue *parent, CxJsonObjValue v) { if (!parent->value.object.values) { if (obj_init_values(p, parent)) { return -1; } } if (parent->value.object.size == parent->value.object.alloc) { parent->value.object.alloc *= 2; if (cx_reallocate(&parent->value.object.values, sizeof(CxJsonObjValue) * parent->value.object.alloc)) { return -1; } } parent->value.object.values[parent->value.object.size++] = v; return 0; } static int array_init(CxJson *p, CxJsonValue *v) { v->value.array.array = calloc(p->reader_array_alloc, sizeof(CxJsonValue *)); if (!v->value.array.array) { return -1; } v->value.array.alloc = p->reader_array_alloc; v->value.array.size = 0; return 0; } static int array_add_value(CxJson *p, CxJsonValue *parent, CxJsonValue *v) { if (!parent->value.array.array) { if (array_init(p, parent)) { return -1; } } if (parent->value.array.size == parent->value.array.alloc) { parent->value.array.alloc *= 2; if (cx_reallocate(parent->value.array.array, sizeof(CxJsonValue *) * parent->value.array.alloc)) { return -1; } } parent->value.array.array[parent->value.array.size++] = v; return 0; } static int add_to_parent(CxJson *p, CxJsonValue *parent, CxJsonValue *v) { if (!parent) { return -1; // shouldn't happen but who knows } int ret = 0; if (parent->type == CX_JSON_OBJECT) { if (!p->value_name || p->value_name_len == 0) { return -1; } char *valuename = p->value_name; p->value_name = NULL; CxJsonObjValue newvalue; newvalue.name = valuename; newvalue.value = v; ret = obj_add_value(p, parent, newvalue); } else if (parent->type == CX_JSON_ARRAY) { ret = array_add_value(p, parent, v); } else { ret = -1; // should also never happen } return ret; } static int readvaluestack_add(CxJson *p, CxJsonValue *v) { if (p->readvalue_nelm == p->readvalue_alloc) { p->readvalue_alloc *= 2; if (cx_reallocate(&p->readvalue_stack, sizeof(CxJsonValue *) * p->readvalue_alloc)) { return -1; } } p->readvalue_stack[p->readvalue_nelm++] = v; return 0; } void cxJsonInit(CxJson *json) { memset(json, 0, sizeof(CxJson)); // TODO: do not allocate states right away json->states_alloc = PARSER_STATES_ALLOC; json->states = calloc(PARSER_STATES_ALLOC, sizeof(int)); // TODO: find better way to configure the initial allocation size for arrays and objects json->reader_array_alloc = 8; } void cxJsonDestroy(CxJson *p) { free(p->states); free(p->readvalue_stack); cxJsonValueFree(p->read_value); free(p->value_name); free(p->value_str); } void cxJsonFill(CxJson *p, const char *buf, size_t size) { // TODO: implement rescue buffer like in CxProperties to allow subsequent fills p->buffer = buf; p->size = size; p->pos = 0; } int cxJsonNext(CxJson *p, CxJsonValue **value) { // TODO: replace int with a status enum like in CxProperties *value = NULL; if (!p->readvalue_stack) { if (setup_read_value(p)) return -1; } while (p->readvalue_nelm > 0 || !p->read_value) { if (p->value_ready) { // value available without another read CxJsonValue *v = calloc(1, sizeof(CxJsonValue)); if (!v) return -1; if (p->readvalue_nelm > 0) { if (add_to_parent(p, p->readvalue_stack[p->readvalue_nelm - 1], v)) { free(v); return -1; } } else { // set this value as root p->read_value = v; } switch (p->reader_type) { case CX_JSON_READER_OBJECT_BEGIN: { v->type = CX_JSON_OBJECT; if (readvaluestack_add(p, v)) { return -1; } break; } case CX_JSON_READER_OBJECT_END: return -1; // should not happen case CX_JSON_READER_ARRAY_BEGIN: { v->type = CX_JSON_ARRAY; if (readvaluestack_add(p, v)) { return -1; } break; } case CX_JSON_READER_ARRAY_END: return -1; // should not happen case CX_JSON_READER_STRING: { v->type = CX_JSON_STRING; if (p->value_str) { v->value.string.ptr = p->value_str; v->value.string.length = p->value_str_len; p->value_str = NULL; } break; } case CX_JSON_READER_INTEGER: { v->type = CX_JSON_INTEGER; v->value.integer.value = p->value_int; break; } case CX_JSON_READER_NUMBER: { v->type = CX_JSON_NUMBER; v->value.number.value = p->value_double; break; } case CX_JSON_READER_LITERAL: { v->type = CX_JSON_LITERAL; v->value.literal.literal = json_reader_literal(p); break; } } } else if (p->readvalue_initialized) { CxJsonReaderType rt = p->reader_type; if (rt == CX_JSON_READER_OBJECT_END || rt == CX_JSON_READER_ARRAY_END) { p->readvalue_nelm--; } // else: p->value_ready is 1, this will be handled in the next run } if (p->readvalue_nelm > 0 || !p->read_value) { int r = json_read(p); if (r != 1) { p->readvalue_initialized = 0; return r; } p->readvalue_initialized = 1; } } *value = p->read_value; p->readvalue_initialized = 0; p->read_value = NULL; return 1; } void cxJsonValueFree(CxJsonValue *value) { if (value == NULL || value == &cx_json_value_nothing) return; // TODO: discuss if we should keep freeing the stuff recursively switch (value->type) { case CX_JSON_OBJECT: { CxJsonObject obj = value->value.object; for (size_t i = 0; i < obj.size; i++) { cxJsonValueFree(obj.values[i].value); free(obj.values[i].name); } free(obj.values); break; } case CX_JSON_ARRAY: { CxJsonArray array = value->value.array; for (size_t i = 0; i < array.size; i++) { cxJsonValueFree(array.array[i]); } free(array.array); break; } case CX_JSON_STRING: { free(value->value.string.ptr); break; } default: { break; } } free(value); } CxJsonValue *cxJsonArrGet(CxJsonValue *value, size_t index) { if (index >= value->value.array.size) { return &cx_json_value_nothing; } return value->value.array.array[index]; } CxJsonValue *cxJsonObjGet(CxJsonValue *value, const char *name) { CxJsonObject *obj = &(value->value.object); // TODO: think about sorting the object so that we can use binary search here for (size_t i = 0; i < obj->size; i++) { // TODO: we might want to store names as cxmutstr if (0 == strcmp(name, obj->values[i].name)) { return obj->values[i].value; } } return &cx_json_value_nothing; }
