Cppcheck report - GATE C/C++ Framework: gate/encode/inifiles.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/encode/inifiles.h"
#include "gate/comparers.h"
#include "gate/results.h"

static gate_flatmap_iterator_t gate_inifile_store_use_section(gate_inifile_store_t* store, gate_string_t const* section)
{
    gate_flatmap_iterator_t iter = gate_flatmap_get(&store->sections, section);
    gate_flatmap_t content = GATE_INIT_EMPTY;

    if (!gate_flatmap_iterator_valid(&store->sections, iter))
    {
        if (NULL != gate_flatmap_create(&content, &gate_compare_string,
            sizeof(gate_string_t), &gate_string_copy_constructor, &gate_string_destructor,
            sizeof(gate_string_t), &gate_string_copy_constructor, &gate_string_destructor))
        {
            iter = gate_flatmap_add(&store->sections, section, &content);
            if (!iter)
            {
                gate_flatmap_destroy(&content);
            }
        }
    }
    return iter;
}

gate_result_t gate_inifile_store_create(gate_inifile_store_t* store)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_flatmap_iterator_t global_section_entry;
    static gate_string_t const empty_string = GATE_STRING_INIT_EMPTY;

    do
    {
        gate_mem_clear(store, sizeof(gate_inifile_store_t));
        if (NULL == gate_flatmap_create(&store->sections, &gate_compare_string,
            sizeof(gate_string_t), &gate_string_copy_constructor, &gate_string_destructor,
            sizeof(gate_flatmap_t), &gate_flatmap_copy_constructor, &gate_flatmap_destructor))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        global_section_entry = gate_inifile_store_use_section(store, &empty_string);
        if (NULL == global_section_entry)
        {
            gate_flatmap_destroy(&store->sections);
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}
gate_result_t gate_inifile_store_copy(gate_inifile_store_t* store, gate_inifile_store_t const* source)
{
    if (NULL == gate_flatmap_copy(&store->sections, &source->sections))
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    return GATE_RESULT_OK;
}


gate_result_t gate_inifile_store_destroy(gate_inifile_store_t* store)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    if (store)
    {
        gate_flatmap_destroy(&store->sections);
        ret = GATE_RESULT_OK;
    }
    return ret;
}


gate_result_t gate_inifile_store_add_section(gate_inifile_store_t* store, gate_string_t const* section)
{
    gate_flatmap_iterator_t section_entry = gate_inifile_store_use_section(store, section);
    if (section_entry == NULL)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        return GATE_RESULT_OK;
    }
}
gate_result_t gate_inifile_store_remove_section(gate_inifile_store_t* store, gate_string_t const* section)
{
    if (gate_flatmap_remove(&store->sections, section))
    {
        return GATE_RESULT_OK;
    }
    else
    {
        return GATE_RESULT_OK_UNCHANGED;
    }
}
gate_result_t gate_inifile_store_set(gate_inifile_store_t* store, gate_string_t const* section,
    gate_string_t const* key, gate_string_t const* value)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_flatmap_iterator_t section_entry;
    gate_flatmap_t* entry_map;
