Cppcheck report - GATE C/C++ Framework: gate/scripting/luascripts.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/scripting/luascripts.h"
#include "gate/results.h"
#include "gate/guids.h"
#include "gate/times.h"
#include "gate/console.h"
#include "gate/functions.h"
#include "gate/files.h"
#include "gate/platforms.h"

#if defined(GATE_EXTLIB_LUA)
#	define GATE_SCRIPTING_LUA_USE_LUA 1
#else
#	define GATE_SCRIPTING_LUA_NO_IMPL 1
#endif


#if defined(GATE_SCRIPTING_LUA_USE_LUA)

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>


#define GATE_SCRIPT_LUA_SESSION_POINTER_NAME "__gate_script_lua_session"

void gate_lua_writestring(char const* str, size_t len, gate_bool_t flushcon)
{
    gate_size_t written = 0;
    gate_console_t* con = gate_console();
    gate_stream_write_block((gate_stream_t*)con, str, len, &written);
    if (flushcon)
    {
        gate_stream_flush((gate_stream_t*)con);
    }
}

void gate_lua_writestring_err(char const* str, size_t len, gate_bool_t flushcon)
{
    gate_size_t written = 0;
    gate_console_t* con = gate_console();
    gate_stream_write_block((gate_stream_t*)con, str, len, &written);
    if (flushcon)
    {
        gate_stream_flush((gate_stream_t*)con);
    }
}

gate_result_t gate_script_lua_init(gate_script_lua_session_t* session)
{
    gate_result_t ret;

    do
    {
        gate_mem_clear(session, sizeof(gate_script_lua_session_t));
        ret = gate_script_lua_reset(session);
    } while (0);
    return ret;
}
gate_result_t gate_script_lua_uninit(gate_script_lua_session_t* session)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    lua_State* lstate = NULL;

    do
    {
        lstate = (lua_State*)session->state;
        if (lstate != NULL)
        {
            lua_close(lstate);
            session->state = NULL;
        }
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}
gate_result_t gate_script_lua_reset(gate_script_lua_session_t* session)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    lua_State* lstate = NULL;

    do
    {
        lstate = luaL_newstate();
        if (NULL == lstate)
        {
            ret = GATE_RESULT_OUTOFRESOURCES;
            break;
        }

        luaopen_base(lstate);
        luaopen_table(lstate);
        luaopen_string(lstate);
        luaopen_math(lstate);
        luaopen_coroutine(lstate);
        luaopen_utf8(lstate);

        if (session->state != NULL)
        {
            lua_close((lua_State*)session->state);
        }
        lua_pushlightuserdata(lstate, session);
        lua_setglobal(lstate, GATE_SCRIPT_LUA_SESSION_POINTER_NAME);
        session->state = lstate;
        lstate = NULL;
        ret = GATE_RESULT_OK;
    } while (0);

    if (lstate != NULL)
    {
        lua_close(lstate);
    }

    return ret;
}

static gate_script_lua_session_t* gate_script_lua_get_session(lua_State* L)
{
    lua_getglobal(L, GATE_SCRIPT_LUA_SESSION_POINTER_NAME);
    return (gate_script_lua_session_t*)lua_touserdata(L, -1);
}


struct gate_script_lua_code_block
{
    char const* data;
    gate_size_t	size;
};

static char const* gate_script_lua_code_reader(lua_State* L, void* data, size_t* size)
{
    char const* ret = NULL;
    struct gate_script_lua_code_block* block = (struct gate_script_lua_code_block*)data;

    (void)L;
    *size = 0;
    if (block->size > 0)
    {
        ret = block->data;
        *size = block->size;

        block->data += block->size;
        block->size = 0;
    }
    return ret;
}

static gate_result_t gate_script_lua_map_error(int lua_result_code)
{
    switch (lua_result_code)
    {
    case LUA_OK:		return GATE_RESULT_OK;
    case LUA_YIELD:		return GATE_RESULT_OK_PARTIAL;
    case LUA_ERRRUN:	return GATE_RESULT_EXECUTIONFAILED;
    case LUA_ERRSYNTAX:	return GATE_RESULT_INVALIDDATA;
    case LUA_ERRMEM:	return GATE_RESULT_OUTOFMEMORY;
    case LUA_ERRERR:	return GATE_RESULT_CRITICALERROR;
    default:			return GATE_RESULT_FAILED;
    }
}

static gate_result_t gate_script_lua_load_impl(lua_State* lstate, gate_string_t const* code, gate_bool_t print_error)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    int result;
<--- The scope of the variable 'result' can be reduced. [+]
The scope of the variable 'result' 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.
    struct gate_script_lua_code_block block;

    (void)print_error;
    do
    {
        block.data = gate_string_ptr(code, 0);
        block.size = gate_string_length(code);
        result = lua_load(lstate, &gate_script_lua_code_reader, &block, "gate_lua_code", NULL);
        ret = gate_script_lua_map_error(result);
        GATE_BREAK_IF_FAILED(ret);

        result = lua_pcall(lstate, 0, 0, 0);
        ret = gate_script_lua_map_error(result);
        GATE_BREAK_IF_FAILED(ret);
    } while (0);

    return ret;

}

gate_result_t gate_script_lua_load(gate_script_lua_session_t* session, gate_string_t const* code)
{
    return gate_script_lua_load_impl((lua_State*)session->state, code, false);
}


