advgetopt.cpp

Go to the documentation of this file.

// Copyright (c) 2006-2024  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/advgetopt.h"
 
#include    "advgetopt/exception.h"
 
 
// snapdev
//
#include    <snapdev/join_strings.h>
#include    <snapdev/not_reached.h>
 
 
// cppthread
//
#include    <cppthread/log.h>
 
 
// libutf8
//
#include    <libutf8/iterator.h>
 
 
// C
//
#include    <string.h>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
 
 
namespace advgetopt
{
 
 
namespace
{
 
 
option const g_system_options[] =
{
    define_option(
          Name("build-date")
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("print out the time and date when %p was built and exit.")
    ),
    define_option(
          Name("compiler-version")
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("print the version of the compiler used to compile the advgetopt library.")
    ),
    define_option(
          Name("configuration-filenames")
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("print out the list of configuration files checked out by this tool.")
    ),
    define_option(
          Name("copyright")
        , ShortName('C')
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS>())
        , Help("print out the copyright of %p and exit.")
    ),
    define_option(
          Name("environment-variable-name")
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("print out the name of the environment variable supported by %p (if any.)")
    ),
    define_option(
          Name("has-sanitizer")
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("print whether the advgetopt was compiled with the sanitizer extension.")
    ),
    define_option(
          Name("help")
        , ShortName('h')
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_USAGE_ON_ERROR>())
        , Help("print out this help screen and exit.")
    ),
    define_option(
          Name("license")
        , ShortName('L')
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS>())
        , Help("print out the license of %p and exit.")
    ),
    define_option(
          Name("path-to-option-definitions")
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("print out the path to the option definitions.")
    ),
    define_option(
          Name("print-option")
        , Flags(command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_REQUIRED
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("print the value of the named option after parsing all the options from the command line, environment variables, and configuration files.")
    ),
    define_option(
          Name("show-option-sources")
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS
            , GETOPT_FLAG_SHOW_SYSTEM>())
        , Help("parse all the options and then print out the source of each value and each override.")
    ),
    define_option(
          Name("version")
        , ShortName('V')
        , Flags(standalone_command_flags<
              GETOPT_FLAG_GROUP_COMMANDS>())
        , Help("print out the version of %p and exit.")
    ),
    end_options()
};
 
 
option const g_if_configuration_filename_system_options[] =
{
    define_option(
          Name("config-dir")
        , Flags(any_flags<GETOPT_FLAG_COMMAND_LINE
                        , GETOPT_FLAG_ENVIRONMENT_VARIABLE
                        , GETOPT_FLAG_REQUIRED
                        , GETOPT_FLAG_MULTIPLE
                        , GETOPT_FLAG_GROUP_OPTIONS>())
        , Help("add one or more configuration directory paths to search for configuration files.")
    ),
    end_options()
};
 
 
 
 
bool is_arg(char const * a)
{
    // "-" and "--" are not options; however "--" returns true
    // because after a "--" we take the data as default arguments
    return a[0] == '-' && a[1] != '\0';
}
 
 
 
void check_for_show_sources(int argc, char * argv[])
{
    static bool found = false;
 
    if(!found && argv != nullptr)
    {
        for(int idx(1); idx < argc; ++idx)
        {
            if(strcmp(argv[idx], "--show-option-sources") == 0)
            {
                found = true;
                option_info::set_trace_sources(true);
            }
        }
    }
}
 
 
 
} // no name namespace
 
 
 
