ucx: comparison src/json.c

-:f3b04cd60776
+:6eb7b54975ee
 cxmutstr str = cx_mutstrn(json->buffer.space + start, end - start);
 bool allocated = false;
 if (json->uncompleted.tokentype != CX_JSON_NO_TOKEN) {
 allocated = true;
 str = cx_strcat_m(json->uncompleted.content, 1, str);
-if (str.ptr == NULL) {
+if (str.ptr == NULL) { // LCOV_EXCL_START
 return (CxJsonToken){CX_JSON_NO_TOKEN, false, {NULL, 0}};
-}
+} // LCOV_EXCL_STOP
 }
 json->uncompleted = (CxJsonToken){0};
 CxJsonTokenType ttype;
 if (isstring) {
 ttype = CX_JSON_TOKEN_STRING;
 } else {
 // finish token
 if (ctype != CX_JSON_NO_TOKEN) {
 *result = token_create(json, false, token_start, i);
 if (result->tokentype == CX_JSON_NO_TOKEN) {
-return CX_JSON_BUFFER_ALLOC_FAILED;
+return CX_JSON_BUFFER_ALLOC_FAILED; // LCOV_EXCL_LINE
 }
 if (result->tokentype == CX_JSON_TOKEN_ERROR) {
 return CX_JSON_FORMAT_ERROR_NUMBER;
 }
 json->buffer.pos = i;
 json->tokenizer_escape = false;
 } else {
 if (c == '"') {
 *result = token_create(json, true, token_start, i + 1);
 if (result->tokentype == CX_JSON_NO_TOKEN) {
-return CX_JSON_BUFFER_ALLOC_FAILED;
+return CX_JSON_BUFFER_ALLOC_FAILED; // LCOV_EXCL_LINE
 }
 json->buffer.pos = i + 1;
 return CX_JSON_NO_ERROR;
 } else if (c == '\\') {
 json->tokenizer_escape = true;
 CxJsonToken uncompleted = {
 ttype, true,
 cx_strdup(cx_strn(json->buffer.space + token_start, uncompleted_len))
 };
 if (uncompleted.content.ptr == NULL) {
-return CX_JSON_BUFFER_ALLOC_FAILED;
+return CX_JSON_BUFFER_ALLOC_FAILED; // LCOV_EXCL_LINE
 }
 json->uncompleted = uncompleted;
 } else {
 // previously we also had an uncompleted token
 // combine the uncompleted token with the current token
 assert(json->uncompleted.allocated);
 cxmutstr str = cx_strcat_m(json->uncompleted.content, 1,
 cx_strn(json->buffer.space + token_start, uncompleted_len));
 if (str.ptr == NULL) {
-return CX_JSON_BUFFER_ALLOC_FAILED;
+return CX_JSON_BUFFER_ALLOC_FAILED; // LCOV_EXCL_LINE
 }
 json->uncompleted.content = str;
 }
 // advance the buffer position - we saved the stuff in the uncompleted token
 json->buffer.pos += uncompleted_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 = cxMalloc(a, str.length - 1);
-if (result.ptr == NULL) {
+if (result.ptr == NULL) return result; // LCOV_EXCL_LINE
-return result;
-}
 bool u = false;
 for (size_t i = 1; i < str.length - 1; i++) {
 char c = str.ptr[i];
 if (u) {
 return result;
 }
 static CxJsonValue* create_json_value(CxJson *json, CxJsonValueType type) {
 CxJsonValue *v = cxMalloc(json->allocator, sizeof(CxJsonValue));
-if (v == NULL) {
+if (v == NULL) return NULL; // LCOV_EXCL_LINE
-return NULL;
-}
 // initialize the value
 if (type == CX_JSON_ARRAY) {
 cx_array_initialize_a(json->allocator, v->value.array.array, 16);
-if (v->value.array.array == NULL) {
+if (v->value.array.array == NULL) { // LCOV_EXCL_START
 cxFree(json->allocator, v);
 return NULL;
-}
+} // LCOV_EXCL_STOP
 } else if (type == CX_JSON_OBJECT) {
 cx_array_initialize_a(json->allocator, v->value.object.values, 16);
-if (v->value.object.values == NULL) {
+if (v->value.object.values == NULL) { // LCOV_EXCL_START
 cxFree(json->allocator, v);
 return NULL;
-}
+} // LCOV_EXCL_STOP
 } else {
 memset(v, 0, sizeof(CxJsonValue));
 }
 v->type = type;
 v->allocator = json->allocator;
 } else if (parent->type == CX_JSON_OBJECT) {
 assert(parent->value.object.values_size > 0);
 assert(parent->value.object.values[parent->value.object.values_size - 1].value == NULL);
 parent->value.object.values[parent->value.object.values_size - 1].value = v;
 } else {
-assert(false);
+assert(false); // LCOV_EXCL_LINE
 }
 }
 // add the new value to the stack, if it is an array or object
 if (type == CX_JSON_ARRAY || type == CX_JSON_OBJECT) {
 CxArrayReallocator vbuf_realloc = cx_array_reallocator(NULL, json->vbuf_internal);
 if (cx_array_simple_add_a(&vbuf_realloc, json->vbuf, v)) {
+// LCOV_EXCL_START
 cxFree(json->allocator, v);
 return NULL;
-}
+} // LCOV_EXCL_STOP
 }
 // if currently no value is parsed, this is now the value of interest
 if (json->parsed == NULL) {
 json->parsed = v;
 int state = json->states[--json->states_size];
 // guarantee that at least two more states fit on the stack
 CxArrayReallocator state_realloc = cx_array_reallocator(NULL, json->states_internal);
 if (cx_array_simple_reserve_a(&state_realloc, json->states, 2)) {
-return CX_JSON_BUFFER_ALLOC_FAILED;
+return CX_JSON_BUFFER_ALLOC_FAILED; // LCOV_EXCL_LINE
 }
 //  0 JP_STATE_VALUE_BEGIN          value begin
 // 10 JP_STATE_VALUE_END            expect value end
 // push expected end state to the stack
 json_add_state(json, 10 + state);
 switch (token.tokentype) {
 case CX_JSON_TOKEN_BEGIN_ARRAY: {
 if (create_json_value(json, CX_JSON_ARRAY) == NULL) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 json_add_state(json, JP_STATE_VALUE_BEGIN_AR);
 return_rec(CX_JSON_NO_ERROR);
 }
 case CX_JSON_TOKEN_BEGIN_OBJECT: {
 if (create_json_value(json, CX_JSON_OBJECT) == NULL) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 json_add_state(json, JP_STATE_OBJ_NAME_OR_CLOSE);
 return_rec(CX_JSON_NO_ERROR);
 }
 case CX_JSON_TOKEN_STRING: {
 if ((vbuf = create_json_value(json, CX_JSON_STRING)) == NULL) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 cxmutstr str = unescape_string(json->allocator, token.content);
 if (str.ptr == NULL) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 vbuf->value.string = str;
 return_rec(CX_JSON_NO_ERROR);
 }
 case CX_JSON_TOKEN_INTEGER:
 case CX_JSON_TOKEN_NUMBER: {
 int type = token.tokentype == CX_JSON_TOKEN_INTEGER ? CX_JSON_INTEGER : CX_JSON_NUMBER;
 if (NULL == (vbuf = create_json_value(json, type))) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 if (type == CX_JSON_INTEGER) {
 if (cx_strtoi64(token.content, &vbuf->value.integer, 10)) {
 return_rec(CX_JSON_FORMAT_ERROR_NUMBER);
 }
 }
 return_rec(CX_JSON_NO_ERROR);
 }
 case CX_JSON_TOKEN_LITERAL: {
 if ((vbuf = create_json_value(json, CX_JSON_LITERAL)) == NULL) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 if (0 == cx_strcmp(cx_strcast(token.content), cx_str("true"))) {
 vbuf->value.literal = CX_JSON_TRUE;
 } else if (0 == cx_strcmp(cx_strcast(token.content), cx_str("false"))) {
 vbuf->value.literal = CX_JSON_FALSE;
 }
 // add new entry
 cxmutstr name = unescape_string(json->allocator, token.content);
 if (name.ptr == NULL) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 CxJsonObjValue kv = {name, NULL};
 assert(json->vbuf_size > 0);
 CxJsonValue *parent = json->vbuf[json->vbuf_size - 1];
 assert(parent != NULL);
 assert(parent->type == CX_JSON_OBJECT);
 CxArrayReallocator value_realloc = cx_array_reallocator(json->allocator, NULL);
 if (cx_array_simple_add_a(&value_realloc, parent->value.object.values, kv)) {
-return_rec(CX_JSON_VALUE_ALLOC_FAILED);
+return_rec(CX_JSON_VALUE_ALLOC_FAILED); // LCOV_EXCL_LINE
 }
 // next state
 json_add_state(json, JP_STATE_OBJ_COLON);
 return_rec(CX_JSON_NO_ERROR);
 v->type = CX_JSON_LITERAL;
 v->value.literal = lit;
 return v;
 }
+// LCOV_EXCL_START
+// never called as long as malloc() does not return NULL
 static void cx_json_arr_free_temp(CxJsonValue** values, size_t count) {
 for (size_t i = 0; i < count; i++) {
 if (values[i] == NULL) break;
 cxJsonValueFree(values[i]);
 }
 free(values);
 }
+// LCOV_EXCL_STOP
 int cxJsonArrAddNumbers(CxJsonValue* arr, const double* num, size_t count) {
 CxJsonValue** values = calloc(count, sizeof(CxJsonValue*));
 if (values == NULL) return -1;
 for (size_t i = 0; i < count; i++) {

Mercurial > hg > ucx / file comparison

comparison: src/json.c

src/json.c