static gate_result_t gate_script_lua_push_value(lua_State* L, gate_value_t const* val)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_type_id_t value_type = gate_value_type(val);
    void const* value_ptr = gate_value_get_ptr(val);

    char buffer[8192];
    gate_size_t buffer_used = 0;
    gate_datetime_t datetime = GATE_INIT_EMPTY;

    do
    {
        if (!value_ptr)
        {
            ret = GATE_RESULT_NOTAVAILABLE;
            break;
        }

        ret = GATE_RESULT_OK;

        switch (value_type)
        {
        case GATE_TYPE_BOOL:	lua_pushboolean(L, *((gate_bool_t const*)value_ptr) ? 1 : 0); break;
        case GATE_TYPE_I8:		lua_pushinteger(L, (lua_Integer) * ((gate_int8_t const*)value_ptr)); break;
        case GATE_TYPE_UI8:		lua_pushinteger(L, (lua_Integer) * ((gate_uint8_t const*)value_ptr)); break;
        case GATE_TYPE_I16:		lua_pushinteger(L, (lua_Integer) * ((gate_int16_t const*)value_ptr)); break;
        case GATE_TYPE_UI16:	lua_pushinteger(L, (lua_Integer) * ((gate_uint16_t const*)value_ptr)); break;
        case GATE_TYPE_I32:		lua_pushinteger(L, (lua_Integer) * ((gate_int32_t const*)value_ptr)); break;
        case GATE_TYPE_UI32:	lua_pushinteger(L, (lua_Integer) * ((gate_uint32_t const*)value_ptr)); break;
        case GATE_TYPE_I64:		lua_pushinteger(L, (lua_Integer) * ((gate_int64_t const*)value_ptr)); break;
        case GATE_TYPE_UI64:	lua_pushinteger(L, (lua_Integer) * ((gate_uint64_t const*)value_ptr)); break;
        case GATE_TYPE_ADDRESS:	lua_pushinteger(L, (lua_Integer) * ((gate_uintptr_t const*)value_ptr)); break;
        case GATE_TYPE_R32:		lua_pushnumber(L, (lua_Number) * ((gate_real32_t const*)value_ptr)); break;
        case GATE_TYPE_R64:		lua_pushnumber(L, (lua_Number) * ((gate_real64_t const*)value_ptr)); break;

        case GATE_TYPE_CSTR:	lua_pushlstring(L, (char const*)value_ptr, gate_str_length((char const*)value_ptr)); break;
        case GATE_TYPE_WSTR:
            buffer_used = gate_str_utf16_2_utf8((gate_char16_t const*)value_ptr,
                gate_str16_length((gate_char16_t const*)value_ptr),
                buffer, sizeof(buffer));
            lua_pushlstring(L, buffer, buffer_used);
            break;
        case GATE_TYPE_GUID:
            gate_guid_to_string((gate_guid_t const*)value_ptr, buffer);
            lua_pushlstring(L, buffer, 36);
            break;
        case GATE_TYPE_DATE:
            datetime.date = *((gate_date_t const*)value_ptr);
            buffer_used = sizeof(buffer);
            gate_date_to_string(&datetime, 0, "{YYYY}-{MM}-{DD}", buffer, &buffer_used);
            lua_pushlstring(L, buffer, buffer_used);
            break;
        case GATE_TYPE_DAYTIME:
            datetime.time = *((gate_daytime_t const*)value_ptr);
            buffer_used = sizeof(buffer);
            gate_date_to_string(&datetime, 0, "{hh}:{mm}:{ss}.{SSS}", buffer, &buffer_used);
            lua_pushlstring(L, buffer, buffer_used);
            break;
        case GATE_TYPE_DATETIME:
            buffer_used = sizeof(buffer);
            gate_date_to_string((gate_datetime_t const*)value_ptr, 0, NULL, buffer, &buffer_used);
            lua_pushlstring(L, buffer, buffer_used);
            break;
        case GATE_TYPE_TIME:
            gate_time_to_datetime((gate_time_t const*)value_ptr, &datetime);
            buffer_used = sizeof(buffer);
            gate_date_to_string((gate_datetime_t const*)value_ptr, 0, NULL, buffer, &buffer_used);
            lua_pushlstring(L, buffer, buffer_used);
            break;
        case GATE_TYPE_STRING:
            lua_pushlstring(L, gate_string_ptr((gate_string_t const*)value_ptr, 0),
                gate_string_length((gate_string_t const*)value_ptr));
            break;


        default:
            ret = GATE_RESULT_NOTSUPPORTED;
            break;
        }


    } while (0);

    return ret;
}


static gate_result_t gate_script_lua_get_value(lua_State* L, int index, gate_value_t* value)
{
    int ltype = lua_type(L, index);

    gate_value_t* ret_value = NULL;
    gate_bool_t bool_val = false;
    gate_real64_t real_val = 0.0;
    gate_string_t str_val = GATE_STRING_INIT_EMPTY;
    size_t str_len = 0;
    gate_cstr_t cstr = NULL;


    switch (ltype)
    {
    case LUA_TNIL:
    {
        ret_value = gate_value_create(GATE_TYPE_EMPTY, NULL, value);
        break;
    }
    case LUA_TBOOLEAN:
    {
        bool_val = (lua_toboolean(L, index) == 0) ? false : true;
        ret_value = gate_value_create(GATE_TYPE_BOOL, &bool_val, value);
        break;
    }
    case LUA_TNUMBER:
    {
        real_val = (gate_real64_t)lua_tonumber(L, index);
        ret_value = gate_value_create(GATE_TYPE_R64, &real_val, value);
        break;
    }
    case LUA_TSTRING:
    {
        cstr = lua_tolstring(L, index, &str_len);
        if (gate_string_create(&str_val, cstr, str_len))
        {
            ret_value = gate_value_create(GATE_TYPE_STRING, &str_val, value);
        }
        break;
    }
    case LUA_TFUNCTION:
    case LUA_TTABLE:
    default:
    {
        break;
    }
    }

    gate_string_release(&str_val);
    return ret_value == NULL ? GATE_RESULT_NOTSUPPORTED : GATE_RESULT_OK;
}

gate_result_t gate_script_lua_invoke(gate_script_lua_session_t* session, gate_string_t const* func_name,
    gate_value_t* args, gate_size_t arg_count, gate_value_t* ret_val)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    lua_State* lstate;
<--- The scope of the variable 'lstate' can be reduced. [+]
The scope of the variable 'lstate' 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.
    int result;
<--- The scope of the variable 'result' can be reduced. [+]
The scope of the variable 'result' 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 buffer[4096];
    int index;

    do
    {
        lstate = (lua_State*)session->state;
        gate_string_to_buffer(func_name, buffer, sizeof(buffer));

        lua_checkstack(lstate, (int)(arg_count + 2));
        result = lua_getglobal(lstate, buffer);
        ret = gate_script_lua_map_error(result);
        GATE_BREAK_IF_FAILED(ret);

        for (index = 0; index != arg_count; ++index)
        {
            ret = gate_script_lua_push_value(lstate, &args[index]);
            if (GATE_FAILED(ret))
            {
                lua_pop(lstate, index + 1);
                break;
            }
        }
        GATE_BREAK_IF_FAILED(ret);

        result = lua_pcall(lstate, (int)arg_count, 1, 0);
        ret = gate_script_lua_map_error(result);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_script_lua_get_value(lstate, -1, ret_val);
        lua_pop(lstate, 1);

    } while (0);

    return ret;
}
gate_result_t gate_script_lua_set_var(gate_script_lua_session_t* session,
    gate_string_t const* name, gate_value_t const* value)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    lua_State* lstate;
