Cppcheck report - GATE C/C++ Framework: gate/structs.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| 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 OWNER 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 "gate/structs.h"
#include "gate/results.h"
#include "gate/objects.h"
#include "gate/arrays.h"
#include "gate/guids.h"
#include "gate/times.h"
#include "gate/blobs.h"
#include "gate/utilities.h"
#include "gate/properties.h"


gate_result_t gate_struct_item_init(gate_uint16_t type, void* ptr)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t type_length = gate_type_length(type);

    switch (type)
    {
    case GATE_TYPE_ARRAYLIST_BOOL:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_bool_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_I8:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_int8_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_UI8:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_uint8_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_I16:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_int16_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_UI16:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_uint16_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_I32:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_int32_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_UI32:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_uint32_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_I64:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_int64_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_UI64:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_uint64_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_R32:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_real32_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_R64:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_real64_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_ADDRESS:	*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_uintptr_t), NULL, 0, NULL, NULL); break;

        /* arraylist of basic gate structures (POD) */
    case GATE_TYPE_ARRAYLIST_DATAPTR:	*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_dataptr_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_FUNCPTR:	*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_funcptr_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_CSTR:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(char const*), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_WSTR:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(wchar_t const*), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_GUID:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_guid_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_DATE:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_date_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_DAYTIME:	*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_daytime_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_DATETIME:	*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_datetime_t), NULL, 0, NULL, NULL); break;
    case GATE_TYPE_ARRAYLIST_TIME:		*((gate_arraylist_t*)(ptr)) = gate_arraylist_create(sizeof(gate_time_t), NULL, 0, NULL, NULL); break;

        /* arraylist of basic generic types */
    case GATE_TYPE_ARRAYLIST_STRING:	*((gate_arraylist_t*)(ptr)) = gate_util_stringarray_create(); break;
    case GATE_TYPE_ARRAYLIST_ARRAY:		*((gate_arraylist_t*)(ptr)) = NULL; break;	/* must be initialized individually */
    case GATE_TYPE_ARRAYLIST_BLOB:		*((gate_arraylist_t*)(ptr)) = gate_util_blobarray_create(); break;

        /* arraylist of basic reference types */
    case GATE_TYPE_ARRAYLIST_STRUCT:	*((gate_arraylist_t*)(ptr)) = NULL; break;	/* must be initialized individually */
    case GATE_TYPE_ARRAYLIST_OBJECT:	*((gate_object_ptr_t*)(ptr)) = NULL; break;	/* must be initialized individually */
    case GATE_TYPE_ARRAYLIST_PROPERTY:	gate_property_create_empty((gate_property_t*)(ptr)); break;
    case GATE_TYPE_STRUCT:				((gate_struct_t*)(ptr))->struct_descriptor = NULL; break;	/* must be initialized individually */
    default:
    {
        gate_mem_clear(ptr, type_length);
        break;
    }
    }
    return ret;
}

gate_result_t gate_struct_item_release(gate_uint16_t type, void* ptr)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t type_length = gate_type_length(type);
    gate_struct_ptr_t struct_ptr;

    switch (type)
    {
    case GATE_TYPE_STRUCT:
    {
        struct_ptr = *((gate_struct_ptr_t*)ptr);
        ret = gate_struct_release(struct_ptr);
        break;
    }
    case GATE_TYPE_STRING:
    {
        gate_string_release((gate_string_t*)ptr);
        break;
    }
    case GATE_TYPE_BLOB:
    {
        gate_blob_release((gate_blob_t*)ptr);
        break;
    }
    case GATE_TYPE_OBJECT:
    {
        gate_object_release(*((gate_object_ptr_t*)ptr));
        break;
    }
    case GATE_TYPE_PROPERTY:
    {
        gate_property_destroy((gate_property_t*)ptr);
        break;
    }
    case GATE_TYPE_ARRAY:
    {
        gate_array_release((gate_array_t*)ptr);
        break;
    }
    case GATE_TYPE_EMPTY:
    {
        break;
    }
    default:
    {
        if (GATE_FLAG_ENABLED(type, GATE_TYPE_ARRAYLIST))
        {
            gate_arraylist_release(*(gate_arraylist_t*)ptr);
            *((gate_arraylist_t*)ptr) = NULL;
        }
        else if (type_length == 0)
        {
            ret = GATE_RESULT_FAILED;
        }
        else
        {
            gate_mem_clear(ptr, type_length);
        }
        break;
    }
    }
    return ret;
}



gate_result_t gate_struct_init(gate_struct_t* obj, gate_struct_descriptor_t const* descriptor)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    char* obj_ptr = (char*)obj;
    char* data_ptr;
    size_t index;

    do
    {
        if (obj == NULL)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }

        if (descriptor != NULL)
        {
            obj->struct_descriptor = descriptor;
        }
        else
        {
            descriptor = obj->struct_descriptor;
        }

        if (obj->struct_descriptor == NULL)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }

        ret = GATE_RESULT_OK;
        for (index = 0; index != descriptor->item_count; ++index)
        {
            data_ptr = obj_ptr + descriptor->items[index].offset;
            ret = gate_struct_item_init(descriptor->items[index].type, data_ptr);
            if (GATE_FAILED(ret))
            {
                /* release all previous created data */
                while (index != 0)
                {
                    --index;
                    data_ptr = obj_ptr + descriptor->items[index].offset;
                    gate_struct_item_release(descriptor->items[index].type, data_ptr);
                }
                break;
            }
        }
    } while (0);

    return ret;
}