<--- The scope of the variable 'entry_map' can be reduced. [+]
The scope of the variable 'entry_map' 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
    {
        if (gate_string_is_empty(key))
        {
            /* a key MUST NOT be empty */
            ret = GATE_RESULT_INVALIDARG;
            break;
        }
        section_entry = gate_inifile_store_use_section(store, section);
        if (NULL == section_entry)
        {
            /* failed to access or create section */
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        entry_map = (gate_flatmap_t*)gate_flatmap_iterator_value(section_entry);
        if (NULL == entry_map)
        {
            /* section entry is invalid */
            ret = GATE_RESULT_INVALIDCONTENT;
            break;
        }
        if (NULL == gate_flatmap_add(entry_map, key, value))
        {
            /* failed to add */
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        /* new value successfully attached */
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}
gate_result_t gate_inifile_store_get(gate_inifile_store_t const* store, gate_string_t const* section,
    gate_string_t const* key, gate_string_t* return_value)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_flatmap_iterator_t section_entry;
    gate_flatmap_t* entry_map;
<--- The scope of the variable 'entry_map' can be reduced. [+]
The scope of the variable 'entry_map' 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_flatmap_iterator_t entry_iter;

    do
    {
        section_entry = gate_flatmap_get(&store->sections, section);
        if (NULL == section_entry)
        {
            /* failed to access or create section */
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        entry_map = (gate_flatmap_t*)gate_flatmap_iterator_value(section_entry);
        if (NULL == entry_map)
        {
            /* section entry is invalid */
            ret = GATE_RESULT_INVALIDCONTENT;
            break;
        }
        entry_iter = gate_flatmap_get(entry_map, key);
        if (NULL == entry_iter)
        {
            /* key does not exist in section */
            ret = GATE_RESULT_NOMATCH;
            break;
        }

        if (NULL != return_value)
        {
            if (NULL == gate_string_duplicate(return_value, (gate_string_t const*)gate_flatmap_iterator_value(entry_iter)))
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
        }
        /* value successfully retrieved */
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}

gate_result_t gate_inifile_store_remove(gate_inifile_store_t* store, gate_string_t const* section, gate_string_t const* key)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_flatmap_iterator_t section_entry;
    gate_flatmap_t* entry_map;
<--- The scope of the variable 'entry_map' can be reduced. [+]
The scope of the variable 'entry_map' 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
    {
        section_entry = gate_flatmap_get(&store->sections, section);
        if (NULL == section_entry)
        {
            /* failed to access or create section */
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        entry_map = (gate_flatmap_t*)gate_flatmap_iterator_value(section_entry);
        if (NULL == entry_map)
        {
            /* section entry is invalid */
            ret = GATE_RESULT_INVALIDCONTENT;
            break;
        }
        if (!gate_flatmap_remove(entry_map, key))
        {
            /* entry key does not exist */
            ret = GATE_RESULT_NOMATCH;
            break;
        }

        /* entry successfully removed */
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}





gate_result_t gate_inifile_store_load(gate_inifile_store_t* inistore, gate_stream_t* input)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_string_t current_section = GATE_STRING_INIT_EMPTY;
    char buffer[8192];
    gate_uint64_t comment_counter = 0;
    char comment_id[128] = ";;;;;;;;;;;;;;;;";
    gate_size_t linelen;
    gate_string_t comment_key = GATE_STRING_INIT_EMPTY;
    gate_string_t current_line = GATE_STRING_INIT_EMPTY;
    gate_string_t current_key = GATE_STRING_INIT_EMPTY;
    gate_string_t current_value = GATE_STRING_INIT_EMPTY;
    gate_size_t pos;
    gate_char8_t chr;
    gate_char8_t chr_last;

    do
    {
        ret = GATE_RESULT_OK;
        while (GATE_SUCCEEDED(ret))
        {
            ret = gate_stream_read_line(input, buffer, sizeof(buffer), &linelen);
            GATE_BREAK_IF_FAILED(ret);
            if (linelen == 0)
            {
                /* end of stream reached */
                break;
            }

            gate_string_create_static_len(&current_line, buffer, linelen);
            gate_string_rtrim(&current_line, &current_line);
            gate_string_ltrim(&current_line, &current_line);

            if (gate_string_is_empty(&current_line))
            {
                continue;
            }

            chr = gate_string_char_at(&current_line, 0);
            switch (chr)
            {
            case '[':
            {
                /* new section */
                chr_last = gate_string_char_at(&current_line, gate_string_length(&current_line) - 1);
                if (chr_last != ']')
                {
                    ret = GATE_RESULT_INVALIDINPUT;
                    break;
                }
                gate_string_release(&current_section);
                if (NULL == gate_string_create(&current_section, gate_string_ptr(&current_line, 1), gate_string_length(&current_line) - 2))
                {
                    ret = GATE_RESULT_OUTOFMEMORY;
                    break;
                }
                ret = gate_inifile_store_add_section(inistore, &current_section);
                break;
            }
            case '#':
            case ';':
            {
                /* comment line */
                gate_str_print_uint64(&comment_id[1], sizeof(comment_id) - 1, ++comment_counter);
                gate_string_create_static(&comment_key, comment_id);
                gate_inifile_store_set(inistore, &current_section, &comment_key, &current_line);
                gate_string_release(&comment_key);
                break;
            }
            default:
            {
                /* key-value entry */
                pos = gate_string_char_pos(&current_line, '=', 0);
                if (pos == GATE_STR_NPOS)
                {
                    gate_string_duplicate(&current_key, &current_line);
                    gate_string_create_empty(&current_value);
                }
                else
                {
                    gate_string_substr(&current_key, &current_line, 0, pos);
                    gate_string_rtrim(&current_key, &current_key);
                    gate_string_substr(&current_value, &current_line, pos + 1, GATE_STR_NPOS);
                    gate_string_ltrim(&current_value, &current_value);
                }
                ret = gate_inifile_store_set(inistore, &current_section, &current_key, &current_value);
                gate_string_release(&current_value);
                gate_string_release(&current_key);
                break;
            }
            }
            gate_string_release(&current_line);
        }

    } while (0);

    gate_string_release(&current_section);

    return ret;
}

gate_result_t gate_inifile_store_save(gate_inifile_store_t const* inistore, gate_stream_t* output)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_flatmap_iterator_t section_iter;
    gate_flatmap_iterator_t entry_iter;
    gate_string_t const* ptr_section_name;
    gate_flatmap_t const* ptr_section_content;
    gate_string_t const* ptr_key;
    gate_string_t const* ptr_value;
    gate_size_t entry_count;

    do
    {
        section_iter = gate_flatmap_first(&inistore->sections);
        while (gate_flatmap_iterator_valid(&inistore->sections, section_iter))
        {
            ptr_section_name = (gate_string_t const*)gate_flatmap_iterator_key(section_iter);
            ptr_section_content = (gate_flatmap_t const*)gate_flatmap_iterator_value(section_iter);
            if (ptr_section_name && ptr_section_content)
            {
                if (!gate_string_is_empty(ptr_section_name))
                {
                    gate_stream_print(output,
                        GATE_PRINT_CHAR, '[',
                        GATE_PRINT_STRING, ptr_section_name,
                        GATE_PRINT_CHAR, ']',
                        GATE_PRINT_NEWLINE,
                        GATE_PRINT_END);
                }
                entry_count = gate_flatmap_count(ptr_section_content);
                if (entry_count > 0)
                {
                    entry_iter = gate_flatmap_first(ptr_section_content);
                    while (gate_flatmap_iterator_valid(ptr_section_content, entry_iter))
                    {
                        ptr_key = (gate_string_t const*)gate_flatmap_iterator_key(entry_iter);
                        ptr_value = (gate_string_t const*)gate_flatmap_iterator_value(entry_iter);
                        if (gate_string_starts_with_char(ptr_key, ';'))
                        {
                            gate_stream_print(output,
                                GATE_PRINT_STRING, ptr_value,
                                GATE_PRINT_NEWLINE,
                                GATE_PRINT_END);
                        }
                        else
                        {
                            gate_stream_print(output,
                                GATE_PRINT_STRING, ptr_key,
                                GATE_PRINT_CSTR, " = ",
                                GATE_PRINT_STRING, ptr_value,
                                GATE_PRINT_NEWLINE,
                                GATE_PRINT_END);
                        }
                        entry_iter = gate_flatmap_iterator_next(entry_iter);
                    }
                    gate_stream_print(output,
                        GATE_PRINT_NEWLINE,
                        GATE_PRINT_END);
                }
            }
            section_iter = gate_flatmap_iterator_next(section_iter);
        }
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}

static gate_result_t gate_inifile_store_import_tree(gate_inifile_store_t* inistore, gate_property_t const* property_tree, gate_string_t const* section)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_size_t count, ndx;
    gate_array_t names = GATE_INIT_EMPTY;
    gate_string_t const* ptr_name;
    gate_property_t const* ptr_prop;
    gate_property_typeid_t prop_type;
    gate_string_t prop_value;
    gate_strbuilder_t builder;
    gate_string_t sub_section;

    do
    {
        if (NULL == gate_property_member_names(property_tree, &names))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        count = gate_array_length(&names);
        ret = GATE_RESULT_OK;
        for (ndx = 0; GATE_SUCCEEDED(ret) && (ndx != count); ++ndx)
        {
            ptr_name = (gate_string_t const*)gate_array_get(&names, ndx);
            if (!ptr_name)
            {
                continue;
            }
            ptr_prop = gate_property_member_get(property_tree, ptr_name);
            if (!ptr_prop)
            {
                continue;
            }
            prop_type = gate_property_get_type(ptr_prop);
            switch (prop_type)
            {
            case GATE_PROPERTY_TYPE_BOOL:
            case GATE_PROPERTY_TYPE_INT:
            case GATE_PROPERTY_TYPE_REAL:
            case GATE_PROPERTY_TYPE_STRING:
            {
                ret = gate_property_get_string(ptr_prop, &prop_value);
                GATE_BREAK_IF_FAILED(ret);
                ret = gate_inifile_store_set(inistore, section, ptr_name, &prop_value);
                gate_string_release(&prop_value);
                break;
            }
            case GATE_PROPERTY_TYPE_ARRAY:
            {
                break;
            }
            case GATE_PROPERTY_TYPE_OBJECT:
            {
                gate_strbuilder_create(&builder, 0);
                gate_strbuilder_append_string(&builder, section);
                if (gate_strbuilder_length(&builder) != 0)
                {
                    gate_strbuilder_append_cstr(&builder, "/");
                }
                gate_strbuilder_append_string(&builder, ptr_name);
                if (NULL == gate_strbuilder_to_string(&builder, &sub_section))
                {
                    ret = GATE_RESULT_OUTOFMEMORY;
                }
                gate_strbuilder_release(&builder);
                GATE_BREAK_IF_FAILED(ret);
                ret = gate_inifile_store_import_tree(inistore, ptr_prop, &sub_section);
                gate_string_release(&sub_section);
                break;
            }
            }
        }

    } while (0);

    gate_array_release(&names);

    return ret;
}

gate_result_t gate_inifile_store_import(gate_inifile_store_t* inistore, gate_property_t const* property_tree)
{
    gate_string_t section = GATE_STRING_INIT_EMPTY;
    if (gate_property_get_type(property_tree) != GATE_PROPERTY_TYPE_OBJECT)
    {
        return GATE_RESULT_INVALIDINPUT;
    }
    else
    {
        return gate_inifile_store_import_tree(inistore, property_tree, &section);
    }
}

gate_result_t gate_inifile_store_export(gate_inifile_store_t* inistore, gate_property_t* property_tree)
{
    /* TODO */
    return GATE_RESULT_NOTIMPLEMENTED;
}



gate_result_t gate_inifile_parse_string(gate_string_t const* source, gate_property_t* property_tree)
{
    gate_memstream_impl_t mem_stream = GATE_INIT_EMPTY;
    gate_memstream_create_static_unmanaged_readonly(&mem_stream, gate_string_ptr(source, 0), gate_string_length(source), 0);
    return gate_inifile_parse((gate_stream_t*)&mem_stream, property_tree);
}
gate_result_t gate_inifile_build_string(gate_property_t const* property_tree, gate_strbuilder_t* dest_builder)
{
    gate_result_t ret;
    gate_stringstream_t* stream = gate_stringstream_create_builder(dest_builder);
    if (NULL == stream)
    {
        ret = GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        ret = gate_inifile_build(property_tree, (gate_stream_t*)stream);
        gate_object_release(stream);
    }
    return ret;
}

gate_result_t gate_inifile_parse(gate_stream_t* source, gate_property_t* property_tree)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_inifile_store_t store = GATE_INIT_EMPTY;
    do
    {
        ret = gate_inifile_store_create(&store);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_inifile_store_load(&store, source);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_inifile_store_export(&store, property_tree);
    } while (0);

    gate_inifile_store_destroy(&store);

    return ret;
}
gate_result_t gate_inifile_build(gate_property_t const* property_tree, gate_stream_t* output)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_inifile_store_t store = GATE_INIT_EMPTY;
    do
    {
        ret = gate_inifile_store_create(&store);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_inifile_store_import(&store, property_tree);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_inifile_store_save(&store, output);
    } while (0);

    gate_inifile_store_destroy(&store);

    return ret;
}