<--- The scope of the variable 'lstate' can be reduced. [+]
The scope of the variable 'lstate' 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 buffer[4096];

    do
    {
        gate_string_to_buffer(name, buffer, sizeof(buffer));
        lstate = (lua_State*)session->state;
        ret = gate_script_lua_push_value(lstate, value);
        lua_setglobal(lstate, buffer);
    } while (0);
    return ret;
}
gate_result_t gate_script_lua_get_var(gate_script_lua_session_t* session,
    gate_string_t const* name, gate_value_t* value)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    lua_State* lstate;
<--- The scope of the variable 'lstate' can be reduced. [+]
The scope of the variable 'lstate' 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 buffer[4096];

    do
    {
        gate_string_to_buffer(name, buffer, sizeof(buffer));
        lstate = (lua_State*)session->state;
        lua_getglobal(lstate, buffer);

        ret = gate_script_lua_get_value(lstate, -1, value);
        GATE_BREAK_IF_FAILED(ret);

        lua_pop(lstate, 1);
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}

gate_result_t gate_script_lua_cfunc_add(
    gate_script_lua_session_t* session,
    gate_string_t const* func_name,
    int(*lua_cfunc)(void* lstate),
    void* userparam)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    lua_State* lstate;
<--- The scope of the variable 'lstate' can be reduced. [+]
The scope of the variable 'lstate' 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_cstrbuffer_t name_buffer = GATE_INIT_EMPTY;

    do
    {
        if (!session || !func_name || !lua_cfunc)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }

        if (NULL == gate_cstrbuffer_create_string(&name_buffer, func_name, false))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        lstate = (lua_State*)session->state;

        if (userparam)
        {
            /* add userparam to stack */
            lua_pushlightuserdata(lstate, userparam);
            lua_pushcclosure(lstate, (lua_CFunction)lua_cfunc, 1);
        }
        else
        {
            /* add function dispatcher with one upvalue (cfunc-def) */
            lua_pushcclosure(lstate, (lua_CFunction)lua_cfunc, 0);
        }

        /* set global name of function */
        lua_setglobal(lstate, gate_cstrbuffer_get(&name_buffer));

        ret = GATE_RESULT_OK;
    } while (0);

    gate_cstrbuffer_destroy(&name_buffer);

    return ret;
}

gate_size_t gate_script_lua_cfunc_get_arg_count(void* lstate)
{
    lua_State* L = (lua_State*)lstate;
    return (gate_size_t)lua_gettop(L);
}

static void lua_stack_get_bool(lua_State* state, int index, gate_bool_t* ptr)
{
    *ptr = lua_toboolean(state, index) == 0 ? false : true;
}

static void lua_stack_get_int(lua_State* state, int index, gate_int32_t* ptr)
{
    *ptr = (gate_int32_t)lua_tointeger(state, index);
}

static void lua_stack_get_number(lua_State* state, int index, gate_real64_t* ptr)
{
    *ptr = (gate_real64_t)lua_tonumber(state, index);
}

static void lua_stack_get_string(lua_State* state, int index, gate_string_t* ptr)
{
    size_t len = 0;
    char const* str = lua_tolstring(state, index, &len);
    gate_string_create(ptr, str, len);
}

static gate_result_t lua_stack_item_to_prop(lua_State* L, int index, gate_property_t* prop)
{
    gate_result_t result;
    gate_property_t* ret = NULL;
    if (lua_isboolean(L, index))
    {
        gate_bool_t v = false;
        lua_stack_get_bool(L, index, &v);
        ret = gate_property_create_bool(prop, v);
    }
    else if (lua_isinteger(L, index))
    {
        gate_int32_t v = 0;
        lua_stack_get_int(L, index, &v);
        ret = gate_property_create_int(prop, (gate_int64_t)v);
    }
    else if (lua_isnumber(L, index))
    {
        gate_real64_t v = 0.0;
        lua_stack_get_number(L, index, &v);
        ret = gate_property_create_real(prop, (gate_real64_t)v);
    }
    else if (lua_isstring(L, index))
    {
        gate_string_t gstr = GATE_STRING_INIT_EMPTY;
        lua_stack_get_string(L, index, &gstr);
        ret = gate_property_create_string(prop, &gstr);
        gate_string_release(&gstr);
    }
    else if (lua_istable(L, index))
    {
        gate_bool_t prop_init = false;
        /* empty-pre-first-key to search next: */
        lua_pushnil(L);

        /* search next key from stack and push key-vakue pair */
        while (lua_next(L, index) != 0)
        {
            gate_property_t item = GATE_INIT_EMPTY;
            result = lua_stack_item_to_prop(L, -1, &item);
            if (GATE_SUCCEEDED(result))
            {
                if (lua_isnumber(L, -2))
                {
                    lua_Integer tbl_ndx = lua_tointeger(L, -2);
                    if (!prop_init)
                    {
                        /* first key is a number -> table is an array */
                        ret = gate_property_create_array(prop, NULL, 0);
                        prop_init = true;
                    }
                    gate_property_array_add(prop, &item);
                }
                else if (lua_isstring(L, -2))
                {
                    size_t key_len;
                    char const* key_value;
                    gate_string_t key_str = GATE_STRING_INIT_EMPTY;
                    if (!prop_init)
                    {
                        /* first key is a string -> table is a property object */
                        ret = gate_property_create_object(prop);
                        prop_init = true;
                    }
                    key_value = lua_tolstring(L, -2, &key_len);
                    gate_string_create(&key_str, key_value, key_len);
                    gate_property_member_add(prop, &key_str, &item);
                    gate_string_release(&key_str);
                }

                gate_property_destroy(&item);
            }
            lua_pop(L, 1);
        }
    }
    if (ret == NULL)
    {
        return GATE_RESULT_FAILED;
    }
    return GATE_RESULT_OK;
}

gate_result_t gate_script_lua_cfunc_get_stack_item(void* lstate, int arg_index, gate_property_t* prop)
{
    lua_State* const L = (lua_State*)lstate;
    return lua_stack_item_to_prop(L, arg_index, prop);
}

