conf_file.cpp

Go to the documentation of this file.

// Copyright (c) 2006-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/project/advgetopt
// contact@m2osw.com
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 
// self
//
#include    "advgetopt/conf_file.h"
 
#include    "advgetopt/exception.h"
#include    "advgetopt/utils.h"
 
 
// snapdev
//
#include    <snapdev/join_strings.h>
#include    <snapdev/mkdir_p.h>
#include    <snapdev/safe_variable.h>
#include    <snapdev/string_replace_many.h>
#include    <snapdev/tokenize_string.h>
#include    <snapdev/trim_string.h>
 
 
// cppthread
//
#include    <cppthread/guard.h>
#include    <cppthread/log.h>
#include    <cppthread/mutex.h>
 
 
// C++
//
#include    <algorithm>
#include    <fstream>
#include    <iomanip>
 
 
// C
//
#include    <string.h>
#include    <sys/stat.h>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
namespace advgetopt
{
 
 
// from utils.cpp
//
// (it's here because we do not want to make cppthread public in
// out header files--we could have an advgetopt_private.h, though)
//
cppthread::mutex &  get_global_mutex();
 
 
 
namespace
{
 
 
 
typedef std::map<std::string, conf_file::pointer_t>     conf_file_map_t;
 
 
conf_file_map_t     g_conf_files = conf_file_map_t();
 
 
} // no name namespace
 
 
 
 
 
conf_file_setup::conf_file_setup(
          std::string const & filename
        , line_continuation_t line_continuation
        , assignment_operator_t assignment_operator
        , comment_t comment
        , section_operator_t section_operator
        , name_separator_t name_separator)
    : f_original_filename(filename)
    , f_line_continuation(line_continuation)
    , f_assignment_operator(assignment_operator == 0
                ? ASSIGNMENT_OPERATOR_EQUAL
                : assignment_operator)
    , f_comment(comment)
    , f_section_operator(section_operator)
    , f_name_separator(name_separator)
{
    initialize();
}
 
 
conf_file_setup::conf_file_setup(
          std::string const & filename
        , conf_file_setup const & original)
    : f_original_filename(filename)
    , f_line_continuation(original.f_line_continuation)
    , f_assignment_operator(original.f_assignment_operator == 0
                ? ASSIGNMENT_OPERATOR_EQUAL
                : original.f_assignment_operator)
    , f_comment(original.f_comment)
    , f_section_operator(original.f_section_operator)
    , f_name_separator(original.f_name_separator)
{
    initialize();
}
 
 
void conf_file_setup::initialize()
{
    if(f_original_filename.empty())
    {
        throw getopt_invalid("trying to load a configuration file using an empty filename.");
    }
 
    // canonicalization so we can properly cache files
    //
    std::unique_ptr<char, decltype(&::free)> fn(realpath(f_original_filename.c_str(), nullptr), &::free);
    if(fn != nullptr)
    {
        f_filename = fn.get();
    }
    else
    {
        f_filename = f_original_filename;
    }
}
 
 
bool conf_file_setup::is_valid() const
{
    return !f_filename.empty();
}
 
 
std::string const & conf_file_setup::get_original_filename() const
{
    return f_original_filename;
}
 
 
std::string const & conf_file_setup::get_filename() const
{
    return f_filename;
}
 
 
line_continuation_t conf_file_setup::get_line_continuation() const
{
    return f_line_continuation;
}
 
 
assignment_operator_t conf_file_setup::get_assignment_operator() const
{
    return f_assignment_operator;
}
 
 
comment_t conf_file_setup::get_comment() const
{
    return f_comment;
}
 
 
section_operator_t conf_file_setup::get_section_operator() const
{
    return f_section_operator;
}
 
 
std::string conf_file_setup::get_config_url() const
{
    if(f_url.empty())
    {
        std::stringstream ss;
 
        ss << "file://"
           << (f_filename.empty()
                    ? "/<empty>"
                    : f_filename);
 
        std::vector<std::string> params;
        if(f_line_continuation != line_continuation_t::line_continuation_unix)
        {
            std::string name;
            switch(f_line_continuation)
            {
            case line_continuation_t::line_continuation_single_line:
                name = "single-line";
                break;
 
            case line_continuation_t::line_continuation_rfc_822:
                name = "rfc-822";
                break;
 
            case line_continuation_t::line_continuation_msdos:
                name = "msdos";
                break;
 
            // we should not ever receive this one since we don't enter
            // this block when the value is "unix"
            //
            //case line_continuation_t::line_continuation_unix:
            //    name = "unix";
            //    break;
 
            case line_continuation_t::line_continuation_fortran:
                name = "fortran";
                break;
 
            case line_continuation_t::line_continuation_semicolon:
                name = "semi-colon";
                break;
 
            default:
                throw getopt_logic_error("unexpected line continuation.");
 
            }
            params.push_back("line-continuation=" + name);
        }
 
        if(f_assignment_operator != ASSIGNMENT_OPERATOR_EQUAL)
        {
            std::vector<std::string> assignments;
            if((f_assignment_operator & ASSIGNMENT_OPERATOR_EQUAL) != 0)
            {
                assignments.push_back("equal");
            }
            if((f_assignment_operator & ASSIGNMENT_OPERATOR_COLON) != 0)
            {
                assignments.push_back("colon");
            }
            if((f_assignment_operator & ASSIGNMENT_OPERATOR_SPACE) != 0)
            {
                assignments.push_back("space");
            }
            if((f_assignment_operator & ASSIGNMENT_OPERATOR_EXTENDED) != 0)
            {
                assignments.push_back("extended");
            }
            if(!assignments.empty())
            {
                params.push_back("assignment-operator=" + snapdev::join_strings(assignments, ","));
            }
        }
 
        if(f_comment != COMMENT_INI | COMMENT_SHELL)
        {
            std::vector<std::string> comment;
            if((f_comment & COMMENT_INI) != 0)
            {
                comment.push_back("ini");
            }
            if((f_comment & COMMENT_SHELL) != 0)
            {
                comment.push_back("shell");
            }
            if((f_comment & COMMENT_CPP) != 0)
            {
                comment.push_back("cpp");
            }
            if((f_comment & COMMENT_SAVE) != 0)
            {
                comment.push_back("save");
            }
            if(comment.empty())
            {
                params.push_back("comment=none");
            }
            else
            {
                params.push_back("comment=" + snapdev::join_strings(comment, ","));
            }
        }
 
        if(f_section_operator != SECTION_OPERATOR_INI_FILE)
        {
            std::vector<std::string> section_operator;
            if((f_section_operator & SECTION_OPERATOR_C) != 0)
            {
                section_operator.push_back("c");
            }
            if((f_section_operator & SECTION_OPERATOR_CPP) != 0)
            {
                section_operator.push_back("cpp");
            }
            if((f_section_operator & SECTION_OPERATOR_BLOCK) != 0)
            {
                section_operator.push_back("block");
            }
            if((f_section_operator & SECTION_OPERATOR_INI_FILE) != 0)
            {
                section_operator.push_back("ini-file");
            }
            if(!section_operator.empty())
            {
                params.push_back("section-operator=" + snapdev::join_strings(section_operator, ","));
            }
        }
 
        std::string const query_string(snapdev::join_strings(params, "&"));
        if(!query_string.empty())
        {
            ss << '?'
               << query_string;
        }
 
        f_url = ss.str();
    }
 
    return f_url;
}
 
 
name_separator_t conf_file_setup::get_name_separator() const
{
    return f_name_separator;
}
 
 
void conf_file_setup::set_section_to_ignore(std::string const & section_name)
{
    f_section_to_ignore = section_name;
}
 
 
std::string const & conf_file_setup::get_section_to_ignore() const
{
    return f_section_to_ignore;
}
 
 
 
 
 
 
 
 
parameter_value::parameter_value()
{
}
 
 
parameter_value::parameter_value(parameter_value const & rhs)
    : f_value(rhs.f_value)
    , f_comment(rhs.f_comment)
    , f_line(rhs.f_line)
    , f_assignment_operator(rhs.f_assignment_operator)
{
}
 
 
parameter_value::parameter_value(std::string const & value)
    : f_value(value)
{
}
 
 
parameter_value & parameter_value::operator = (parameter_value const & rhs)
{
    if(this != &rhs)
    {
        f_value = rhs.f_value;
        f_comment = rhs.f_comment;
        f_line = rhs.f_line;
        f_assignment_operator = rhs.f_assignment_operator;
    }
    return *this;
}
 
 
parameter_value & parameter_value::operator = (std::string const & value)
{
    f_value = value;
    return *this;
}
 
 
parameter_value::operator std::string () const
{
    return f_value;
}
 
 
void parameter_value::set_value(std::string const & value)
{
    f_value = value;
}
 
 
void parameter_value::set_comment(std::string const & comment)
{
    // ignore if the comment is only composed of spaces, tabs, empty lines
    //
    std::string const trimmed(snapdev::trim_string(comment));
    if(trimmed.empty())
    {
        f_comment.clear();
    }
    else
    {
        // IMPORTANT: we do not save the trimmed version we only use that
        //            to make sure it's not a completely empty comment
        //
        f_comment = comment;
    }
}
 
 
void parameter_value::set_line(int line)
{
    f_line = line;
}
 
 
void parameter_value::set_assignment_operator(assignment_t a)
{
    f_assignment_operator = a;
}
 
 
std::string const & parameter_value::get_value() const
{
    return f_value;
}
 
 
std::string parameter_value::get_comment(bool ensure_newline) const
{
    if(f_comment.empty())
    {
        return f_comment;
    }
 
    if(ensure_newline
    && f_comment.back() != '\n')
    {
        return f_comment + '\n';
    }
 
    return f_comment;
}
 
 
int parameter_value::get_line() const
{
    return f_line;
}
 
 
assignment_t parameter_value::get_assignment_operator() const
{
    return f_assignment_operator;
}
 
 
 
 
 
 
 
 
 
conf_file::pointer_t conf_file::get_conf_file(conf_file_setup const & setup)
{
    cppthread::guard lock(get_global_mutex());
 
    auto it(g_conf_files.find(setup.get_filename()));
    if(it != g_conf_files.end())
    {
        if(it->second->get_setup().get_config_url() != setup.get_config_url())
        {
            throw getopt_logic_error("trying to load configuration file \""
                                       + setup.get_config_url()
                                       + "\" but an existing configuration file with the same name was loaded with URL: \""
                                       + it->second->get_setup().get_config_url()
                                       + "\".");
        }
        return it->second;
    }
 
    // TODO: look into not blocking "forever"?
    //
    conf_file::pointer_t cf(new conf_file(setup));
    g_conf_files[setup.get_filename()] = cf;
    return cf;
}
 
 
void conf_file::reset_conf_files()
{
    cppthread::guard lock(get_global_mutex());
    g_conf_files.clear();
}
 
 
bool conf_file::save_configuration(
          std::string backup_extension
        , bool replace_backup
        , bool prepend_warning
        , std::string output_filename)
{
    if(f_modified)
    {
        std::string const & filename(output_filename.empty()
                    ? f_setup.get_filename()
                    : output_filename);
 
        // create backup?
        //
        if(!backup_extension.empty())
        {
            struct stat s = {};
            if(stat(filename.c_str(), &s) == 0)
            {
                if(backup_extension[0] != '.'
                && backup_extension[0] != '~')
                {
                    backup_extension.insert(0, 1, '.');
                }
 
                std::string const backup_filename(filename + backup_extension);
 
                if(replace_backup
                || access(backup_filename.c_str(), F_OK) != 0)
                {
                    if(unlink(backup_filename.c_str()) != 0
                    && errno != ENOENT)
                    {
                        f_errno = errno;   // LCOV_EXCL_LINE
                        return false;      // LCOV_EXCL_LINE
                    }
 
                    if(rename(filename.c_str(), backup_filename.c_str()) != 0)
                    {
                        f_errno = errno;   // LCOV_EXCL_LINE
                        return false;      // LCOV_EXCL_LINE
                    }
                }
            }
        }
 
        // TODO: look at adding the user:group info
        //
        if(snapdev::mkdir_p(filename, true) != 0)
        {
            f_errno = errno;   // LCOV_EXCL_LINE
            return false;      // LCOV_EXCL_LINE
        }
 
        // save parameters to file
        //
        std::ofstream conf;
        conf.open(filename);
        if(!conf.is_open())
        {
            f_errno = errno;   // LCOV_EXCL_LINE
            return false;      // LCOV_EXCL_LINE
        }
 
        // header warning with date & time
        //
        // (but only if the user doesn't already save comments otherwise
        // that one would get re-added each time--some form of recursivity)
        //
        if(prepend_warning
        && (f_parameters.empty()
            || f_parameters.begin()->second.get_comment().empty()))
        {
            time_t const now(time(nullptr));
            tm t;
            gmtime_r(&now, &t);
            char str_date[16];
            strftime(str_date, sizeof(str_date), "%Y/%m/%d", &t);
            char str_time[16];
            strftime(str_time, sizeof(str_time), "%H:%M:%S", &t);
 
            conf << "# This file was auto-generated by advgetopt on " << str_date << " at " << str_time << "." << std::endl
                 << "# Making modifications here is likely safe unless the tool handling this" << std::endl
                 << "# configuration file is actively working on it while you do the edits." << std::endl;
        }
        for(auto p : f_parameters)
        {
            // if the value has a comment, output it
            //
            conf << p.second.get_comment(true);
 
            if(f_setup.get_name_separator() == NAME_SEPARATOR_DASHES)
            {
                // `first` already has dashes
                //
                conf << p.first;
            }
            else
            {
                for(auto const c : p.first)
                {
                    conf << (c == '-' ? '_' : c);
                }
            }
 
            if((f_setup.get_assignment_operator() & ASSIGNMENT_OPERATOR_SPACE) != 0)
            {
                conf << ' ';
            }
            else if((f_setup.get_assignment_operator() & ASSIGNMENT_OPERATOR_COLON) != 0)
            {
                conf << ':';
            }
            else
            {
                conf << '=';
            }
 
            // prevent saving \r and \n characters as is when part of the
            // value; also double \ otherwise reading those back would fail
            //
            std::string const value(snapdev::string_replace_many(
                  p.second.get_value()
                , {
                    { "\\", "\\\\" },
                    { "\\r", "\\r" },
                    { "\\n", "\\n" },
                    { "\\t", "\\t" },
                }));
            conf << value << std::endl;
 
            if(!conf)
            {
                return false;   // LCOV_EXCL_LINE
            }
        }
 
        // it all worked, it's considered saved now
        //
        f_modified = false;
    }
 
    return true;
}
 
 
conf_file::conf_file(conf_file_setup const & setup)
    : f_setup(setup)
{
    read_configuration();
}
 
 
conf_file_setup const & conf_file::get_setup() const
{
    return f_setup;
}
 
 
conf_file::callback_id_t conf_file::add_callback(
          callback_t const & c
        , std::string const & parameter_name)
{
    cppthread::guard lock(get_global_mutex());
 
    ++f_next_callback_id;
    f_callbacks.emplace_back(f_next_callback_id, c, parameter_name);
    return f_next_callback_id;
}
 
 
void conf_file::remove_callback(callback_id_t id)
{
    cppthread::guard lock(get_global_mutex());
 
    auto it(std::find_if(
              f_callbacks.begin()
            , f_callbacks.end()
            , [id](auto e)
            {
                return e.f_id == id;
            }));
    if(it != f_callbacks.end())
    {
        f_callbacks.erase(it);
    }
}
 
 
void conf_file::value_changed(
          callback_action_t action
        , std::string const & parameter_name
        , std::string const & value)
{
    callback_vector_t callbacks;
    callbacks.reserve(f_callbacks.size());
 
    {
        cppthread::guard lock(get_global_mutex());
        callbacks = f_callbacks;
    }
 
    for(auto & e : callbacks)
    {
        if(e.f_parameter_name.empty()
        || e.f_parameter_name == parameter_name)
        {
            e.f_callback(shared_from_this(), action, parameter_name, value);
        }
    }
}
 
 
bool conf_file::exists() const
{
    cppthread::guard lock(get_global_mutex());
 
    return f_exists;
}
 
 
int conf_file::get_errno(bool clear) const
{
    cppthread::guard lock(get_global_mutex());
 
    int e(f_errno);
    if(clear)
    {
        f_errno = 0;
    }
    return e;
}
 
 
void conf_file::set_variables(variables::pointer_t variables)
{
    f_variables = variables;
}
 
 
variables::pointer_t conf_file::get_variables() const
{
    return f_variables;
}
 
 
conf_file::sections_t conf_file::get_sections() const
{
    cppthread::guard lock(get_global_mutex());
 
    return f_sections;
}
 
 
conf_file::parameters_t conf_file::get_parameters() const
{
    cppthread::guard lock(get_global_mutex());
 
    return f_parameters;
}
 
 
bool conf_file::has_parameter(std::string name) const
{
    std::replace(name.begin(), name.end(), '_', '-');
 
    cppthread::guard lock(get_global_mutex());
 
    auto it(f_parameters.find(name));
    return it != f_parameters.end();
}
 
 
std::string conf_file::get_parameter(std::string name) const
{
    std::replace(name.begin(), name.end(), '_', '-');
 
    cppthread::guard lock(get_global_mutex());
 
    auto it(f_parameters.find(name));
    if(it != f_parameters.end())
    {
        if(f_variables != nullptr)
        {
            return f_variables->process_value(it->second);
        }
        else
        {
            return it->second;
        }
    }
    return std::string();
}
 
 
bool conf_file::set_parameter(
      std::string section
    , std::string name
    , std::string const & value
    , assignment_t a
    , std::string const & comment)
{
    // use the tokenize_string() function because we do not want to support
    // quoted strings in this list of sections which our split_string()
    // does automatically
    //
    string_list_t section_list;
 
    std::replace(section.begin(), section.end(), '_', '-');
    std::replace(name.begin(), name.end(), '_', '-');
 
    char const * n(name.c_str());
 
    // global scope? if so ignore the section parameter
    //
    if((f_setup.get_section_operator() & SECTION_OPERATOR_CPP) != 0
    && n[0] == ':'
    && n[1] == ':')
    {
        do
        {
            ++n;
        }
        while(*n == ':');
    }
    else
    {
        snapdev::tokenize_string(section_list
                            , section
                            , "::"
                            , true
                            , std::string()
                            , &snapdev::string_predicate<string_list_t>);
    }
 
    char const * s(n);
    while(*n != '\0')
    {
        if((f_setup.get_section_operator() & SECTION_OPERATOR_C) != 0
        && *n == '.')
        {
            if(s == n)
            {
                cppthread::log << cppthread::log_level_t::error
                               << "option name \""
                               << name
                               << "\" cannot start with a period (.)."
                               << cppthread::end;
                return false;
            }
            section_list.push_back(std::string(s, n - s));
            do
            {
                ++n;
            }
            while(*n == '.');
            s = n;
        }
        else if((f_setup.get_section_operator() & SECTION_OPERATOR_CPP) != 0
             && n[0] == ':'
             && n[1] == ':')
        {
            if(s == n)
            {
                cppthread::log << cppthread::log_level_t::error
                               << "option name \""
                               << name
                               << "\" cannot start with a scope operator (::)."
                               << cppthread::end;
                return false;
            }
            section_list.push_back(std::string(s, n - s));
            do
            {
                ++n;
            }
            while(*n == ':');
            s = n;
        }
        else
        {
            ++n;
        }
    }
    if(s == n)
    {
        cppthread::log << cppthread::log_level_t::error
                       << "option name \""
                       << name
                       << "\" cannot end with a section operator or be empty."
                       << cppthread::end;
        return false;
    }
    std::string param_name(s, n - s);
 
    std::string const section_name(snapdev::join_strings(section_list, "::"));
 
    if(f_setup.get_section_operator() == SECTION_OPERATOR_NONE
    && !section_list.empty())
    {
        cppthread::log << cppthread::log_level_t::error
                       << "option name \""
                       << name
                       << "\" cannot be added to section \""
                       << section_name
                       << "\" because there is no section support for this configuration file."
                       << cppthread::end;
        return false;
    }
    if((f_setup.get_section_operator() & SECTION_OPERATOR_ONE_SECTION) != 0
    && section_list.size() > 1)
    {
        if(section_list.size() == 2
        && section_list[0] == f_setup.get_section_to_ignore())
        {
            section_list.erase(section_list.begin());
        }
        if(section_list.size() > 1)
        {
            cppthread::log << cppthread::log_level_t::error
                           << "option name \""
                           << name
                           << "\" cannot be added to section \""
                           << section_name
                           << "\" because this configuration only accepts one section level."
                           << cppthread::end;
            return false;
        }
    }
 
    section_list.push_back(param_name);
    std::string const full_name(snapdev::join_strings(section_list, "::"));
 
    // verify that each section name only includes characters we accept
    // for a parameter name
    //
    // WARNING: we do not test with full_name because it includes ':'
    //
    for(auto sn : section_list)
    {
        for(char const * f(sn.c_str()); *f != '\0'; ++f)
        {
            switch(*f)
            {
            case '\001':    // forbid controls
            case '\002':
            case '\003':
            case '\004':
            case '\005':
            case '\006':
            case '\007':
            case '\010':
            case '\011':
            case '\012':
            case '\013':
            case '\014':
            case '\015':
            case '\016':
            case '\017':
            case '\020':
            case '\021':
            case '\022':
            case '\023':
            case '\024':
            case '\025':
            case '\026':
            case '\027':
            case '\030':
            case '\031':
            case '\032':
            case '\033':
            case '\034':
            case '\035':
            case '\036':
            case '\037':
            case ' ':       // forbid spaces
            case '\'':      // forbid all quotes
            case '"':       // forbid all quotes
            case ';':       // forbid all comment operators
            case '#':       // forbid all comment operators
            case '/':       // forbid all comment operators
            case '=':       // forbid all assignment operators
            case ':':       // forbid all assignment operators
            case '?':       // forbid all assignment operators (for later)
            case '+':       // forbid all assignment operators (for later)
            case '\\':      // forbid backslashes
                cppthread::log << cppthread::log_level_t::error
                               << "section \""
                               << sn
                               << "\" from parameter \""
                               << full_name
                               << "\" on line "
                               << f_line
                               << " in configuration file \""
                               << f_setup.get_filename()
                               << "\" includes a character (\\"
                               << std::oct << std::setfill('0') << std::setw(3) << static_cast<int>(*f) << std::dec
                               << ") not acceptable for a section or parameter name (controls, space, quotes, and \";#/=:?+\\\")."
                               << cppthread::end;
                return false;
 
            }
        }
    }
 
    cppthread::guard lock(get_global_mutex());
 
    // add the section to the list of sections
    //
    // TODO: should we have a list of all the parent sections? Someone can
    //       write "a::b::c::d = 123" and we currently only get section
    //       "a::b::c", no section "a" and no section "a::b".
    //
    if(!section_name.empty())
    {
        f_sections.insert(section_name);
    }
 
    callback_action_t action(callback_action_t::created);
    auto it(f_parameters.find(full_name));
    if(it == f_parameters.end())
    {
        f_parameters[full_name] = value;
        f_parameters[full_name].set_comment(comment);
        f_parameters[full_name].set_line(f_line);
        f_parameters[full_name].set_assignment_operator(a);
    }
    else
    {
        if(f_reading)
        {
            // this is just a warning; it can be neat to know about such
            // problems and fix them early
            //
            cppthread::log << cppthread::log_level_t::warning
                           << "parameter \""
                           << full_name
                           << "\" on line "
                           << f_line
                           << " in configuration file \""
                           << f_setup.get_filename()
                           << "\" was found twice in the same configuration file."
                           << cppthread::end;
        }
 
        switch(a)
        {
        case assignment_t::ASSIGNMENT_SET:
        case assignment_t::ASSIGNMENT_NONE:
            it->second = value;
            break;
 
        case assignment_t::ASSIGNMENT_OPTIONAL:
            // already set, do not overwrite
            return false;
 
        case assignment_t::ASSIGNMENT_APPEND:
            it->second.set_value(it->second.get_value() + value);
            break;
 
        case assignment_t::ASSIGNMENT_NEW:
            cppthread::log << cppthread::log_level_t::error
                           << "parameter \""
                           << name
                           << "\" is already defined and it cannot be overridden with the ':=' operator on line "
                           << f_line
                           << " from configuration file \""
                           << f_setup.get_filename()
                           << "\"."
                           << cppthread::end;
            return false;
 
        }
 
        action = callback_action_t::updated;
    }
 
    if(!f_reading)
    {
        f_modified = true;
 
        value_changed(action, full_name, value);
    }
 
    return true;
}
 
 
bool conf_file::erase_parameter(std::string name)
{
    std::replace(name.begin(), name.end(), '_', '-');
 
    auto it(f_parameters.find(name));
    if(it == f_parameters.end())
    {
        return false;
    }
 
    f_parameters.erase(it);
 
    if(!f_reading)
    {
        f_modified = true;
 
        value_changed(callback_action_t::erased, name, std::string());
    }
 
    return true;
}
 
 
void conf_file::erase_all_parameters()
{
    while(!f_parameters.empty())
    {
        erase_parameter(f_parameters.begin()->first);
    }
}
 
 
bool conf_file::was_modified() const
{
    return f_modified;
}
 
 
int conf_file::getc(std::ifstream & in)
{
    if(f_unget_char != '\0')
    {
        int const r(f_unget_char);
        f_unget_char = '\0';
        return r;
    }
 
    char c;
    in.get(c);
 
    if(!in)
    {
        return EOF;
    }
 
    return static_cast<std::uint8_t>(c);
}
 
 
void conf_file::ungetc(int c)
{
    if(f_unget_char != '\0')
    {
        throw getopt_logic_error("conf_file::ungetc() called when the f_unget_char variable member is not '\\0'."); // LCOV_EXCL_LINE
    }
    f_unget_char = c;
}
 
 
bool conf_file::get_line(std::ifstream & in, std::string & line)
{
    line.clear();
 
    for(;;)
    {
        int c(getc(in));
        if(c == EOF)
        {
            return !line.empty();
        }
        if(c == ';'
        && f_setup.get_line_continuation() == line_continuation_t::line_continuation_semicolon)
        {
            return true;
        }
 
        while(c == '\n' || c == '\r')
        {
            // count the "\r\n" sequence as one line
            //
            if(c == '\r')
            {
                c = getc(in);
                if(c != '\n')
                {
                    ungetc(c);
                }
                c = '\n';
            }
 
            ++f_line;
            switch(f_setup.get_line_continuation())
            {
            case line_continuation_t::line_continuation_single_line:
                // continuation support
                return true;
 
            case line_continuation_t::line_continuation_rfc_822:
                c = getc(in);
                if(!iswspace(c))
                {
                    ungetc(c);
                    return true;
                }
                do
                {
                    c = getc(in);
                }
                while(iswspace(c));
                break;
 
            case line_continuation_t::line_continuation_msdos:
                if(line.empty()
                || line.back() != '&')
                {
                    return true;
                }
                line.pop_back();
                c = getc(in);
                break;
 
            case line_continuation_t::line_continuation_unix:
                if(line.empty()
                || line.back() != '\\')
                {
                    return true;
                }
                line.pop_back();
                c = getc(in);
                break;
 
            case line_continuation_t::line_continuation_fortran:
                c = getc(in);
                if(c != '&')
                {
                    ungetc(c);
                    return true;
                }
                c = getc(in);
                break;
 
            case line_continuation_t::line_continuation_semicolon:
                // if we have a comment, we want to return immediately;
                // at this time, the comments are not multi-line so
                // the call can return true only if we were reading the
                // very first line
                //
                if(is_comment(line.c_str()))
                {
                    return true;
                }
                // the semicolon is checked earlier, just keep the newline
                // in this case (but not at the start)
                //
                if(!line.empty() || c != '\n')
                {
                    line += c;
                }
                c = getc(in);
                break;
 
            }
        }
 
        // we just read the last line
        if(c == EOF)
        {
            return true;
        }
 
        line += c;
    }
}
 
 
void conf_file::read_configuration()
{
    snapdev::safe_variable<decltype(f_reading)> safe_reading(f_reading, true);
 
    std::ifstream conf(f_setup.get_filename());
    if(!conf)
    {
        f_errno = errno;
        return;
    }
    f_exists = true;
 
    bool const save_comment((f_setup.get_comment() & COMMENT_SAVE) != 0);
    std::string current_section;
    std::vector<std::string> sections;
    std::string str;
    std::string last_comment;
    f_line = 0;
    while(get_line(conf, str))
    {
        char const * s(str.c_str());
        while(iswspace(*s))
        {
            ++s;
        }
        if(*s == '\0'
        || is_comment(s))
        {
            // skip empty lines and comments
            //
            if(save_comment)
            {
                last_comment += str;
                last_comment += '\n';   // str does not include the newline
            }
            continue;
        }
        if((f_setup.get_section_operator() & SECTION_OPERATOR_BLOCK) != 0
        && *s == '}')
        {
            current_section = sections.back();
            sections.pop_back();
            continue;
        }
        char const * str_name(s);
        char const * e(nullptr);
        while(is_assignment_operator(s, false) == assignment_t::ASSIGNMENT_NONE
           && ((f_setup.get_section_operator() & SECTION_OPERATOR_BLOCK) == 0 || (*s != '{' && *s != '}'))
           && ((f_setup.get_section_operator() & SECTION_OPERATOR_INI_FILE) == 0 || *s != ']')
           && *s != '\0'
           && !iswspace(*s))
        {
            ++s;
        }
        if(iswspace(*s))
        {
            e = s;
            while(iswspace(*s))
            {
                ++s;
            }
            if(*s != '\0'
            && is_assignment_operator(s, false) == assignment_t::ASSIGNMENT_NONE
            && (f_setup.get_assignment_operator() & ASSIGNMENT_OPERATOR_SPACE) == 0
            && ((f_setup.get_section_operator() & SECTION_OPERATOR_BLOCK) == 0 || (*s != '{' && *s != '}')))
            {
                cppthread::log << cppthread::log_level_t::error
                               << "option name from \""
                               << str
                               << "\" on line "
                               << f_line
                               << " in configuration file \""
                               << f_setup.get_filename()
                               << "\" cannot include a space, missing assignment operator?"
                               << cppthread::end;
                continue;
            }
        }
        if(e == nullptr)
        {
            e = s;
        }
        if(e - str_name == 0)
        {
            cppthread::log << cppthread::log_level_t::error
                           << "no option name in \""
                           << str
                           << "\" on line "
                           << f_line
                           << " from configuration file \""
                           << f_setup.get_filename()
                           << "\", missing name before the assignment operator?"
                           << cppthread::end;
            continue;
        }
        std::string name(str_name, e - str_name);
        std::replace(name.begin(), name.end(), '_', '-');
        if(name[0] == '-')
        {
            cppthread::log << cppthread::log_level_t::error
                           << "option names in configuration files cannot start with a dash or an underscore in \""
                           << str
                           << "\" on line "
                           << f_line
                           << " from configuration file \""
                           << f_setup.get_filename()
                           << "\"."
                           << cppthread::end;
            continue;
        }
        if((f_setup.get_section_operator() & SECTION_OPERATOR_INI_FILE) != 0
        && name.length() >= 1
        && name[0] == '['
        && *s == ']')
        {
            ++s;
            if(!sections.empty())
            {
                cppthread::log << cppthread::log_level_t::error
                               << "`[...]` sections can't be used within a `section { ... }` on line "
                               << f_line
                               << " from configuration file \""
                               << f_setup.get_filename()
                               << "\"."
                               << cppthread::end;
                continue;
            }
            while(iswspace(*s))
            {
                ++s;
            }
            if(*s != '\0'
            && !is_comment(s))
            {
                cppthread::log << cppthread::log_level_t::error
                               << "section names in configuration files cannot be followed by anything other than spaces in \""
                               << str
                               << "\" on line "
                               << f_line
                               << " from configuration file \""
                               << f_setup.get_filename()
                               << "\"."
                               << cppthread::end;
                continue;
            }
            if(name.length() == 1)
            {
                // "[]" removes the section
                //
                current_section.clear();
            }
            else
            {
                current_section = name.substr(1);
                current_section += "::";
            }
            last_comment.clear();
        }
        else if((f_setup.get_section_operator() & SECTION_OPERATOR_BLOCK) != 0
             && *s == '{')
        {
            sections.push_back(current_section);
            current_section += name;
            current_section += "::";
            last_comment.clear();
        }
        else
        {
            assignment_t const a(is_assignment_operator(s, true));
            while(iswspace(*s))
            {
                ++s;
            }
            for(e = str.c_str() + str.length(); e > s; --e)
            {
                if(!iswspace(e[-1]))
                {
                    break;
                }
            }
            std::size_t const len(e - s);
            std::string const value(snapdev::string_replace_many(
                  std::string(s, len)
                , {
                    { "\\\\", "\\" },
                    { "\\r", "\r" },
                    { "\\n", "\n" },
                    { "\\t", "\t" },
                }));
            set_parameter(
                      current_section
                    , name
                    , unquote(value)
                    , a
                    , last_comment);
            last_comment.clear();
        }
    }
    if(!conf.eof())
    {
        f_errno = errno;                                            // LCOV_EXCL_LINE
        cppthread::log << cppthread::log_level_t::error             // LCOV_EXCL_LINE
                       << "an error occurred while reading line "   // LCOV_EXCL_LINE
                       << f_line                                    // LCOV_EXCL_LINE
                       << " of configuration file \""               // LCOV_EXCL_LINE
                       << f_setup.get_filename()                    // LCOV_EXCL_LINE
                       << "\"."                                     // LCOV_EXCL_LINE
                       << cppthread::end;                           // LCOV_EXCL_LINE
    }
    if(!sections.empty())
    {
        cppthread::log << cppthread::log_level_t::error
                       << "unterminated `section { ... }`, the `}` is missing in configuration file \""
                       << f_setup.get_filename()
                       << "\"."
                       << cppthread::end;
    }
}
 
 
assignment_t conf_file::is_assignment_operator(
      char const * & s
    , bool skip) const
{
    assignment_operator_t const assignment_operator(f_setup.get_assignment_operator());
    if(*s == '+'
    || *s == '?'
    || (*s == ':' && s[1] == '='))
    {
        if((assignment_operator & ASSIGNMENT_OPERATOR_EXTENDED) != 0
        && s[1] == '=')
        {
            char op(s[0]);
            if(skip)
            {
                s += 2;
            }
            switch(op)
            {
            case '+':
                return assignment_t::ASSIGNMENT_APPEND;
 
            case '?':
                return assignment_t::ASSIGNMENT_OPTIONAL;
 
            case ':':
                return assignment_t::ASSIGNMENT_NEW;
 
            default:
                throw getopt_logic_error("assignment not properly handled in is_assignment_operator()");
 
            }
        }
    }
    else if(((assignment_operator & ASSIGNMENT_OPERATOR_EQUAL) != 0 && *s == '=')
         || ((assignment_operator & ASSIGNMENT_OPERATOR_COLON) != 0 && *s == ':')
         || ((assignment_operator & ASSIGNMENT_OPERATOR_SPACE) != 0 && std::iswspace(*s)))
    {
        if(skip)
        {
            ++s;
        }
        return assignment_t::ASSIGNMENT_SET;
    }
 
    return assignment_t::ASSIGNMENT_NONE;
}
 
 
bool conf_file::is_comment(char const * s) const
{
    comment_t const comment(f_setup.get_comment());
    if((comment & COMMENT_INI) != 0
    && *s == ';')
    {
        return true;
    }
 
    if((comment & COMMENT_SHELL) != 0
    && *s == '#')
    {
        return true;
    }
 
    if((comment & COMMENT_CPP) != 0
    && s[0] == '/'
    && s[1] == '/')
    {
        return true;
    }
 
    return false;
}
 
 
int conf_file::section_to_variables(
      std::string const & section_name
    , variables::pointer_t vars)
{
    if(vars == nullptr)
    {
        return -1;
    }
 
    // verify/canonicalize the section variable name
    //
    auto section(f_sections.find(section_name));
    if(section == f_sections.end())
    {
        return -1;
    }
 
    // do not view that section as such anymore
    //
    f_sections.erase(section);
 
    int found(0);
    std::string starts_with(section_name);
    starts_with += "::";
    for(auto const & param : get_parameters())
    {
        if(param.first.length() > starts_with.length()
        && strncmp(param.first.c_str(), starts_with.c_str(), starts_with.length()) == 0)
        {
            vars->set_variable(
                      param.first.substr(starts_with.length())
                    , param.second
                    , param.second.get_assignment_operator());
            ++found;
 
            // this is safe because get_parameters() returned
            // a copy of the list of parameters
            //
            erase_parameter(param.first);
        }
    }
 
    return found;
}
 
 
bool iswspace(int c)
{
    return c != '\n'
        && c != '\r'
        && std::iswspace(c);
}
 
 
}   // namespace advgetopt
// vim: ts=4 sw=4 et