Cppcheck - HTML report - GATE C/C++ Framework

/* 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/runnables.h"
#include "gate/results.h"

static gate_size_t align_param_size(gate_size_t native_size)
{
    gate_size_t diff = native_size % sizeof(gate_c_maxalign_t);
    if (diff != 0)
    {
        native_size += (sizeof(gate_c_maxalign_t) - diff);
    }
    return native_size;
}

static void gate_runnable_count_sizes(gate_size_t* ptr_param_count, gate_size_t* ptr_param_sizes, gate_va_list_carrier_t* carrier)
{
    void* ptr_param;<--- The scope of the variable 'ptr_param' can be reduced. [+]The scope of the variable 'ptr_param' 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.
    gate_size_t param_size;

    *ptr_param_count = 0;
    *ptr_param_sizes = 0;

    for (;;)
    {
        ptr_param = va_arg(carrier->data, void*);
        if (!ptr_param)
        {
            break;
        }
        param_size = va_arg(carrier->data, size_t);
        param_size = align_param_size(param_size);
        ++(*ptr_param_count);
        *ptr_param_sizes += param_size;
    }
}

static void gate_runnable_copy_params(void** ptr_target_param, void* ptr_target_content, gate_va_list_carrier_t* carrier)
{
    char* ptr = (char*)ptr_target_content;
    void* src_param_ptr;<--- The scope of the variable 'src_param_ptr' can be reduced. [+]The scope of the variable 'src_param_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.
    size_t src_param_size;<--- The scope of the variable 'src_param_size' can be reduced. [+]The scope of the variable 'src_param_size' 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.

    for (;;)
    {
        src_param_ptr = va_arg(carrier->data, void*);
        if (!src_param_ptr)
        {
            break;
        }
        src_param_size = va_arg(carrier->data, size_t);

        gate_mem_copy((void*)ptr, src_param_ptr, src_param_size);

        *ptr_target_param = (void*)ptr;
        ++ptr_target_param;

        src_param_size = align_param_size(src_param_size);

        ptr += src_param_size;
    }
}

typedef struct gate_runner_disp_impl
{
    GATE_INTERFACE_VTBL(gate_runnable) const* vtbl;

    gate_atomic_int_t			ref_counter;
    gate_runnable_storage_t		store;
} gate_runner_disp_t;

static char const* disp_get_interface_name(void* obj)
{
    (void)obj;
    return GATE_INTERFACE_NAME_RUNNABLE;
}
static void disp_release(void* obj)
{
    gate_runner_disp_t* disp = (gate_runner_disp_t*)obj;
    if (gate_atomic_int_dec(&disp->ref_counter) == 0)
    {
        gate_mem_dealloc(disp);
    }
}
static int disp_retain(void* obj)
{
    gate_runner_disp_t* disp = (gate_runner_disp_t*)obj;
    return gate_atomic_int_inc(&disp->ref_counter);
}

static gate_result_t disp_run(void* obj)
{
    gate_runner_disp_t* disp = (gate_runner_disp_t*)obj;
    gate_result_t result = disp->store.dispatcher(&disp->store);
    return result;
}

static GATE_INTERFACE_VTBL(gate_runnable) gate_runnable_disp_vtbl;
static void gate_init_runnable_disp_vtbl()
{
    if (!gate_runnable_disp_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_runnable) const local_vtbl =
        {
            &disp_get_interface_name,
            &disp_release,
            &disp_retain,
            &disp_run
        };
        gate_runnable_disp_vtbl = local_vtbl;
    }
}

gate_runnable_t* gate_runnable_dispatcher_create(void* ptr_target_func, gate_size_t func_size,
    gate_runnable_dispatcher_t dispatcher,
    ...)
{
    gate_runner_disp_t* ret = NULL;
    gate_size_t param_count;
    gate_size_t param_size;
    gate_va_list_carrier_t carrier;
    gate_size_t total_size;

    do
    {
        va_start(carrier.data, dispatcher);
        gate_runnable_count_sizes(&param_count, &param_size, &carrier);
        va_end(carrier.data);

        total_size = sizeof(gate_runner_disp_t) + sizeof(void*) * param_count + param_size;
        ret = (gate_runner_disp_t*)gate_mem_alloc(total_size);
        if (ret == NULL)
        {
            break;
        }
        gate_mem_clear(ret, total_size);

        gate_init_runnable_disp_vtbl();
        ret->vtbl = &gate_runnable_disp_vtbl;
        gate_atomic_int_init(&ret->ref_counter, 1);

        gate_mem_copy(&ret->store.function_storage, &ptr_target_func, func_size);
        ret->store.dispatcher = dispatcher;

        va_start(carrier.data, dispatcher);
        gate_runnable_copy_params(&ret->store.parameters.params[0], &ret->store.parameters.params[param_count], &carrier);
        va_end(carrier.data);

    } while (0);

    return (gate_runnable_t*)ret;
}







typedef struct gate_taskimpl_class
{
    GATE_INTERFACE_VTBL(gate_task) const* vtbl;

    gate_atomic_int_t			ref_counter;
    gate_atomic_int_t			status;
    gate_result_t				task_result;
    gate_syncevent_t			signal;
    gate_task_storage_t			store;
} gate_taskimpl_t;

static char const* gate_taskimpl_get_interface_name(void* obj)
{
    GATE_UNUSED_ARG(obj);
    return GATE_INTERFACE_NAME_TASK;
}

static void gate_taskimpl_destroy(gate_taskimpl_t* impl)
{
    /* TODO */
    gate_syncevent_destroy(&impl->signal);
    gate_mem_dealloc(impl);
}