gate_result_t gate_script_lua_cfunc_get_arg(void* lstate, gate_size_t arg_index, gate_property_t* prop)
{
    lua_State* const L = (lua_State*)lstate;
    int const lua_func_arg_count = lua_gettop(L);
    int const lua_func_arg_index = (int)arg_index + 1;

    if (lua_func_arg_index > lua_func_arg_count)
    {
        return GATE_RESULT_OUTOFBOUNDS;
    }

    return lua_stack_item_to_prop(L, lua_func_arg_index, prop);
}


static void lua_stack_push_property(lua_State* L, gate_property_t const* prop)
{
    switch (gate_property_get_type(prop))
    {
    case GATE_PROPERTY_TYPE_EMPTY:
    {
        lua_pushnil(L);
        return;
    }
    case GATE_PROPERTY_TYPE_BOOL:
    {
        gate_bool_t b = false;
        gate_property_get_bool(prop, &b);
        lua_pushboolean(L, b ? 1 : 0);
        return;
    }
    case GATE_PROPERTY_TYPE_INT:
    {
        gate_int64_t v = 0;
        gate_property_get_int(prop, &v);
        if ((v < -2147483648LL) || (v > 2147483647LL))
        {
            lua_pushnumber(L, (lua_Number)v);
        }
        else
        {
            lua_pushinteger(L, (lua_Integer)v);
        }
        return;
    }
    case GATE_PROPERTY_TYPE_REAL:
    {
        gate_real64_t v = 0.0;
        gate_property_get_real(prop, &v);
        lua_pushnumber(L, (lua_Number)v);
        return;
    }
    case GATE_PROPERTY_TYPE_STRING:
    {
        gate_string_t str = GATE_STRING_INIT_EMPTY;
        gate_property_get_string(prop, &str);
        lua_pushlstring(L, gate_string_ptr(&str, 0), gate_string_length(&str));
        gate_string_release(&str);
        return;
    }
    case GATE_PROPERTY_TYPE_ARRAY:
    {
        gate_size_t ndx;
        const gate_size_t length = gate_property_array_length(prop);
        lua_createtable(L, (int)length, 0);
        for (ndx = 0; ndx < (int)length; ++ndx)
        {
            gate_property_t const* item = gate_property_array_get(prop, ndx);
            if (item)
            {
                lua_stack_push_property(L, item);
            }
            else
            {
                lua_pushnil(L);
            }
            lua_rawseti(L, -2, (lua_Integer)(ndx + 1));
        }
        return;
    }
    case GATE_PROPERTY_TYPE_OBJECT:
    {
        gate_size_t ndx, length;
        gate_array_t names = GATE_INIT_EMPTY;
        gate_property_member_names(prop, &names);
        length = gate_array_length(&names);

        lua_newtable(L);
        for (ndx = 0; ndx != length; ++ndx)
        {
            gate_string_t const* name = (gate_string_t const*)gate_array_get(&names, ndx);
            gate_property_t const* item;
            if (!name)
            {
                continue;
            }
            item = gate_property_member_get(prop, name);
            if (!item)
            {
                continue;
            }
            lua_pushlstring(L, gate_string_ptr(name, 0), gate_string_length(name));
            lua_stack_push_property(L, item);
            lua_settable(L, -3);
        }
        return;
    }
    }
}

gate_result_t gate_script_lua_cfunc_push_stack_item(void* lstate, gate_property_t const* prop)
{
    lua_State* const L = (lua_State*)lstate;
    if (!L || !prop)
    {
        return GATE_RESULT_INVALIDARG;
    }
    lua_stack_push_property(L, prop);
    return GATE_RESULT_OK;
}

gate_size_t gate_script_lua_cfunc_def_param_count(gate_script_lua_cfunc_def_t const* cfunc_def)
{
    unsigned ndx;
    for (ndx = 0; ndx != GATE_SCRIPTING_LUA_MAX_FUNC_PARAMS; ++ndx)
    {
        if (cfunc_def->params[ndx] == GATE_TYPE_VOID)
        {
            return ndx;
        }
    }
    return GATE_SCRIPTING_LUA_MAX_FUNC_PARAMS;
}

#define CREATE_INT_VALUE(native_type)	\
	const native_type v = (native_type)lua_tointeger(L, lua_param_index); \
	gate_value_create(required_type, &v, ptr_val)

#define CREATE_NUM_VALUE(native_type)	\
	const native_type v = (native_type)lua_tonumber(L, lua_param_index); \
	gate_value_create(required_type, &v, ptr_val)


