variables.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/variables.h"
 
#include    "advgetopt/exception.h"
 
 
// C++
//
#include    <iostream>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
namespace advgetopt
{
 
 
 
std::string variables::canonicalize_variable_name(std::string const & name)
{
    std::string result;
 
    bool first(true);
    for(char const * n(name.c_str()); *n != '\0'; ++n)
    {
        if(*n == ':' || *n == '.')
        {
            if(first)
            {
                throw getopt_invalid(
                      "found an empty section name in \""
                    + name
                    + "\".");
            }
            while(n[1] == ':' || n[1] == '.')
            {
                ++n;
            }
            result += "::";
            first = true;
        }
        else
        {
            if(first && *n >= '0' && *n <= '9')
            {
                throw getopt_invalid(
                      "a variable name or section name in \""
                    + name
                    + "\" starts with a digit, which is not allowed.");
            }
            first = false;
            if(*n == '_')
            {
                result += '-';
            }
            else
            {
                result += *n;
            }
        }
    }
 
    return result;
}
 
 
bool variables::has_variable(std::string const & name) const
{
    auto it(f_variables.find(canonicalize_variable_name(name)));
    return it != f_variables.end();
}
 
 
std::string variables::get_variable(std::string const & name) const
{
    auto it(f_variables.find(canonicalize_variable_name(name)));
    if(it != f_variables.end())
    {
        return it->second;
    }
 
    return std::string();
}
 
 
variables::variable_t const & variables::get_variables() const
{
    return f_variables;
}
 
 
void variables::set_variable(
      std::string const & name
    , std::string const & value
    , assignment_t assignment)
{
    std::string const var(canonicalize_variable_name(name));
    auto it(f_variables.find(var));
    switch(assignment)
    {
    case assignment_t::ASSIGNMENT_OPTIONAL:
        if(it == f_variables.end())
        {
            f_variables[var] = value;
        }
        break;
 
    case assignment_t::ASSIGNMENT_APPEND:
        if(it == f_variables.end())
        {
            f_variables[var] = value;
        }
        else
        {
            f_variables[var] = it->second + value;
        }
        break;
 
    case assignment_t::ASSIGNMENT_NEW:
        if(it == f_variables.end())
        {
            f_variables[var] = value;
        }
        else
        {
            throw getopt_defined_twice(
                  "variable \""
                + var
                + "\" is already defined.");
        }
        break;
 
    //case assignment_t::ASSIGNMENT_NONE:
    //case assignment_t::ASSIGNMENT_SET:
    default:
        f_variables[var] = value;
        break;
 
    }
}
 
 
std::string variables::process_value(std::string const & value) const
{
    // to support the recursivity, we call a sub-function which calls itself
    // whenever a variable is discovered to include another variable; that
    // recursivity is broken immediately if a variable includes itself;
    // this function is private
    //
    variable_names_t names;
    return recursive_process_value(value, names);
}
 
 
std::string variables::recursive_process_value(
      std::string const & value
    , variable_names_t & names) const
{
    std::string result;
 
    for(char const * s(value.c_str()); *s != '\0'; ++s)
    {
        char c(*s);
        if(c == '$' && s[1] == '{') // start variable reference?
        {
            s += 2;
            char const * name(s);
            for(; *s != '}' && *s != '\0'; ++s);
            if(*s == '\0')
            {
                // invalid variable reference
                //
                result += "${";
                result += name;
                return result;
            }
 
            // TODO: add support for conversions like we have in bash
            //       (i.e. ${var:-extension} ${var%.extension} ...
            //       see man bash section "Parameter Expansion")
            //
            // TODO: add support for emitting errors on an undefined
            //       variable
            //
            std::string var(std::string(name, s - name));
            auto allowed(names.insert(var));
            if(allowed.second)
            {
                result += recursive_process_value(get_variable(var), names);
                names.erase(allowed.first);
            }
            else
            {
                result += "<variable \"" + var + "\" loops>";
            }
        }
        else
        {
            result += c;
        }
    }
 
    return result;
} // LCOV_EXCL_LINE
 
 
 
} // namespace advgetopt
// vim: ts=4 sw=4 et