static void gate_taskimpl_release(void* obj)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    if (obj)
    {
        if (0 == gate_atomic_int_dec(&impl->ref_counter))
        {
            gate_taskimpl_destroy(impl);
        }
    }
}
static int gate_taskimpl_retain(void* obj)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    if (impl)
    {
        return gate_atomic_int_inc(&impl->ref_counter);
    }
    return 0;
}
static gate_bool_t gate_taskimpl_update_state(gate_taskimpl_t* impl, int from_state, int to_state)
{
    gate_int32_t old_state = gate_atomic_int_xchg_if(&impl->status, from_state, to_state);
    return old_state == from_state;
}

static gate_result_t gate_taskimpl_run(void* obj)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_int32_t old_state;
    gate_int32_t target_state;

    do
    {
        if (!gate_taskimpl_update_state(impl, GATE_TASK_STATUS_PREPARED, GATE_TASK_STATUS_RUNNING))
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }

        impl->task_result = impl->store.dispatcher(&impl->store);

        target_state = GATE_SUCCEEDED(impl->task_result) ? GATE_TASK_STATUS_COMPLETED : GATE_TASK_STATUS_FAILED;
        old_state = gate_atomic_int_xchg_if(&impl->status, GATE_TASK_STATUS_RUNNING, target_state);
        if (GATE_TASK_STATUS_RUNNING == old_state)
        {
            gate_syncevent_set(&impl->signal);
            ret = GATE_RESULT_OK;
        }
        else if (GATE_TASK_STATUS_CANCELED == old_state)
        {
            ret = GATE_RESULT_CANCELED;
        }
        else
        {
            ret = GATE_RESULT_INVALIDSTATE;
        }

    } while (0);

    return ret;
}

static gate_result_t gate_taskimpl_cancel(void* obj)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;

    if (gate_taskimpl_update_state(impl, GATE_TASK_STATUS_PREPARED, GATE_TASK_STATUS_CANCELED))
    {
        gate_syncevent_set(&impl->signal);
        return GATE_RESULT_OK;
    }

    if (gate_taskimpl_update_state(impl, GATE_TASK_STATUS_RUNNING, GATE_TASK_STATUS_CANCELED))
    {
        gate_syncevent_set(&impl->signal);
        return GATE_RESULT_OK;
    }

    return GATE_RESULT_INVALIDSTATE;
}
static int gate_taskimpl_get_status(void* obj)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    return gate_atomic_int_get(&impl->status);
}
static gate_bool_t gate_taskimpl_completed(void* obj)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    int state = gate_atomic_int_get(&impl->status);
    switch (state)
    {
    case GATE_TASK_STATUS_COMPLETED:
    case GATE_TASK_STATUS_CANCELED:
    case GATE_TASK_STATUS_FAILED:
        return true;
    }
    return false;
}
static gate_result_t gate_taskimpl_get_result(void* obj, gate_result_t* ptr_task_result, void const** ptr_task_data)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    gate_result_t task_result;
    void const* task_data = NULL;
    int state = gate_atomic_int_get(&impl->status);
    switch (state)
    {
    case GATE_TASK_STATUS_PREPARED:
    case GATE_TASK_STATUS_RUNNING:
        task_result = GATE_RESULT_INVALIDSTATE;
        break;
    case GATE_TASK_STATUS_COMPLETED:
    case GATE_TASK_STATUS_FAILED:
        task_result = impl->task_result;
        task_data = impl->store.parameters.params[0];
        break;
    case GATE_TASK_STATUS_CANCELED:
        task_result = GATE_RESULT_CANCELED;
        break;
    default:
        return GATE_RESULT_INVALIDSTATE;
    }
    if (ptr_task_result)
    {
        *ptr_task_result = task_result;
    }
    if (ptr_task_data)
    {
        *ptr_task_data = task_data;
    }
    return GATE_RESULT_OK;
}
static gate_result_t gate_taskimpl_wait(void* obj)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    return gate_syncevent_wait(&impl->signal);
}
static gate_result_t gate_taskimpl_timed_wait(void* obj, gate_uint32_t timeout_ms)
{
    gate_taskimpl_t* impl = (gate_taskimpl_t*)obj;
    return gate_syncevent_timed_wait(&impl->signal, timeout_ms);
}