static gate_result_t load_lua_params(lua_State* L, gate_type_id_t required_type, int lua_param_index, gate_value_t* ptr_val)
{
    gate_result_t ret = GATE_RESULT_OK;

    switch (required_type)
    {
    case GATE_TYPE_BOOL:
    {
        const gate_bool_t v = lua_toboolean(L, lua_param_index);
        gate_value_create(GATE_TYPE_BOOL, &v, ptr_val);
        break;
    }
    case GATE_TYPE_I8: { CREATE_INT_VALUE(gate_int8_t); break; }
    case GATE_TYPE_UI8: { CREATE_INT_VALUE(gate_uint8_t); break; }
    case GATE_TYPE_I16: { CREATE_INT_VALUE(gate_int16_t); break; }
    case GATE_TYPE_UI16: { CREATE_INT_VALUE(gate_uint16_t); break; }
    case GATE_TYPE_I32: { CREATE_INT_VALUE(gate_int32_t); break; }
    case GATE_TYPE_UI32: { CREATE_INT_VALUE(gate_uint32_t); break; }
    case GATE_TYPE_I64: { CREATE_NUM_VALUE(gate_int64_t); break; }
    case GATE_TYPE_UI64: { CREATE_NUM_VALUE(gate_uint64_t); break; }
    case GATE_TYPE_R32: { CREATE_NUM_VALUE(gate_real32_t); break; }
    case GATE_TYPE_R64: { CREATE_NUM_VALUE(gate_real64_t); break; }
    case GATE_TYPE_ADDRESS:
    case GATE_TYPE_DATAPTR:
    case GATE_TYPE_FUNCPTR:
    {
        ret = GATE_RESULT_NOTSUPPORTED;
        break;
    }
    case GATE_TYPE_CSTR:
    {
        size_t l;
        gate_cstr_t s = luaL_tolstring(L, lua_param_index, &l);
        gate_value_create(GATE_TYPE_CSTR, &s, ptr_val);
        break;
    }
    case GATE_TYPE_WSTR:
    case GATE_TYPE_GUID:
    {
        ret = GATE_RESULT_NOTSUPPORTED;
        break;
    }
    case GATE_TYPE_DATE:
    {
        gate_time_t tm = GATE_INIT_EMPTY;
        gate_datetime_t dt = GATE_INIT_EMPTY;
        const gate_int64_t unix_seconds = (gate_int64_t)lua_tointeger(L, lua_param_index);
        gate_time_from_unix(unix_seconds, &tm.timestamp);
        gate_time_to_datetime(&tm, &dt);
        gate_value_create(GATE_TYPE_DATE, &dt.date, ptr_val);
        break;
    }
    case GATE_TYPE_DAYTIME:
    {
        gate_time_t tm = GATE_INIT_EMPTY;
        gate_datetime_t dt = GATE_INIT_EMPTY;
        const gate_int64_t unix_seconds = (gate_int64_t)lua_tointeger(L, lua_param_index);
        gate_time_from_unix(unix_seconds, &tm.timestamp);
        gate_time_to_datetime(&tm, &dt);
        gate_value_create(GATE_TYPE_DAYTIME, &dt.time, ptr_val);
        break;
    }
    case GATE_TYPE_DATETIME:
    {
        gate_time_t tm = GATE_INIT_EMPTY;
        gate_datetime_t dt = GATE_INIT_EMPTY;
        const gate_int64_t unix_seconds = (gate_int64_t)lua_tointeger(L, lua_param_index);
        gate_time_from_unix(unix_seconds, &tm.timestamp);
        gate_time_to_datetime(&tm, &dt);
        gate_value_create(GATE_TYPE_DATETIME, &dt, ptr_val);
        break;
    }
    case GATE_TYPE_TIME:
    {
        gate_time_t tm = GATE_INIT_EMPTY;
        const gate_int64_t unix_seconds = (gate_int64_t)lua_tointeger(L, lua_param_index);
        gate_time_from_unix(unix_seconds, &tm.timestamp);
        gate_value_create(GATE_TYPE_TIME, &tm, ptr_val);
        break;
    }
    case GATE_TYPE_STRING:
    {
        gate_string_t str = GATE_STRING_INIT_EMPTY;
        size_t l;
        gate_cstr_t s = luaL_tolstring(L, lua_param_index, &l);
        gate_string_create(&str, s, l);
        gate_value_create(GATE_TYPE_STRING, &str, ptr_val);
        gate_string_release(&str);
        break;
    }
    case GATE_TYPE_BLOB:
    {
        gate_blob_t blob = GATE_INIT_EMPTY;
        size_t l;
        gate_cstr_t s = luaL_tolstring(L, lua_param_index, &l);
        gate_blob_create(&blob, s, l);
        gate_value_create(GATE_TYPE_BLOB, &blob, ptr_val);
        gate_blob_release(&blob);
        break;
    }
    case GATE_TYPE_STRUCT:
    case GATE_TYPE_OBJECT:
    case GATE_TYPE_PROPERTY:

    case GATE_TYPE_ARRAY:
    case GATE_TYPE_ARRAYLIST:
    case GATE_TYPE_ARRAYLIST_BOOL:
    case GATE_TYPE_ARRAYLIST_I8:
    case GATE_TYPE_ARRAYLIST_UI8:
    case GATE_TYPE_ARRAYLIST_I16:
    case GATE_TYPE_ARRAYLIST_UI16:
    case GATE_TYPE_ARRAYLIST_I32:
    case GATE_TYPE_ARRAYLIST_UI32:
    case GATE_TYPE_ARRAYLIST_I64:
    case GATE_TYPE_ARRAYLIST_UI64:
    case GATE_TYPE_ARRAYLIST_R32:
    case GATE_TYPE_ARRAYLIST_R64:
    case GATE_TYPE_ARRAYLIST_ADDRESS:

    case GATE_TYPE_ARRAYLIST_DATAPTR:
    case GATE_TYPE_ARRAYLIST_FUNCPTR:
    case GATE_TYPE_ARRAYLIST_CSTR:
    case GATE_TYPE_ARRAYLIST_WSTR:
    case GATE_TYPE_ARRAYLIST_GUID:
    case GATE_TYPE_ARRAYLIST_DATE:
    case GATE_TYPE_ARRAYLIST_DAYTIME:
    case GATE_TYPE_ARRAYLIST_DATETIME:
    case GATE_TYPE_ARRAYLIST_TIME:

    case GATE_TYPE_ARRAYLIST_STRING:
    case GATE_TYPE_ARRAYLIST_ARRAY:
    case GATE_TYPE_ARRAYLIST_BLOB:

    case GATE_TYPE_ARRAYLIST_STRUCT:
    case GATE_TYPE_ARRAYLIST_OBJECT:
    case GATE_TYPE_ARRAYLIST_PROPERTY:
    default:
    {
        /*TODO*/
        ret = GATE_RESULT_NOTSUPPORTED;
        break;
    }

    }

    return ret;
}

static gate_result_t convert_value_to_func_arg(gate_value_t const* ptr_val, gate_function_argument_t* ptr_arg)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_type_id_t const gt = gate_value_type(ptr_val);
    switch (gt)
    {
    case GATE_TYPE_BOOL:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_UCHAR;
        ptr_arg->arg_value.u_chr = ptr_val->content.bool_value;
        break;
    case GATE_TYPE_I8:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_SCHAR;
        ptr_arg->arg_value.s_chr = ptr_val->content.i8_value;
        break;
    case GATE_TYPE_UI8:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_UCHAR;
        ptr_arg->arg_value.u_chr = ptr_val->content.ui8_value;
        break;
    case GATE_TYPE_I16:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_SSHORT;
        ptr_arg->arg_value.s_short = ptr_val->content.i16_value;
        break;
    case GATE_TYPE_UI16:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_USHORT;
        ptr_arg->arg_value.u_short = ptr_val->content.ui16_value;
        break;
    case GATE_TYPE_I32:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_SLONG;
        ptr_arg->arg_value.s_long = ptr_val->content.i32_value;
        break;
    case GATE_TYPE_UI32:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_ULONG;
        ptr_arg->arg_value.u_long = ptr_val->content.ui32_value;
        break;
    case GATE_TYPE_I64:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_SLONGLONG;
        ptr_arg->arg_value.s_long_long = ptr_val->content.i64_value;
        break;
    case GATE_TYPE_UI64:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_ULONGLONG;
        ptr_arg->arg_value.u_long_long = ptr_val->content.ui64_value;
        break;
    case GATE_TYPE_R32:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_FLOAT;
        ptr_arg->arg_value.flt = ptr_val->content.r32_value;
        break;
    case GATE_TYPE_R64:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_DOUBLE;
        ptr_arg->arg_value.dbl = ptr_val->content.r64_value;
        break;
        /* pointer types: */
    case GATE_TYPE_ADDRESS:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)ptr_val->content.address_value;
        break;
    case GATE_TYPE_DATAPTR:
    case GATE_TYPE_FUNCPTR:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = ptr_val->content.ptr_value;
        break;
    case GATE_TYPE_CSTR:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)ptr_val->content.cstring_value;
        break;
    case GATE_TYPE_WSTR:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)ptr_val->content.wstring_value;
        break;
    case GATE_TYPE_GUID:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.guid_value;
        break;
    case GATE_TYPE_DATE:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.date_value;
        break;
    case GATE_TYPE_DAYTIME:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.daytime_value;
        break;
    case GATE_TYPE_DATETIME:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.datetime_value;
        break;
    case GATE_TYPE_TIME:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.time_value;
        break;
    case GATE_TYPE_STRING:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.string_value;
        break;
    case GATE_TYPE_BLOB:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.blob_value;
        break;
    case GATE_TYPE_ARRAY:
        ptr_arg->arg_type = GATE_FUNCTION_ARG_POINTER;
        ptr_arg->arg_value.ptr = (void*)&ptr_val->content.array_value;
        break;
    default:
        ret = GATE_RESULT_NOTSUPPORTED;
        break;
    }
    return ret;
}