gate_result_t gate_struct_copy(gate_struct_t* dst, gate_struct_t const* src)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    char* ptr_dst = (char*)dst;
    char const* ptr_src = (char const*)src;
    gate_size_t index;

    if (dst->struct_descriptor == NULL)
    {
        dst->struct_descriptor = src->struct_descriptor;
    }

    do
    {
        if (dst->struct_descriptor->item_count != src->struct_descriptor->item_count)
        {
            ret = GATE_RESULT_INCORRECTTYPE;
            break;
        }

        ret = GATE_RESULT_OK;

        for (index = 0; index != src->struct_descriptor->item_count; ++index)
        {
            if (dst->struct_descriptor->items[index].type == src->struct_descriptor->items[index].type)
            {
                ret = gate_type_copy(dst->struct_descriptor->items[index].type,
                    ptr_dst + dst->struct_descriptor->items[index].offset,
                    ptr_src + src->struct_descriptor->items[index].offset);
                if (GATE_FAILED(ret))
                {
                    while (index-- != 0)
                    {
                        gate_type_release(dst->struct_descriptor->items[index].type, ptr_dst + dst->struct_descriptor->items[index].offset);
                    }
                    break;
                }
            }
            else
            {
                ret = GATE_RESULT_INCORRECTTYPE;
                break;
            }
        }

    } while (0);


    return ret;
}

gate_size_t gate_struct_length(gate_struct_t const* src)
{
    return src->struct_descriptor->struct_length;
}

char const* gate_struct_get_name(gate_struct_t const* src)
{
    return src->struct_descriptor->name;
}

gate_size_t gate_struct_get_member_count(gate_struct_t const* src)
{
    return src->struct_descriptor->item_count;
}

gate_uint16_t gate_struct_get_member_type(gate_struct_t const* src, gate_size_t index)
{
    if (index >= src->struct_descriptor->item_count)
    {
        return 0;
    }
    return src->struct_descriptor->items[index].type;
}
gate_uint16_t gate_struct_get_member_type_by_string(gate_struct_t const* src, gate_string_t const* name)
{
    gate_size_t index;
    gate_size_t len;
    for (index = 0; index != src->struct_descriptor->item_count; ++index)
    {
        len = gate_str_length(src->struct_descriptor->items[index].name);
        if (0 == gate_str_compare(src->struct_descriptor->items[index].name, len, name->str, name->length))
        {
            return src->struct_descriptor->items[index].type;
        }
    }
    return GATE_TYPE_EMPTY;
}
gate_uint16_t gate_struct_get_member_type_by_name(gate_struct_t const* src, char const* name)
{
    gate_uint16_t type = GATE_TYPE_EMPTY;
    gate_string_t str_name = GATE_STRING_INIT_EMPTY;
    gate_string_create_static(&str_name, name);
    type = gate_struct_get_member_type_by_string(src, &str_name);
    gate_string_release(&str_name);
    return type;
}


char const* gate_struct_get_member_name(gate_struct_t const* src, gate_size_t index)
{
    if (index >= src->struct_descriptor->item_count)
    {
        return NULL;
    }
    return src->struct_descriptor->items[index].name;
}

void const* gate_struct_get_member(gate_struct_t const* src, gate_size_t index)
{
    if (index >= src->struct_descriptor->item_count)
    {
        return NULL;
    }
    return (void const*)(((char const*)src) + src->struct_descriptor->items[index].offset);
}

void const* gate_struct_get_member_by_string(gate_struct_t const* src, gate_string_t const* name)
{
    gate_size_t index;
    gate_size_t len;
    for (index = 0; index != src->struct_descriptor->item_count; ++index)
    {
        len = gate_str_length(src->struct_descriptor->items[index].name);
        if (0 == gate_str_compare(src->struct_descriptor->items[index].name, len, name->str, name->length))
        {
            return (void const*)(((char const*)src) + src->struct_descriptor->items[index].offset);
        }
    }
    return NULL;
}

void const* gate_struct_get_member_by_name(gate_struct_t const* src, char const* name)
{
    void const* ret = NULL;
    gate_string_t str_name = GATE_STRING_INIT_EMPTY;
    if (NULL != gate_string_create_static(&str_name, name))
    {
        ret = gate_struct_get_member_by_string(src, &str_name);
        gate_string_release(&str_name);
    }
    return ret;
}

void* gate_struct_get_mutable_member(gate_struct_t* src, gate_size_t index)
{
    if (index >= src->struct_descriptor->item_count)
    {
        return NULL;
    }
    return (void*)(((char*)src) + src->struct_descriptor->items[index].offset);
}


gate_result_t gate_struct_release(gate_struct_ptr_t obj)
{
    gate_result_t ret = GATE_RESULT_OK;
    char* data_ptr;
<--- The scope of the variable 'data_ptr' can be reduced. [+]
The scope of the variable 'data_ptr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    char* obj_ptr = (char*)obj;
    gate_size_t index = 0;
    if (obj->struct_descriptor)
    {
        for (index = 0; index != obj->struct_descriptor->item_count; ++index)
        {
            data_ptr = obj_ptr + obj->struct_descriptor->items[index].offset;
            gate_struct_item_release(obj->struct_descriptor->items[index].type, data_ptr);
        }
    }
    return ret;
}

gate_result_t gate_struct_copy_constructor(void* dest, void const* src)
{
    gate_result_t result = gate_struct_copy((gate_struct_t*)dest, (gate_struct_t const*)src);
    return result;
}

void gate_struct_destructor(void* dest)
{
    gate_struct_release((gate_struct_ptr_t)dest);
}