static GATE_INTERFACE_VTBL(gate_task) gate_taskimpl_vtbl;

void gate_init_taskimpl_vtbl()
{
    if (!gate_taskimpl_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_task) const local_vtbl =
        {
            &gate_taskimpl_get_interface_name,
            &gate_taskimpl_release,
            &gate_taskimpl_retain,

            &gate_taskimpl_run,

            &gate_taskimpl_cancel,
            &gate_taskimpl_get_status,
            &gate_taskimpl_completed,
            &gate_taskimpl_get_result,
            &gate_taskimpl_wait,
            &gate_taskimpl_timed_wait
        };
        gate_taskimpl_vtbl = local_vtbl;
    }
}

gate_task_t* create_task()
{
    gate_task_t* ret = NULL;
    gate_taskimpl_t* impl = NULL;

    do
    {
        gate_init_taskimpl_vtbl();
        impl = (gate_taskimpl_t*)gate_mem_alloc(sizeof(gate_taskimpl_t));
        if (!impl)
        {
            break;
        }
        impl->vtbl = &gate_taskimpl_vtbl;
        gate_atomic_int_init(&impl->ref_counter, 1);
        gate_atomic_int_init(&impl->status, GATE_TASK_STATUS_PREPARED);

        ret = (gate_task_t*)impl;
        impl = NULL;
    } while (0);

    if (impl)
    {
        gate_taskimpl_destroy(impl);
    }

    return ret;
}


gate_task_t* gate_task_dispatcher_create(void* func_ptr, gate_size_t func_ptr_size,
    gate_task_dispatcher_t dispatcher,
    gate_size_t ret_type_size,
    ...)
{
    gate_task_t* ret = NULL;
    gate_taskimpl_t* impl = NULL;

    gate_size_t param_count;
    gate_size_t param_size;
    gate_va_list_carrier_t carrier;
    gate_size_t total_size;
    gate_result_t result;
    char* result_address;
    char* param_store_address;<--- The scope of the variable 'param_store_address' can be reduced. [+]The scope of the variable 'param_store_address' 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.

    do
    {
        va_start(carrier.data, ret_type_size);
        gate_runnable_count_sizes(&param_count, &param_size, &carrier);
        va_end(carrier.data);

        ret_type_size = align_param_size(ret_type_size);
        total_size = sizeof(gate_taskimpl_t) + sizeof(void*) * (param_count + 1) + ret_type_size + param_size;
        impl = (gate_taskimpl_t*)gate_mem_alloc(total_size);
        if (impl == NULL)
        {
            break;
        }
        gate_mem_clear(impl, total_size);

        gate_init_taskimpl_vtbl();

        impl->vtbl = &gate_taskimpl_vtbl;
        gate_atomic_int_init(&impl->ref_counter, 1);
        gate_atomic_int_init(&impl->status, GATE_TASK_STATUS_PREPARED);

        result = gate_syncevent_create(&impl->signal, false);
        if (GATE_FAILED(result))
        {
            break;
        }

        gate_mem_copy(&impl->store.function_storage, &func_ptr, func_ptr_size);
        impl->store.dispatcher = dispatcher;

        result_address = (char*)&impl->store.parameters.params[param_count + 1];
        param_store_address = result_address + ret_type_size;
        impl->store.parameters.params[0] = result_address;

        va_start(carrier.data, ret_type_size);
        gate_runnable_copy_params(&impl->store.parameters.params[1], param_store_address, &carrier);
        va_end(carrier.data);

        ret = (gate_task_t*)impl;
        impl = NULL;

    } while (0);

    if (impl != NULL)
    {
        gate_taskimpl_destroy(impl);
    }

    return ret;
}
Cppcheck report - GATE C/C++ Framework: gate/runnables.c