static int gate_lua_cfunc_dispatcher(lua_State* L)
{
    static char const* const error_msg_fmt = "LUA C-function dispatcher error: #%d %s";
    int const lua_func_arg_count = lua_gettop(L);
    gate_script_lua_cfunc_def_t const* const cfunc_def =
        (gate_script_lua_cfunc_def_t const*)lua_touserdata(L, lua_upvalueindex(1));
    gate_size_t cfunc_count = 0;
    gate_value_t value_store[GATE_SCRIPTING_LUA_MAX_FUNC_PARAMS] = GATE_INIT_EMPTY;
    gate_function_argument_t cfunc_args[GATE_SCRIPTING_LUA_MAX_FUNC_PARAMS] = GATE_INIT_EMPTY;
    gate_function_argument_t ret_val = GATE_INIT_EMPTY;
    int ret = 0;
    int ndx;
    gate_result_t result;

    do
    {
        if (NULL == cfunc_def)
        {
            ret = luaL_error(L, error_msg_fmt, 1, "internal lua_cfunc_def parameter is missing");
            break;
        }

        cfunc_count = gate_script_lua_cfunc_def_param_count(cfunc_def);

        if (lua_func_arg_count < (int)cfunc_count)
        {
            ret = luaL_error(L, error_msg_fmt, (int)cfunc_count, " required parameters not available");
            break;
        }

        if (lua_func_arg_count > GATE_SCRIPTING_LUA_MAX_FUNC_PARAMS)
        {
            ret = luaL_error(L, error_msg_fmt, (int)lua_func_arg_count, " too many parameters");
            break;
        }

        /* store lua parameters as gate_value objects */
        for (ndx = 0; ndx < (int)cfunc_count; ++ndx)
        {
            result = load_lua_params(L, cfunc_def->params[ndx], ndx + 1, &value_store[ndx]);
        }

        /* create generic function args from gate_value objects */
        for (ndx = 0; ndx < (int)cfunc_count; ++ndx)
        {
            result = convert_value_to_func_arg(&value_store[ndx], &cfunc_args[ndx]);
        }

        /* call native gate-function pointer */
        result = gate_function_invoke_generic(cfunc_def->func_ptr, 0, cfunc_args, cfunc_count, &ret_val);


    } while (0);

    for (ndx = 0; ndx < (int)cfunc_count; ++ndx)
    {
        gate_value_release(&value_store[ndx]);
    }

    return ret;
}

gate_result_t gate_script_lua_add_function(
    gate_script_lua_session_t* session,
    gate_string_t const* func_name,
    gate_script_lua_cfunc_def_t const* func_def)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    lua_State* lstate;
<--- The scope of the variable 'lstate' can be reduced. [+]
The scope of the variable 'lstate' 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.
    void* const cfunc_def_param = (void*)func_def;
    char name[128];

    do
    {
        gate_string_to_buffer(func_name, name, sizeof(name));

        lstate = (lua_State*)session->state;

        /* push pointer to function definition as upvalue for function */
        lua_pushlightuserdata(lstate, cfunc_def_param);

        /* add function dispatcher with one upvalue (cfunc-def) */
        lua_pushcclosure(lstate, &gate_lua_cfunc_dispatcher, 1);

        /* set global name of function */
        lua_setglobal(lstate, name);

        ret = GATE_RESULT_OK;

    } while (0);

    return ret;
}


static int gate_lua_print(lua_State* L)
{
    int n = lua_gettop(L);	/* number of arguments */
    int i;
    for (i = 1; i <= n; i++)
    {
        size_t l;
        const char* s = luaL_tolstring(L, i, &l);  /* convert it to string */
        if (i > 1)
        {
            /* not the first element? */
            gate_lua_writestring(" ", 1, false);  /* add a tab before it */
        }
        gate_lua_writestring(s, l, false);  /* print it */
        lua_pop(L, 1);  /* pop result */
    }
    gate_lua_writestring(GATE_STR_NEWLINE, GATE_STR_NEWLINE_LENGTH, true);
    return 0;
}

static int gate_lua_printerr(lua_State* L)
{
    int n = lua_gettop(L);	/* number of arguments */
    int i;
    for (i = 1; i <= n; i++)
    {
        size_t l;
        const char* s = luaL_tolstring(L, i, &l);  /* convert it to string */
        if (i > 1)
        {
            /* not the first element? */
            gate_lua_writestring_err(" ", 1, false);  /* add a tab before it */
        }
        gate_lua_writestring_err(s, l, false);  /* print it */
        lua_pop(L, 1);  /* pop result */
    }
    gate_lua_writestring_err(GATE_STR_NEWLINE, GATE_STR_NEWLINE_LENGTH, true);
    return 0;
}

static int gate_lua_read(lua_State* L)
{
    int ret = 0;<--- Variable 'ret' is assigned a value that is never used.
    gate_string_t line = GATE_STRING_INIT_EMPTY;
    gate_console_t* const con = gate_console();

    gate_console_readln(con, &line);

    lua_pushlstring(L, gate_string_ptr(&line, 0), gate_string_length(&line));

    gate_string_release(&line);
    return 1;
}

