webserver: comparison src/ucx/json.c

-:a202cb1ee175
+:956c03c25edd
 #include <string.h>
 #include <assert.h>
 #include <stdio.h>
 #include <inttypes.h>
+#include <ctype.h>
 /*
 * RFC 8259
 * https://tools.ietf.org/html/rfc8259
 */
 const CxJsonObjValue *left = l;
 const CxJsonObjValue *right = r;
 return cx_strcmp(cx_strcast(left->name), cx_strcast(right->name));
 }
-static CxJsonObjValue *json_find_objvalue(const CxJsonValue *obj, cxstring name) {
+static size_t json_find_objvalue(const CxJsonValue *obj, cxstring name) {
 assert(obj->type == CX_JSON_OBJECT);
 CxJsonObjValue kv_dummy;
 kv_dummy.name = cx_mutstrn((char*) name.ptr, name.length);
-size_t index = cx_array_binary_search(
+return cx_array_binary_search(
 obj->value.object.values,
 obj->value.object.values_size,
 sizeof(CxJsonObjValue),
 &kv_dummy,
 json_cmp_objvalue
 );
-if (index == obj->value.object.values_size) {
-return NULL;
-} else {
-return &obj->value.object.values[index];
-}
 }
 static int json_add_objvalue(CxJsonValue *objv, CxJsonObjValue member) {
 assert(objv->type == CX_JSON_OBJECT);
 const CxAllocator * const al = objv->allocator;
 if (token->allocated) {
 cx_strfree(&token->content);
 }
 }
-static bool json_isdigit(char c) {
-// TODO: remove once UCX has public API for this
-return c >= '0' && c <= '9';
-}
-static bool json_isspace(char c) {
-// TODO: remove once UCX has public API for this
-return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f';
-}
 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 (json_isdigit(c)) {
+if (isdigit((unsigned char)c)) {
 ok = 1;
 } else if (i == pos) {
 if (!(c == '+' || c == '-')) {
 return 0;
 }
 }
 static CxJsonTokenType token_numbertype(const char *content, size_t length) {
 if (length == 0) return CX_JSON_TOKEN_ERROR;
-if (content[0] != '-' && !json_isdigit(content[0])) {
+if (content[0] != '-' && !isdigit((unsigned char)content[0])) {
 return CX_JSON_TOKEN_ERROR;
 }
 CxJsonTokenType type = CX_JSON_TOKEN_INTEGER;
 for (size_t i = 1; i < length; i++) {
 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 (!json_isdigit(content[i])) {
+} else if (!isdigit((unsigned char)content[i])) {
 return CX_JSON_TOKEN_ERROR; // char is not a digit, decimal separator or exponent sep
 }
 }
 return type;
 }
 case '"': {
 return CX_JSON_TOKEN_STRING;
 }
 default: {
-if (json_isspace(c)) {
+if (isspace((unsigned char)c)) {
 return CX_JSON_TOKEN_SPACE;
 }
 }
 }
 return CX_JSON_NO_TOKEN;
 cx_strfree_a(json->allocator, &json->uncompleted_member.name);
 json->uncompleted_member = (CxJsonObjValue){{NULL, 0}, NULL};
 }
 }
+void cxJsonReset(CxJson *json) {
+const CxAllocator *allocator = json->allocator;
+cxJsonDestroy(json);
+cxJsonInit(json, allocator);
+}
 int cxJsonFilln(CxJson *json, const char *buf, size_t size) {
 if (cxBufferEof(&json->buffer)) {
 // reinitialize the buffer
 cxBufferDestroy(&json->buffer);
 cxBufferInit(&json->buffer, (char*) buf, size,
 return &cx_json_value_nothing;
 }
 return value->value.array.array[index];
 }
+CxJsonValue *cxJsonArrRemove(CxJsonValue *value, size_t index) {
+if (index >= value->value.array.array_size) {
+return NULL;
+}
+CxJsonValue *ret = value->value.array.array[index];
+// TODO: replace with a low level cx_array_remove()
+size_t count = value->value.array.array_size - index - 1;
+if (count > 0) {
+memmove(value->value.array.array + index, value->value.array.array + index + 1, count * sizeof(CxJsonValue*));
+}
+value->value.array.array_size--;
+return ret;
+}
+char *cxJsonAsString(const CxJsonValue *value) {
+return value->value.string.ptr;
+}
+cxstring cxJsonAsCxString(const CxJsonValue *value) {
+return cx_strcast(value->value.string);
+}
+cxmutstr cxJsonAsCxMutStr(const CxJsonValue *value) {
+return value->value.string;
+}
+double cxJsonAsDouble(const CxJsonValue *value) {
+if (value->type == CX_JSON_INTEGER) {
+return (double) value->value.integer;
+} else {
+return value->value.number;
+}
+}
+int64_t cxJsonAsInteger(const CxJsonValue *value) {
+if (value->type == CX_JSON_INTEGER) {
+return value->value.integer;
+} else {
+return (int64_t) value->value.number;
+}
+}
 CxIterator cxJsonArrIter(const CxJsonValue *value) {
 return cxIteratorPtr(
 value->value.array.array,
-value->value.array.array_size
+value->value.array.array_size,
+true // arrays need to keep order
 );
 }
 CxIterator cxJsonObjIter(const CxJsonValue *value) {
 return cxIterator(
 value->value.object.values,
 sizeof(CxJsonObjValue),
-value->value.object.values_size
+value->value.object.values_size,
+true // TODO: objects do not always need to keep order
 );
 }
-CxJsonValue *cx_json_obj_get_cxstr(const CxJsonValue *value, cxstring name) {
+CxJsonValue *cx_json_obj_get(const CxJsonValue *value, cxstring name) {
-CxJsonObjValue *member = json_find_objvalue(value, name);
+size_t index = json_find_objvalue(value, name);
-if (member == NULL) {
+if (index >= value->value.object.values_size) {
 return &cx_json_value_nothing;
 } else {
-return member->value;
+return value->value.object.values[index].value;
+}
+}
+CxJsonValue *cx_json_obj_remove(CxJsonValue *value, cxstring name) {
+size_t index = json_find_objvalue(value, name);
+if (index >= value->value.object.values_size) {
+return NULL;
+} else {
+CxJsonObjValue kv = value->value.object.values[index];
+cx_strfree_a(value->allocator, &kv.name);
+// TODO: replace with cx_array_remove() / cx_array_remove_fast()
+value->value.object.values_size--;
+memmove(value->value.object.values + index, value->value.object.values + index + 1, (value->value.object.values_size - index) * sizeof(CxJsonObjValue));
+return kv.value;
 }
 }
 CxJsonWriter cxJsonWriterCompact(void) {
 return (CxJsonWriter) {

Mercurial > hg > webserver / file comparison

comparison: src/ucx/json.c

src/ucx/json.c