getopt::getopt(options_environment const & opt_env)
{
    initialize_parser(opt_env);
}
 
 
getopt::getopt(options_environment const & opt_env
             , int argc
             , char * argv[])
{
    // TODO: I do not think that this check_for_show_sources() is required
    //       because we also do it in finish_parsing()
    //
    check_for_show_sources(argc, argv);
 
    initialize_parser(opt_env);
    finish_parsing(argc, argv);
}
 
 
void getopt::initialize_parser(options_environment const & opt_env)
{
    f_variables = std::make_shared<variables>();
    f_options_environment = opt_env;
 
    parse_options_info(f_options_environment.f_options, false);
    parse_options_from_file();
    if(has_flag(GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS | GETOPT_ENVIRONMENT_FLAG_PROCESS_SYSTEM_PARAMETERS))
    {
        parse_options_info(g_system_options, true);
        if(f_options_environment.f_configuration_filename != nullptr
        && *f_options_environment.f_configuration_filename != '\0')
        {
            // add the "--config-dir <path> ..." option
            //
            parse_options_info(g_if_configuration_filename_system_options, true);
        }
    }
    parse_options_from_group_names();
 
    define_environment_variable_data();
}
 
 
void getopt::finish_parsing(int argc, char * argv[])
{
    if(argv == nullptr)
    {
        throw getopt_logic_error("argv pointer cannot be nullptr");
    }
 
    check_for_show_sources(argc, argv);
 
    parse_program_name(argv);
    if(f_options_by_name.empty())
    {
        throw getopt_logic_error("an empty list of options is not legal, you must defined at least one (i.e. --version, --help...)");
    }
 
    link_aliases();
 
    parse_configuration_files(argc, argv);
    f_parsed = false;
    parse_environment_variable();
    f_parsed = false;
    parse_arguments(argc, argv, option_source_t::SOURCE_COMMAND_LINE, false);
 
    if(has_flag(GETOPT_ENVIRONMENT_FLAG_PROCESS_SYSTEM_PARAMETERS))
    {
        flag_t const result(process_system_options(std::cout));
        if((result & SYSTEM_OPTION_COMMANDS_MASK) != 0)
        {
            throw getopt_exit("system command processed.", 0);
        }
    }
 
    if(cppthread::log.get_errors() != 0)
    {
        throw getopt_exit("errors were found on your command line, environment variable, or configuration file.", 1);
    }
}
 
 
void getopt::is_parsed() const
{
    if(!f_parsed
    && (f_options_environment.f_environment_flags & GETOPT_ENVIRONMENT_FLAG_AUTO_DONE) == 0)
    {
        throw getopt_initialization(
                "function called too soon, parser is not done yet"
                " (i.e. is_defined(), get_string(), get_long(),"
                " get_double() cannot be called until the parser is done)");
    }
}
 
 
options_environment const & getopt::get_options_environment() const
{
    return f_options_environment;
}
 
 
bool getopt::has_flag(flag_t flag) const
{
    return (f_options_environment.f_environment_flags & flag) != 0;
}
 
 
void getopt::define_environment_variable_data()
{
    f_environment_variable.clear();
 
    if(f_options_environment.f_environment_variable_name == nullptr
    || *f_options_environment.f_environment_variable_name == '\0')
    {
        // no name
        //
        return;
    }
 
    char const * s(getenv(f_options_environment.f_environment_variable_name));
    if(s == nullptr)
    {
        // no environment variable with that name
        //
        return;
    }
 
    f_environment_variable = s;
}
 
 
void getopt::parse_environment_variable()
{
    // first test the global environment variable
    //
    if(!f_environment_variable.empty())
    {
        parse_string(
                  f_environment_variable
                , option_source_t::SOURCE_ENVIRONMENT_VARIABLE
                , true);
    }
 
    // second check each option environment variable
    //
    for(auto const & opt : f_options_by_name)
    {
        std::string const name(opt.second->get_environment_variable_name());
 
        // get the value, only set the option if the variable is set
        //
        std::string value;
        if(opt.second->get_environment_variable_value(
                  value
                , f_options_environment.f_environment_variable_intro))
        {
            add_option_from_string(
                      opt.second
                    , value
                    , std::string()
                    , string_list_t()
                    , option_source_t::SOURCE_ENVIRONMENT_VARIABLE);
        }
    }
 
    f_parsed = true;
}
 
 
void getopt::parse_string(
          std::string const & str
        , option_source_t source
        , bool only_environment_variable)
{
    string_list_t args(split_environment(str));
    if(args.empty())
    {
        // nothing extra to do
        //
        return;
    }
 
    // TODO: expand the arguments that include unquoted '*', '?', '[...]'
    //       (note that we remove the quotes at the moment so we'd have
    //       to keep track of that specific problem...)
 
    // the argv array has to be a null terminated bare string pointers
    //
    std::vector<char *> sub_argv;
 
    sub_argv.resize(args.size() + 2);
 
    // argv[0] is the program name
    //
    sub_argv[0] = const_cast<char *>(f_program_fullname.c_str());
 
    // the other arguments are from the variable
    //
    for(size_t idx(0); idx < args.size(); ++idx)
    {
        sub_argv[idx + 1] = const_cast<char *>(args[idx].c_str());
    }
 
    // this is probably already a nullptr
    //
    sub_argv[args.size() + 1] = nullptr;
 
    // now convert those parameters in values
    //
    parse_arguments(
          static_cast<int>(sub_argv.size() - 1)
        , sub_argv.data()
        , source
        , only_environment_variable);
}
 
 
string_list_t getopt::split_environment(std::string const & environment)
{
    // this is exactly like the command line only in an environment variable
    // so parse the parameters just like the shell
    //
    string_list_t args;
    std::string a;
    char const * s(environment.c_str());
    while(*s != '\0')
    {
        if(isspace(*s))
        {
            if(!a.empty())
            {
                args.push_back(a);
                a.clear();
            }
            do
            {
                ++s;
            }
            while(isspace(*s));
        }
        else if(*s == '"'
             || *s == '\'')
        {
            // support quotations and remove them from the argument
            //
            char const quote(*s++);
            while(*s != '\0'
               && *s != quote)
            {
                a += *s++;
            }
            if(*s != '\0')
            {
                ++s;
            }
        }
        else
        {
            a += *s++;
        }
    }
 
    if(!a.empty())
    {
        args.push_back(a);
    }
 
    return args;
}
 
 
void getopt::parse_arguments(
          int argc
        , char * argv[]
        , option_source_t source
        , bool only_environment_variable)
{
    for(int i(1); i < argc; ++i)
    {
        if(argv[i][0] == '-')
        {
            if(argv[i][1] == '-')
            {
                if(argv[i][2] == '\0')
                {
                    // end of options, skip the '--' and then anything else
                    // is taken as "filenames" (or whatever the tool expects)
                    //
                    if(f_default_option == nullptr)
                    {
                        cppthread::log << cppthread::log_level_t::error
                                       << "no default options defined; thus \"--\" is not accepted by this program."
                                       << cppthread::end;
                        break;
                    }
 
                    if(only_environment_variable)
                    {
                        if(!f_default_option->has_flag(GETOPT_FLAG_ENVIRONMENT_VARIABLE))
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"--\" is not supported in the environment variable."
                                           << cppthread::end;
                            break;
                        }
                    }
                    else
                    {
                        if(!f_default_option->has_flag(GETOPT_FLAG_COMMAND_LINE))
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"--\" is not supported on the command line."
                                           << cppthread::end;
                            break;
                        }
                    }
 
                    // in this case we do NOT test whether an argument uses
                    // a dash (-) we take them all as default options
                    //
                    while(i + 1 < argc)
                    {
                        ++i;
                        f_default_option->add_value(argv[i], string_list_t(), source);
                    }
                }
                else
                {
                    // a long option, check that it is defined in the
                    // programmer defined options
                    //
                    std::string option_name(argv[i] + 2);
                    std::string option_value;
                    std::string::size_type pos(option_name.find('='));
                    if(pos != std::string::npos)
                    {
                        if(pos == 0)
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "name missing in \""
                                           << argv[i]
                                           << "\"."
                                           << cppthread::end;
                            break;
                        }
 
                        option_value = option_name.substr(pos + 1);
                        option_name.resize(pos);
                    }
                    string_list_t option_keys;
                    option_info::pointer_t opt(get_option(option_name));
                    if(opt == nullptr)
                    {
                        pos = option_name.find_first_of("[:");
                        if(pos != std::string::npos)
                        {
                            option_keys = parse_option_map(option_name.substr(pos));
                            option_name.resize(pos);
                            opt = get_option(option_name);
                        }
                        if(opt == nullptr)
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"--"
                                           << option_name
                                           << "\" is not supported."
                                           << cppthread::end;
                            break;
                        }
                        if(!opt->has_flag(GETOPT_FLAG_ARRAY))
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"--"
                                           << option_name
                                           << "\" does not support the array or map syntax."
                                           << cppthread::end;
                            break;
                        }
                        if(option_keys.empty())
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"--"
                                           << option_name
                                           << "\" has an invalid list of array keys."
                                           << cppthread::end;
                            break;
                        }
                    }
                    if(only_environment_variable)
                    {
                        if(!opt->has_flag(GETOPT_FLAG_ENVIRONMENT_VARIABLE))
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"--"
                                           << option_name
                                           << "\" is not supported in the environment variable."
                                           << cppthread::end;
                            break;
                        }
                    }
                    else
                    {
                        if(!opt->has_flag(GETOPT_FLAG_COMMAND_LINE))
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"--"
                                           << option_name
                                           << "\" is not supported on the command line."
                                           << cppthread::end;
                            break;
                        }
                    }
                    if(pos != std::string::npos)
                    {
                        // the user specified a value after an equal sign
                        //
                        add_option_from_string(
                                  opt
                                , option_value
                                , std::string()
                                , option_keys
                                , source);
                    }
                    else
                    {
                        add_options(opt, i, argc, argv, option_keys, source);
                    }
                }
            }
            else
            {
                if(argv[i][1] == '\0')
                {
                    // stdin/stdout (a '-' by itself)
                    //
                    if(f_default_option == nullptr)
                    {
                        cppthread::log << cppthread::log_level_t::error
                                       << "no default options defined; thus \"-\" is not accepted by this program."
                                       << cppthread::end;
                        break;
                    }
                    if(only_environment_variable)
                    {
                        if(!f_default_option->has_flag(GETOPT_FLAG_ENVIRONMENT_VARIABLE))
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"-\" is not supported in the environment variable."
                                           << cppthread::end;
                            break;
                        }
                    }
                    else
                    {
                        if(!f_default_option->has_flag(GETOPT_FLAG_COMMAND_LINE))
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"-\" is not supported on the command line."
                                           << cppthread::end;
                            break;
                        }
                    }
 
                    // this is similar to a default option by itself
                    //
                    f_default_option->add_value(argv[i], string_list_t(), source);
                }
                else
                {
                    // short option(s)
                    //
                    // i gets incremented by add_options() so we have to
                    // keep a copy in `k`
                    //
                    std::string const short_args_string(argv[i] + 1);
                    for(libutf8::utf8_iterator short_args(short_args_string)
                      ; short_args != short_args_string.end()
                      ; ++short_args)
                    {
                        option_info::pointer_t opt(get_option(*short_args));
                        if(opt == nullptr)
                        {
                            cppthread::log << cppthread::log_level_t::error
                                           << "option \"-"
                                           << short_name_to_string(*short_args)
                                           << "\" is not supported."
                                           << cppthread::end;
                            break;
                        }
                        if(only_environment_variable)
                        {
                            if(!opt->has_flag(GETOPT_FLAG_ENVIRONMENT_VARIABLE))
                            {
                                cppthread::log << cppthread::log_level_t::error
                                               << "option \"-"
                                               << short_name_to_string(*short_args)
                                               << "\" is not supported in the environment variable."
                                               << cppthread::end;
                                break;
                            }
                        }
                        else
                        {
                            if(!opt->has_flag(GETOPT_FLAG_COMMAND_LINE))
                            {
                                cppthread::log << cppthread::log_level_t::error
                                               << "option \"-"
                                               << short_name_to_string(*short_args)
                                               << "\" is not supported on the command line."
                                               << cppthread::end;
                                break;
                            }
                        }
                        add_options(opt, i, argc, argv, string_list_t(), source);
                    }
                }
            }
        }
        else
        {
            // direct entry (filename or whatever the tool expects as a default)
            //
            if(f_default_option == nullptr)
            {
                cppthread::log << cppthread::log_level_t::error
                               << "no default options defined; we do not know what to do of \""
                               << argv[i]
                               << "\"; standalone parameters are not accepted by this program."
                               << cppthread::end;
                break;
            }
            if(only_environment_variable)
            {
                if(!f_default_option->has_flag(GETOPT_FLAG_ENVIRONMENT_VARIABLE))
                {
                    cppthread::log << cppthread::log_level_t::error
                                   << "default options are not supported in the environment variable."
                                   << cppthread::end;
                    break;
                }
            }
            else
            {
                if(!f_default_option->has_flag(GETOPT_FLAG_COMMAND_LINE))
                {
                    cppthread::log << cppthread::log_level_t::error
                                   << "default options are not supported on the command line."
                                   << cppthread::end;
                    break;
                }
            }
            f_default_option->add_value(argv[i], string_list_t(), source);
        }
    }
 
    f_parsed = true;
}
 
 
string_list_t getopt::parse_option_map(std::string const & raw_key)
{
    string_list_t keys;
    if(raw_key.empty())
    {
        return keys;
    }
 
    if(raw_key[0] == '[')
    {
        // the array syntax allows for keys to be written between square
        // brackets instead of separated by colon so [a][b][c] is equivalent
        // to a:b:c
        //
        std::string result;
        std::string::size_type pos(1);
        for(;;)
        {
            std::string::size_type start(pos);
            pos = raw_key.find(']', pos);
            if(pos == std::string::npos)
            {
                // this is an error...
                //
                return string_list_t();
            }
            std::string key(raw_key.substr(start, pos - start));
            if(!key.empty())
            {
                keys.push_back(key);
            }
            ++pos;
            if(pos >= raw_key.length())
            {
                break;
            }
            if(raw_key[pos] != '[')
            {
                // the next key must start with a '['
                //
                return string_list_t();
            }
            ++pos;
        }
    }
    else
    {
        split_string(raw_key, keys, {":"});
    }
 
    // remove duplicates also sort the keys (which is not a perfect thing
    // to do, but it shouldn't hurt except that numbers will not be sorted
    // properly, i.e. "10" appears before "2").
    //
    std::sort(keys.begin(), keys.end());
    keys.erase(std::unique(keys.begin(), keys.end()), keys.end());
 
    return keys;
}
 
 
option_info::pointer_t getopt::get_alias_destination(option_info::pointer_t opt) const
{
    if(opt != nullptr
    && opt->has_flag(GETOPT_FLAG_ALIAS))
    {
        opt = opt->get_alias_destination();
        if(opt == nullptr)
        {
            throw getopt_undefined("getopt::get_alias_destination(): alias is missing. Did you call link_aliases()?");
        }
    }
 
    return opt;
}
 
 
option_info::map_by_name_t const & getopt::get_options() const
{
    return f_options_by_name;
}
 
 
option_info::pointer_t getopt::get_option(std::string const & name, bool exact_option) const
{
    option_info::pointer_t opt;
 
    if(name.empty())
    {
        // see \note section in doxy above about this
        //
        throw getopt_invalid_parameter("get_option() `name` argument cannot be empty.");
    }
 
    std::string const n(option_with_dashes(name));
 
    // we need this special case when looking for the default option
    // because the name may not be "--" in the option table
    // (i.e. you could call your default option "filenames" for example.)
    //
    if(n.length() == 2
    && n[0] == '-'
    && n[1] == '-')
    {
        opt = f_default_option;
    }
    else
    {
        short_name_t short_name(string_to_short_name(n));
        if(short_name != NO_SHORT_NAME)
        {
            auto it(f_options_by_short_name.find(short_name));
            if(it != f_options_by_short_name.end())
            {
                opt = it->second;
            }
        }
        else
        {
            auto it(f_options_by_name.find(n));
            if(it != f_options_by_name.end())
            {
                opt = it->second;
            }
        }
    }
 
    return exact_option
            ? opt
            : get_alias_destination(opt);
}
 
 
option_info::pointer_t getopt::get_option(short_name_t short_name, bool exact_option) const
{
    auto it(f_options_by_short_name.find(short_name));
    if(it == f_options_by_short_name.end())
    {
        return option_info::pointer_t();
    }
 
    return exact_option
                ? it->second
                : get_alias_destination(it->second);
}
 
 
void getopt::add_options(
          option_info::pointer_t opt
        , int & i
        , int argc
        , char ** argv
        , string_list_t const & option_keys
        , option_source_t source)
{
    if(opt->has_flag(GETOPT_FLAG_FLAG))
    {
        opt->add_value(opt->get_default(), option_keys, source);
    }
    else
    {
        if(i + 1 < argc && !is_arg(argv[i + 1]))
        {
            if(opt->has_flag(GETOPT_FLAG_MULTIPLE))
            {
                do
                {
                    ++i;
                    opt->add_value(argv[i], option_keys, source);
                }
                while(i + 1 < argc && !is_arg(argv[i + 1]));
            }
            else
            {
                ++i;
                opt->add_value(argv[i], option_keys, source);
            }
        }
        else
        {
            if(opt->has_flag(GETOPT_FLAG_REQUIRED))
            {
                cppthread::log << cppthread::log_level_t::error
                               << "option --"
                               << opt->get_name()
                               << " expects an argument."
                               << cppthread::end;
            }
            else
            {
                // We need to set something because the value is being
                // set although no argument was specified (but that's
                // legal by this argument's definition)
                //
                opt->add_value(std::string(), option_keys, source);
            }
        }
    }
}
 
 
void getopt::add_option_from_string(
          option_info::pointer_t opt
        , std::string const & value
        , std::string const & filename
        , string_list_t const & option_keys
        , option_source_t source)
{
    // is the value defined?
    //
    if(!value.empty())
    {
        if(!opt->has_flag(GETOPT_FLAG_FLAG))
        {
            // does the option support multiple entries?
            //
            if(opt->has_flag(GETOPT_FLAG_MULTIPLE))
            {
                opt->set_multiple_values(value, option_keys, source);
            }
            else
            {
                opt->set_value(0, value, option_keys, source);
            }
            return;
        }
 
        // for flags, allow "true" or "false" that way we can reset those
        // flags and especially, it's possible to use them in configuration
        // files that way
        //
        if(is_false(value))
        {
            opt->reset();
            return;
        }
 
        if(is_true(value))
        {
            // for this, pass an empty string to the next layer
            //
            opt->set_value(0, std::string(), option_keys, source);
            return;
        }
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wrestrict"
        cppthread::log << cppthread::log_level_t::error
                       << "option "
                       << (filename.empty()
                               ? "--" + opt->get_name()
                               : "\"" + option_with_underscores(opt->get_name()) + "\"")
                       << " cannot be given value \""
                       << value
                       << "\""
                       << (filename.empty()
                           ? std::string()
                           : " in configuration file \""
                               + filename
                               + "\"")
                       << ". It only accepts \"true\" or \"false\"."
                       << cppthread::end;
#pragma GCC diagnostic pop
        return;
    }
 
    // does the option require a value when used?
    //
    if(opt->has_flag(GETOPT_FLAG_REQUIRED))
    {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wrestrict"
        cppthread::log << cppthread::log_level_t::error
                       << "option "
                       << (filename.empty()
                               ? "--" + opt->get_name()
                               : "\"" + option_with_underscores(opt->get_name()) + "\"")
                       << " must be given a value"
                       << (filename.empty()
                           ? std::string()
                           : " in configuration file \""
                               + filename
                               + "\"")
                       << "."
                       << cppthread::end;
#pragma GCC diagnostic pop
        return;
    }
 
    // accept an empty value otherwise
    //
    opt->set_value(0, value, option_keys, source);
}
 
 
variables::pointer_t getopt::get_variables() const
{
    return f_variables;
}
 
 
 
} // namespace advgetopt
// vim: ts=4 sw=4 et