ucx: comparison src/json.c

-:d3d4f245b843
+:333155f234c4
 CxJsonToken ret = {CX_JSON_NO_TOKEN, NULL, 0, 0};
 return ret;
 }
-static cxmutstr unescape_string(const char *str, size_t len) {
+static cxmutstr unescape_string(const CxAllocator *a, 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);
+result.ptr = cxMalloc(a, len - 1);
 if (result.ptr == NULL) {
 // TODO: check if this actually leads to correct error handling
 return result;
 }
 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);
+cxmutstr str = unescape_string(p->allocator, token.content, token.length);
 if (str.ptr) {
 p->value_str = str.ptr;
 p->value_str_len = str.length;
 } else {
 ret = -1;
 } 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);
+cxmutstr valname = unescape_string(p->allocator, 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;
 static int add_to_parent(CxJson *p, CxJsonValue *parent, CxJsonValue *v) {
 if (!parent) {
 return -1; // shouldn't happen but who knows
 }
+CxArrayReallocator reallocator = cx_array_reallocator(p->allocator, NULL);
 if (parent->type == CX_JSON_OBJECT) {
 if (!p->value_name || p->value_name_len == 0) {
 return -1;
 }
 char *valuename = p->value_name;
 CxJsonObjValue newvalue;
 newvalue.name = valuename;
 newvalue.value = v;
-return cx_array_simple_add(parent->value.object.values, newvalue);
+return cx_array_add(
+&parent->value.object.values,
+&parent->value.object.values_size,
+&parent->value.object.values_capacity,
+sizeof(CxJsonObjValue),
+&newvalue,
+&reallocator);
 } else if (parent->type == CX_JSON_ARRAY) {
-return cx_array_simple_add(parent->value.array.array, v);
+return cx_array_add(
+&parent->value.array.array,
+&parent->value.array.array_size,
+&parent->value.array.array_capacity,
+sizeof(CxJsonValue*),
+&v,
+&reallocator);
 } else {
 return -1; // should also never happen
 }
 }
 }
 p->readvalue_stack[p->readvalue_nelm++] = v;
 return 0;
 }
-void cxJsonInit(CxJson *json) {
+void cxJsonInit(const CxAllocator *allocator, CxJson *json) {
+if (allocator == NULL) {
+allocator = cxDefaultAllocator;
+}
 memset(json, 0, sizeof(CxJson));
+json->allocator = allocator;
 json->states = json->states_internal;
 json->states_alloc = cx_nmemb(json->states_internal);
 // TODO: find better way to configure the initial allocation size for arrays and objects
 json->reader_array_alloc = 8;
 }
 }
 while (p->readvalue_nelm > 0 || !p->read_value) {
 if (p->value_ready) {
 // value available without another read
-CxJsonValue *v = calloc(1, sizeof(CxJsonValue));
+CxJsonValue *v = cxCalloc(p->allocator, 1, sizeof(CxJsonValue));
 if (!v) return -1;
+v->allocator = p->allocator;
 if (p->readvalue_nelm > 0) {
 if (add_to_parent(p, p->readvalue_stack[p->readvalue_nelm - 1], v)) {
 free(v);
 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.values_size; i++) {
 cxJsonValueFree(obj.values[i].value);
-free(obj.values[i].name);
+cxFree(value->allocator, obj.values[i].name);
 }
-free(obj.values);
+cxFree(value->allocator, obj.values);
 break;
 }
 case CX_JSON_ARRAY: {
 CxJsonArray array = value->value.array;
 for (size_t i = 0; i < array.array_size; i++) {
 cxJsonValueFree(array.array[i]);
 }
-free(array.array);
+cxFree(value->allocator, array.array);
 break;
 }
 case CX_JSON_STRING: {
-free(value->value.string.ptr);
+cxFree(value->allocator, value->value.string.ptr);
 break;
 }
 default: {
 break;
 }
 }
-free(value);
+cxFree(value->allocator, value);
 }
 CxJsonValue *cxJsonArrGet(CxJsonValue *value, size_t index) {
 if (index >= value->value.array.array_size) {
 return &cx_json_value_nothing;

Mercurial > hg > ucx / file comparison

comparison: src/json.c

src/json.c