static void add_console_feature(lua_State* lstate)
{
    lua_register(lstate, "print", &gate_lua_print);
    lua_register(lstate, "printerror", &gate_lua_printerr);
    lua_register(lstate, "read", &gate_lua_read);
}

static int gate_lua_fileopen(lua_State* lstate)
{
    gate_result_t ret = 0;
    gate_result_t result;
    gate_string_t str_path = GATE_STRING_INIT_EMPTY;
    gate_string_t str_flags = GATE_STRING_INIT_EMPTY;
    gate_enumint_t openflags = GATE_STREAM_OPEN_READ;
    gate_bool_t truncate = false;
    gate_size_t arg_count;
    gate_file_t f;

    do
    {
        arg_count = gate_script_lua_cfunc_get_arg_count(lstate);
        if (arg_count < 1)
        {
            luaL_error(lstate, "Missing arguments");
            break;
        }

        lua_stack_get_string(lstate, 1, &str_path);
        if (gate_string_is_empty(&str_path))
        {
            lua_pushnil(lstate);
            ret = 1;
            break;
        }

        if (arg_count >= 2)
        {
            lua_stack_get_string(lstate, 2, &str_flags);
        }
        if (gate_string_equals_str(&str_flags, "r") || gate_string_is_empty(&str_flags))
        {
            openflags = GATE_STREAM_OPEN_READ;
        }
        else if (gate_string_equals_str(&str_flags, "r+"))
        {
            openflags = GATE_STREAM_OPEN_READWRITE;
        }
        else if (gate_string_equals_str(&str_flags, "w"))
        {
            openflags = GATE_STREAM_OPEN_WRITE;
        }
        else if (gate_string_equals_str(&str_flags, "w+"))
        {
            openflags = GATE_STREAM_OPEN_READWRITE;
            truncate = true;
        }
        else if (gate_string_equals_str(&str_flags, "a"))
        {
            openflags = GATE_STREAM_OPEN_APPENDWRITE;
        }
        else if (gate_string_equals_str(&str_flags, "a+"))
        {
            openflags = GATE_STREAM_OPEN_APPENDREADWRITE;
        }
        else
        {
            /* unsupported open-type */
            lua_pushnil(lstate);
            ret = 1;
            break;
        }

        result = gate_file_open(&str_path, openflags, &f);
        if (GATE_FAILED(result))
        {
            /* error case */
            lua_pushnil(lstate);
            ret = 1;
            break;
        }

        if (truncate)
        {
            gate_file_truncate(f);
        }

        /* success case */
        lua_pushinteger(lstate, (lua_Integer)(gate_intptr_t)(void*)f);
        ret = 1;
    } while (0);

    gate_string_release(&str_flags);
    gate_string_release(&str_path);
    return ret;
}

static int gate_lua_fileclose(lua_State* lstate)
{
    gate_result_t ret = 0;
    gate_size_t arg_count;
    gate_int32_t file_handle;
    gate_file_t f;

    do
    {
        arg_count = gate_script_lua_cfunc_get_arg_count(lstate);
        if (arg_count < 1)
        {
            luaL_error(lstate, "Missing arguments");
            break;
        }

        lua_stack_get_int(lstate, 1, &file_handle);
        f = (gate_file_t)(gate_intptr_t)file_handle;

        gate_file_close(f);
        /* success case */
    } while (0);

    return ret;
}

static int gate_lua_fileread(lua_State* lstate)
{
    gate_result_t ret = 0;
    gate_result_t result;
    gate_size_t arg_count;
    gate_int32_t file_handle = 0;
    gate_int32_t read_len = 0;
    gate_file_t f;
    char buffer[GATE_MAX_COPYBUFFER_LENGTH];
    char* ptr_buffer = &buffer[0];
    gate_size_t buffer_len;
    gate_size_t buffer_used = 0;

    do
    {
        arg_count = gate_script_lua_cfunc_get_arg_count(lstate);
        if (arg_count < 2)
        {
            luaL_error(lstate, "Missing arguments");
            break;
        }

        lua_stack_get_int(lstate, 1, &file_handle);
        f = (gate_file_t)(gate_intptr_t)file_handle;

        lua_stack_get_int(lstate, 2, &read_len);

        if (read_len <= 0)
        {
            /* invalid read-length */
            lua_pushnil(lstate);
            ret = 1;
            break;
        }

        buffer_len = (gate_size_t)read_len;
        if (buffer_len > sizeof(buffer))
        {
            ptr_buffer = gate_mem_alloc(buffer_len);
            if (NULL == ptr_buffer)
            {
                luaL_error(lstate, "Out of memory");
                break;
            }
        }

        result = gate_file_read(f, ptr_buffer, buffer_len, &buffer_used);
        if (GATE_FAILED(result))
        {
            /* failed to read from file */
            lua_pushnil(lstate);
            ret = 1;
            break;
        }

        /* succes case, return buffer content as string */
        lua_pushlstring(lstate, ptr_buffer, buffer_used);
        ret = 1;
    } while (0);

    if (ptr_buffer && (ptr_buffer != &buffer[0]))
    {
        gate_mem_dealloc(ptr_buffer);
    }

    return ret;
}

static int gate_lua_filewrite(lua_State* lstate)
{
    gate_result_t ret = 0;
    gate_result_t result;
    gate_size_t arg_count;
    gate_int32_t file_handle = 0;
    gate_file_t f;
    gate_string_t buffer = GATE_STRING_INIT_EMPTY;
    gate_size_t written;

    do
    {
        arg_count = gate_script_lua_cfunc_get_arg_count(lstate);
        if (arg_count < 2)
        {
            luaL_error(lstate, "Missing arguments");
            break;
        }

        lua_stack_get_int(lstate, 1, &file_handle);
        f = (gate_file_t)(gate_intptr_t)file_handle;

        lua_stack_get_string(lstate, 2, &buffer);

        result = gate_file_write(f, gate_string_ptr(&buffer, 0), gate_string_length(&buffer), &written);
        if (GATE_FAILED(result))
        {
            /* failed to read from file */
            lua_pushnil(lstate);
            ret = 1;
            break;
        }

        /* success case, return amount of written bytes */
        lua_pushinteger(lstate, (lua_Integer)written);
        ret = 1;
    } while (0);

    gate_string_release(&buffer);
    return ret;
}



