Remove tail recursion in dynType_alloc and add more parsing tests.

Author: PengZheng

libs/dfi/gtest/src/dyn_type_ei_tests.cc

@@ -108,3 +108,15 @@ TEST_F(DynTypeErrorInjectionTestSuite, ParseEnumTypeErrors) {
     ASSERT_NE(0, rc);
     celix_err_printErrors(stderr, nullptr, nullptr);
 }
+
+TEST_F(DynTypeErrorInjectionTestSuite, AllocateErrors) {
+    celix_autoptr(dyn_type) type = NULL;
+    int rc = 0;
+    rc = dynType_parseWithStr("#v1=0;#v2=1;E", NULL, NULL, &type);
+    ASSERT_EQ(0, rc);
+    celix_ei_expect_calloc((void*)dynType_alloc, 0, nullptr);
+    void* buf = nullptr;
+    rc = dynType_alloc(type, &buf);
+    ASSERT_NE(0, rc);
+    ASSERT_STREQ("Error allocating memory for type 'E'", celix_err_popLastError());
+}

libs/dfi/gtest/src/dyn_type_tests.cpp

@@ -326,6 +326,13 @@ TEST_F(DynTypeTests, ComplexTypeMissingClosingBrace) {
     ASSERT_STREQ("Error parsing complex type, expected '}'", celix_err_popLastError());
 }
 
+TEST_F(DynTypeTests, ComplexTypeWithMoreNamesThanFields) {
+    dyn_type *type = NULL;
+    auto rc = dynType_parseWithStr(R"({II a b c})", nullptr, nullptr, &type);
+    ASSERT_NE(0, rc);
+    ASSERT_STREQ("Error parsing complex type, expected '}'", celix_err_popLastError());
+}
+
 TEST_F(DynTypeTests, SchemaEndsWithoutNullTerminator) {
     dyn_type *type = NULL;
     //ends with '-'
@@ -365,8 +372,14 @@ TEST_F(DynTypeTests, MetaInfoMissingValue) {
 
 TEST_F(DynTypeTests, ParseNestedTypeFailed) {
     dyn_type *type = NULL;
+    int rc;
+    //missing name
+    rc = dynType_parseWithStr(R"(T={DD a b};)", nullptr, nullptr, &type);
+    ASSERT_NE(0, rc);
+    ASSERT_STREQ("Parsed empty name", celix_err_popLastError());
+
     //missing '='
-    auto rc = dynType_parseWithStr(R"(Ttype)", nullptr, nullptr, &type);
+    rc = dynType_parseWithStr(R"(Ttype)", nullptr, nullptr, &type);
     ASSERT_EQ(3, rc);
     celix_err_printErrors(stderr, nullptr, nullptr);
 
@@ -383,8 +396,13 @@ TEST_F(DynTypeTests, ParseNestedTypeFailed) {
 
 TEST_F(DynTypeTests, ParseReferenceFailed) {
     dyn_type *type = NULL;
+    int rc;
+    // missing name
+    rc = dynType_parseWithStr(R"(Ttype={DD a b};l;)", nullptr, nullptr, &type);
+    ASSERT_NE(0, rc);
+    ASSERT_STREQ("Parsed empty name", celix_err_popLastError());
     //missing ';'
-    auto rc = dynType_parseWithStr(R"(Ttype={DD a b};ltype)", nullptr, nullptr, &type);
+    rc = dynType_parseWithStr(R"(Ttype={DD a b};ltype)", nullptr, nullptr, &type);
     ASSERT_EQ(3, rc);
     celix_err_printErrors(stderr, nullptr, nullptr);
     //missing ';'

libs/dfi/src/dyn_type.c

@@ -427,10 +427,7 @@ static void dynType_clear(dyn_type* type) {
     while (entry != NULL) {
         tmp = entry;
         entry = TAILQ_NEXT(entry, entries);
-        if (tmp->type != NULL) {
-            dynType_destroy(tmp->type);
-            tmp->type = NULL;
-        }
+        dynType_destroy(tmp->type);
         free(tmp);
     }
 
@@ -499,21 +496,19 @@ static void dynType_clearTypedPointer(dyn_type* type) {
 }
 
 int dynType_alloc(const dyn_type* type, void** bufLoc) {
-    int status = OK;
+    const dyn_type* current = type;
 
-    if (type->type == DYN_TYPE_REF) {
-        status = dynType_alloc(type->ref.ref, bufLoc);
-    } else {
-        void* inst = calloc(1, type->ffiType->size);
-        if (inst != NULL) {
-            *bufLoc = inst;
-        } else {
-            status = MEM_ERROR;
-            celix_err_pushf("Error allocating memory for type '%c'", type->descriptor);
-        }
+    while (current->type == DYN_TYPE_REF) {
+        current = current->ref.ref;
+    }
+    void* inst = calloc(1, current->ffiType->size);
+    if (inst == NULL) {
+        celix_err_pushf("Error allocating memory for type '%c'", current->descriptor);
+        return MEM_ERROR;
     }
+    *bufLoc = inst;
 
-    return status;
+    return OK;
 }
 
 

libs/dfi/src/dyn_type_common.c

@@ -53,10 +53,6 @@ dyn_type* dynType_findType(dyn_type *type, char *name) {
 
 ffi_type * dynType_ffiType(dyn_type * type) {
     if (type->type == DYN_TYPE_REF) {
-        if (type->ref.ref == NULL) {
-            celix_err_pushf("Error. Ref for %s is not (yet) initialized", type->name);
-            return NULL;
-        }
         return type->ref.ref->ffiType;
     }
     return type->ffiType;