static void add_fileaccess_feature(lua_State* lstate)
{
    lua_register(lstate, "file_open", &gate_lua_fileopen);
    lua_register(lstate, "file_close", &gate_lua_fileclose);
    lua_register(lstate, "file_read", &gate_lua_fileread);
    lua_register(lstate, "file_write", &gate_lua_filewrite);
}

gate_result_t gate_script_lua_add_feature(gate_script_lua_session_t* session, gate_script_lua_feature_enum_t feature)
{
    lua_State* lstate = (lua_State*)session->state;

    switch (feature)
    {
    case gate_script_lua_feature_console:
        add_console_feature(lstate);
        return GATE_RESULT_OK;
    case gate_script_lua_feature_fileaccess:
        add_fileaccess_feature(lstate);
        return GATE_RESULT_OK;
    case gate_script_lua_feature_filesystem:
    case gate_script_lua_feature_process:
    default:
        return GATE_RESULT_NOTSUPPORTED;
    }
}

static int gate_script_lua_console_quit(lua_State* L)
{
    gate_script_lua_session_t* ptr_session = gate_script_lua_get_session(L);
    if (ptr_session)
    {
        ptr_session->cancel = true;
    }
    return 0;
}

gate_result_t gate_script_lua_console(gate_stream_t* console)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_script_lua_session_t session = GATE_INIT_EMPTY;
    gate_strbuilder_t builder = GATE_INIT_EMPTY;
    char buffer[4096];
    gate_size_t buffer_used;
    gate_bool_t command_completed;
    gate_string_t command = GATE_STRING_INIT_EMPTY;
    lua_State* lstate;
<--- The scope of the variable 'lstate' can be reduced. [+]
The scope of the variable 'lstate' 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 pos;

    do
    {
        ret = gate_script_lua_init(&session);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_script_lua_add_feature(&session, gate_script_lua_feature_console);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_script_lua_add_feature(&session, gate_script_lua_feature_fileaccess);
        GATE_BREAK_IF_FAILED(ret);

        gate_strbuilder_create(&builder, 0);

        lstate = (lua_State*)session.state;
        session.cancel = false;

        lua_pushcfunction(lstate, &gate_script_lua_console_quit);
        lua_setglobal(lstate, "quit");

        while (!session.cancel)
        {
            buffer_used = 0;
            if (gate_strbuilder_length(&builder) == 0)
            {
                gate_stream_print_cstr(console, "[LUA] > ");
            }
            else
            {
                gate_stream_print_cstr(console, "      > ");

            }
            ret = gate_stream_read_line(console, buffer, sizeof(buffer), &buffer_used);
            GATE_BREAK_IF_FAILED(ret);

            pos = gate_str_find_last_not_of(buffer, buffer_used, " \r\n\t", 4);
            if (pos == GATE_STR_NPOS)
            {
                /* empty line */
            }
            else
            {
                buffer_used = pos + 1;
                if (gate_str_ends_with(buffer, buffer_used, "\\", 1))
                {
                    gate_strbuilder_append_text(&builder, buffer, buffer_used - 1);
                    gate_strbuilder_append_cstr(&builder, "\n");
                    command_completed = false;
                }
                else
                {
                    gate_strbuilder_append_text(&builder, buffer, buffer_used);
                    command_completed = true;
                }
                if (command_completed)
                {
                    if (gate_strbuilder_to_string(&builder, &command))
                    {
                        ret = gate_script_lua_load_impl(lstate, &command, true);
                        gate_strbuilder_release(&builder);
                        gate_strbuilder_create(&builder, 0);
                        if (GATE_SUCCEEDED(ret))
                        {
                            gate_stream_println_cstr(console, NULL);
                            gate_stream_println_cstr(console, "[LUA] : OK (^_^)");
                        }
                        else
                        {
                            gate_stream_println_cstr(console, NULL);
                            gate_stream_print_cstr(console, "[LUA] : ERROR ");
                            gate_stream_print_int(console, ret);
                            gate_stream_println_cstr(console, " (>_<)");
                            ret = GATE_RESULT_OK;
                        }
                    }
                    else
                    {
                        ret = GATE_RESULT_OUTOFMEMORY;
                    }
                    gate_string_release(&command);
                    GATE_BREAK_IF_FAILED(ret);
                }
            }

        }
        gate_script_lua_uninit(&session);

    } while (0);

    gate_strbuilder_release(&builder);

    return ret;
}

#endif /* GATE_SCRIPTING_LUA_USE_LUA */


#if defined(GATE_SCRIPTING_LUA_NO_IMPL)

gate_result_t gate_script_lua_init(gate_script_lua_session_t* session)
{
    GATE_UNUSED_ARG(session);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_script_lua_uninit(gate_script_lua_session_t* session)
{
    GATE_UNUSED_ARG(session);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_script_lua_reset(gate_script_lua_session_t* session)
{
    GATE_UNUSED_ARG(session);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_script_lua_load(gate_script_lua_session_t* session, gate_string_t const* code)
{
    GATE_UNUSED_ARG(session);
    GATE_UNUSED_ARG(code);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_script_lua_invoke(gate_script_lua_session_t* session,
    gate_string_t const* func_name,
    gate_value_t* args, gate_size_t arg_count,
    gate_value_t* ret_val)
{
    GATE_UNUSED_ARG(session);
    GATE_UNUSED_ARG(func_name);
    GATE_UNUSED_ARG(args);
    GATE_UNUSED_ARG(arg_count);
    GATE_UNUSED_ARG(ret_val);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_script_lua_set_var(gate_script_lua_session_t* session,
    gate_string_t const* name, gate_value_t const* value)
{
    GATE_UNUSED_ARG(session);
    GATE_UNUSED_ARG(name);
    GATE_UNUSED_ARG(value);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_script_lua_get_var(gate_script_lua_session_t* session,
    gate_string_t const* name, gate_value_t* value)
{
    GATE_UNUSED_ARG(session);
    GATE_UNUSED_ARG(name);
    GATE_UNUSED_ARG(value);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_script_lua_add_feature(gate_script_lua_session_t* session, gate_script_lua_feature_enum_t feature)
{
    GATE_UNUSED_ARG(session);
    GATE_UNUSED_ARG(feature);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_script_lua_console(gate_stream_t* console)
{
    GATE_UNUSED_ARG(console);
    return GATE_RESULT_NOTIMPLEMENTED;
}

#endif /* GATE_SCRIPTING_LUA_NO_IMPL */