argparse.cpp

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2020, The Regents of the University of California,
// through Lawrence Berkeley National Laboratory (subject to receipt of any
// required approvals from the U.S. Dept. of Energy).  All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#ifndef TIMEMORY_UTILITY_ARGPARSE_CPP_
#define TIMEMORY_UTILITY_ARGPARSE_CPP_
 
#include "timemory/utility/macros.hpp"
 
#if !defined(TIMEMORY_UTILITY_HEADER_MODE)
#    include "timemory/utility/argparse.hpp"
#endif
 
namespace tim
{
namespace argparse
{
TIMEMORY_UTILITY_INLINE
argument_vector::argument_vector(int& argc, char**& argv)
: base_type()
{
    reserve(argc);
    for(int i = 0; i < argc; ++i)
        push_back(argv[i]);
}
 
TIMEMORY_UTILITY_INLINE
argument_vector::argument_vector(int& argc, const char**& argv)
: base_type()
{
    reserve(argc);
    for(int i = 0; i < argc; ++i)
        push_back(argv[i]);
}
 
TIMEMORY_UTILITY_INLINE
argument_vector::argument_vector(int& argc, const char* const*& argv)
{
    reserve(argc);
    for(int i = 0; i < argc; ++i)
        push_back(argv[i]);
}
 
TIMEMORY_UTILITY_INLINE argument_vector::cargs_t
                        argument_vector::get_execv(const base_type& _prepend, size_t _beg, size_t _end) const
{
    std::stringstream cmdss;
    // find the end if not specified
    _end = std::min<size_t>(size(), _end);
    // determine the number of arguments
    auto _argc = (_end - _beg) + _prepend.size();
    // create the new C argument array, add an extra entry at the end which will
    // always be a null pointer because that is how execv determines the end
    char** _argv = new char*[_argc + 1];
 
    // ensure all arguments are null pointers initially
    for(size_t i = 0; i < _argc + 1; ++i)
        _argv[i] = nullptr;
 
    // add the prepend list
    size_t _idx = 0;
    for(const auto& itr : _prepend)
        _argv[_idx++] = helpers::strdup(itr.c_str());
 
    // copy over the arguments stored internally from the range specified
    for(auto i = _beg; i < _end; ++i)
        _argv[_idx++] = helpers::strdup(this->at(i).c_str());
 
    // add check that last argument really is a nullptr
    assert(_argv[_argc] == nullptr);
 
    // create the command string
    for(size_t i = 0; i < _argc; ++i)
        cmdss << " " << _argv[i];
    auto cmd = cmdss.str().substr(1);
 
    // return a new (int argc, char** argv) and subtract 1 bc nullptr in last entry
    // does not count as argc
    return cargs_t(_argc - 1, _argv, cmd);
}
 
TIMEMORY_UTILITY_INLINE argument_vector::cargs_t
                        argument_vector::get_execv(size_t _beg, size_t _end) const
{
    return get_execv(base_type{}, _beg, _end);
}
 
TIMEMORY_UTILITY_INLINE void
argument_parser::print_help(const std::string& _extra)
{
    std::stringstream _usage;
    if(!m_desc.empty())
        _usage << "[" << m_desc << "] ";
    _usage << "Usage: " << m_bin;
 
    std::cerr << _usage.str();
 
    std::stringstream _sshort_desc;
    auto              _indent = _usage.str().length() + 2;
    size_t            _ncnt   = 0;
    for(auto& a : m_arguments)
    {
        std::string name = a.m_names.at(0);
        if(name.empty() || name.find_first_of('-') > name.find_first_not_of(" -"))
            continue;
        // select the first long option
        for(size_t n = 1; n < a.m_names.size(); ++n)
        {
            if(name.find("--") == 0)
                break;
            else if(a.m_names.at(n).find("--") == 0)
            {
                name = a.m_names.at(n);
                break;
            }
        }
        if(name.length() > 0)
        {
            if(_ncnt++ > 0)
                _sshort_desc << "\n " << std::setw(_indent) << " " << name;
            else
                _sshort_desc << " " << name;
 
            _sshort_desc << " (";
            if(a.m_count != argument::Count::ANY)
                _sshort_desc << "count: " << a.m_count;
            else if(a.m_min_count != argument::Count::ANY)
                _sshort_desc << "min: " << a.m_min_count;
            else if(a.m_max_count != argument::Count::ANY)
                _sshort_desc << "max: " << a.m_max_count;
            else
                _sshort_desc << "count: unlimited";
            if(!a.m_dtype.empty())
                _sshort_desc << ", dtype: " << a.m_dtype;
            else if(a.m_count == 0 ||
                    (a.m_count == argument::Count::ANY && a.m_max_count == 1))
                _sshort_desc << ", dtype: bool" << a.m_dtype;
            _sshort_desc << ")";
        }
    }
 
    std::string _short_desc;
    if(!_sshort_desc.str().empty())
    {
        _short_desc.append("[" + _sshort_desc.str());
        std::stringstream _tmp;
        _tmp << "\n" << std::setw(_indent) << "]";
        _short_desc.append(_tmp.str());
    }
 
    if(m_positional_arguments.empty())
    {
        std::cerr << " " << _short_desc << " " << _extra << std::endl;
    }
    else
    {
        std::cerr << " " << _short_desc;
        if(!_short_desc.empty())
            std::cerr << "\n" << std::setw(_indent - 2) << " ";
        for(auto& itr : m_positional_arguments)
        {
            std::cerr << " " << helpers::ltrim(itr.m_names.at(0), [](int c) -> bool {
                return c != static_cast<int>('-');
            });
        }
 
        int current = 0;
        for(auto& v : m_positional_map)
        {
            if(v.first != argument::Position::LastArgument)
            {
                for(; current < v.first; ++current)
                    std::cerr << " [" << current << "]";
                std::cerr << " ["
                          << helpers::ltrim(
                                 m_arguments[static_cast<size_t>(v.second)].m_names.at(0),
                                 [](int c) -> bool { return c != static_cast<int>('-'); })
                          << "]";
            }
            else
            {
                std::cerr << " ... ["
                          << helpers::ltrim(
                                 m_arguments[static_cast<size_t>(v.second)].m_names.at(0),
                                 [](int c) -> bool { return c != static_cast<int>('-'); })
                          << "]";
            }
        }
        std::cerr << " " << _extra << std::endl;
    }
 
    std::cerr << "\nOptions:" << std::endl;
    for(auto& a : m_arguments)
    {
        std::string name = a.m_names.at(0);
        for(size_t n = 1; n < a.m_names.size(); ++n)
            name.append(", " + a.m_names[n]);
        std::stringstream ss;
        ss << name;
        if(a.m_choices.size() > 0)
        {
            ss << " [";
            auto itr = a.m_choices.begin();
            ss << " " << *itr++;
            for(; itr != a.m_choices.end(); ++itr)
                ss << " | " << *itr;
            ss << " ] ";
        }
        std::stringstream prefix;
        prefix << "    " << std::setw(m_width) << std::left << ss.str();
        std::cerr << std::left << prefix.str();
 
        auto desc = a.m_desc;
        if(ss.str().length() >= static_cast<size_t>(m_width))
            desc = std::string("\n%{NEWLINE}%") + desc;
 
        {
            // replace %{INDENT}% with indentation
            const std::string indent_key = "%{INDENT}%";
            const auto        npos       = std::string::npos;
            auto              pos        = npos;
            std::stringstream indent;
            indent << std::setw(prefix.str().length()) << "";
            while((pos = desc.find(indent_key)) != npos)
                desc = desc.replace(pos, indent_key.length(), indent.str());
        }
 
        {
            // replace %{NEWLINE}% with indentation
            const std::string indent_key = "%{NEWLINE}%";
            const auto        npos       = std::string::npos;
            auto              pos        = npos;
            std::stringstream indent;
            indent << std::setw(m_width + 5) << "";
            while((pos = desc.find(indent_key)) != npos)
                desc = desc.replace(pos, indent_key.length(), indent.str());
        }
 
        std::cerr << " " << std::setw(m_width) << desc;
 
        if(a.m_required)
            std::cerr << " (Required)";
        std::cerr << std::endl;
    }
    std::cerr << '\n';
}
 
TIMEMORY_UTILITY_INLINE argument_parser::arg_result
                        argument_parser::parse_known_args(int* argc, char*** argv, strvec_t& _args,
                                  const std::string& _delim, int verbose_level)
{
    // check for help flag
    auto help_check = [&](int _argc, char** _argv) {
        strset_t help_args = { "-h", "--help", "-?" };
        auto     _help_req = (exists("help") ||
                          (_argc > 1 && help_args.find(_argv[1]) != help_args.end()));
        if(_help_req && !exists("help"))
        {
            for(auto hitr : help_args)
            {
                auto hstr = hitr.substr(hitr.find_first_not_of('-'));
                auto itr  = m_name_map.find(hstr);
                if(itr != m_name_map.end())
                    m_arguments[static_cast<size_t>(itr->second)].m_found = true;
            }
        }
        return _help_req;
    };
 
    // check for a dash in th command line
    bool _pdash = false;
    for(int i = 1; i < *argc; ++i)
    {
        if((*argv)[i] == std::string("--"))
            _pdash = true;
    }
 
    // parse the known args and get the remaining argc/argv
    auto _pargs = parse_known_args(*argc, *argv, _args, _delim, verbose_level);
    auto _perrc = std::get<0>(_pargs);
    auto _pargc = std::get<1>(_pargs);
    auto _pargv = std::get<2>(_pargs);
 
    // check if help was requested before the dash (if dash exists)
    if(help_check((_pdash) ? 0 : _pargc, _pargv))
        return arg_result{ "help requested" };
 
    // assign the argc and argv
    *argc = _pargc;
    *argv = _pargv;
 
    return _perrc;
}
 
TIMEMORY_UTILITY_INLINE argument_parser::known_args_t
                        argument_parser::parse_known_args(int argc, char** argv, strvec_t& _args,
                                  const std::string& _delim, int verbose_level)
{
    int    _cmdc = argc;  // the argc after known args removed
    char** _cmdv = argv;  // the argv after known args removed
    // _cmdv and argv are same pointer unless delimiter is found
 
    if(argc > 0)
    {
        m_bin = std::string((const char*) argv[0]);
        _args.push_back(std::string((const char*) argv[0]));
    }
 
    for(int i = 1; i < argc; ++i)
    {
        std::string _arg = argv[i];
        if(_arg == _delim)
        {
            _cmdc        = argc - i;
            _cmdv        = new char*[_cmdc + 1];
            _cmdv[_cmdc] = nullptr;
            _cmdv[0]     = helpers::strdup(argv[0]);
            int k        = 1;
            for(int j = i + 1; j < argc; ++j, ++k)
                _cmdv[k] = helpers::strdup(argv[j]);
            break;
        }
        else
        {
            _args.push_back(std::string((const char*) argv[i]));
        }
    }
 
    auto cmd_string = [](int _ac, char** _av) {
        std::stringstream ss;
        for(int i = 0; i < _ac; ++i)
            ss << _av[i] << " ";
        return ss.str();
    };
 
    if((_cmdc > 0 && verbose_level > 0) || verbose_level > 1)
        std::cerr << "\n";
 
    if(verbose_level > 1)
    {
        std::cerr << "[original]> " << cmd_string(argc, argv) << std::endl;
        std::cerr << "[cfg-args]> ";
        for(auto& itr : _args)
            std::cerr << itr << " ";
        std::cerr << std::endl;
    }
 
    if(_cmdc > 0 && verbose_level > 0)
        std::cerr << "[command]>  " << cmd_string(_cmdc, _cmdv) << "\n\n";
 
    return known_args_t{ parse(_args, verbose_level), _cmdc, _cmdv };
}
 
TIMEMORY_UTILITY_INLINE argument_parser::arg_result
                        argument_parser::parse(const std::vector<std::string>& _args, int verbose_level)
{
    if(verbose_level > 0)
    {
        std::cerr << "[argparse::parse]> parsing '";
        for(const auto& itr : _args)
            std::cerr << itr << " ";
        std::cerr << "'" << '\n';
    }
 
    for(auto& a : m_arguments)
        a.m_callback(a.m_default);
    for(auto& a : m_positional_arguments)
        a.m_callback(a.m_default);
 
    using argmap_t = std::map<std::string, argument*>;
 
    argmap_t   m_arg_map = {};
    arg_result err;
    int        argc = _args.size();
    // the set of options which use a single leading dash but are longer than
    // one character, e.g. -LS ...
    std::set<std::string> long_short_opts;
    if(_args.size() > 1)
    {
        auto is_leading_dash = [](int c) -> bool { return c != static_cast<int>('-'); };
        // build name map
        for(auto& a : m_arguments)
        {
            for(auto& n : a.m_names)
            {
                auto        nleading_dash = helpers::lcount(n, is_leading_dash);
                std::string name          = helpers::ltrim(n, is_leading_dash);
                if(name.empty())
                    continue;
                if(m_name_map.find(name) != m_name_map.end())
                    return arg_result("Duplicate of argument name: " + n);
                m_name_map[name] = a.m_index;
                m_arg_map[name]  = &a;
                if(nleading_dash == 1 && name.length() > 1)
                    long_short_opts.insert(name);
            }
            if(a.m_position >= 0 || a.m_position == argument::Position::LastArgument)
                m_positional_map.at(a.m_position) = a.m_index;
        }
 
        m_bin = _args.at(0);
 
        // parse
        std::string current_arg;
        size_t      arg_len;
        for(int argv_index = 1; argv_index < argc; ++argv_index)
        {
            current_arg = _args.at(argv_index);
            arg_len     = current_arg.length();
            if(arg_len == 0)
                continue;
            if(argv_index == argc - 1 &&
               m_positional_map.find(argument::Position::LastArgument) !=
                   m_positional_map.end())
            {
                err          = end_argument();
                arg_result b = err;
                err          = add_value(current_arg, argument::Position::LastArgument);
                if(b)
                    return b;
                // return (m_error_func(*this, b), b);
                if(err)
                    return (m_error_func(*this, err), err);
                continue;
            }
 
            // count number of leading dashes
            auto nleading_dash = helpers::lcount(current_arg, is_leading_dash);
            // ignores the case if the arg is just a '-'
            // look for -a (short) or --arg (long) args
            bool is_arg = (nleading_dash > 0 && arg_len > 1 && arg_len != nleading_dash)
                              ? true
                              : false;
 
            if(is_arg && !helpers::is_numeric(current_arg))
            {
                err = end_argument();
                if(err)
                    return (m_error_func(*this, err), err);
 
                auto name   = current_arg.substr(nleading_dash);
                auto islong = (nleading_dash > 1 || long_short_opts.count(name) > 0);
                err         = begin_argument(name, islong, argv_index);
                if(err)
                    return (m_error_func(*this, err), err);
            }
            else if(current_arg.length() > 0)
            {
                // argument value
                err = add_value(current_arg, argv_index);
                if(err)
                    return (m_error_func(*this, err), err);
            }
        }
    }
 
    // return the help
    if(m_help_enabled && exists("help"))
        return arg_result("help requested");
 
    err = end_argument();
    if(err)
        return (m_error_func(*this, err), err);
 
    // check requirements
    for(auto& a : m_arguments)
    {
        if(a.m_required && !a.m_found)
        {
            return arg_result("Required argument not found: " + a.m_names.at(0));
        }
        if(a.m_position >= 0 && argc >= a.m_position && !a.m_found)
        {
            return arg_result("argument " + a.m_names.at(0) + " expected in position " +
                              std::to_string(a.m_position));
        }
    }
 
    // check requirements
    for(auto& a : m_positional_arguments)
    {
        if(a.m_required && !a.m_found)
            return arg_result("Required argument not found: " + a.m_names.at(0));
    }
 
    // check all the counts have been satisfied
    for(auto& a : m_arguments)
    {
        if(a.m_found && a.m_default == nullptr)
        {
            auto cnt_err = check_count(a);
            if(cnt_err)
                return cnt_err;
        }
    }
 
    // execute the global actions
    for(auto& itr : m_actions)
    {
        if(itr.first(*this))
            itr.second(*this);
    }
 
    // execute the argument-specific actions
    for(auto& itr : m_arg_map)
    {
        if(exists(itr.first))
            itr.second->execute_actions(*this);
    }
 
    return arg_result{};
}
 
TIMEMORY_UTILITY_INLINE argument_parser::arg_result
                        argument_parser::begin_argument(const std::string& arg, bool longarg, int position)
{
    auto it = m_positional_map.find(position);
    if(it != m_positional_map.end())
    {
        arg_result err = end_argument();
        argument&  a   = m_arguments[static_cast<size_t>(it->second)];
        a.m_values.push_back(arg);
        a.m_found = true;
        return err;
    }
    if(m_current != -1)
    {
        return arg_result("Current argument left open");
    }
    size_t      name_end = helpers::find_punct(arg);
    std::string arg_name = arg.substr(0, name_end);
    if(longarg)
    {
        int  equal_pos = helpers::find_equiv(arg);
        auto nmf       = m_name_map.find(arg_name);
        if(nmf == m_name_map.end())
        {
            arg_name = arg.substr(0, equal_pos);
            nmf      = m_name_map.find(arg_name);
        }
        if(nmf == m_name_map.end())
        {
            return arg_result("Unrecognized command line option '" + arg_name + "'");
        }
        m_current                                             = nmf->second;
        m_arguments[static_cast<size_t>(nmf->second)].m_found = true;
        if(equal_pos == 0 || (equal_pos < 0 && arg_name.length() < arg.length()))
        {
            // malformed argument
            return arg_result("Malformed argument: " + arg);
        }
        else if(equal_pos > 0)
        {
            std::string arg_value = arg.substr(name_end + 1);
            add_value(arg_value, position);
        }
    }
    else
    {
        arg_result r;
        if(arg_name.length() == 1)
        {
            return begin_argument(arg, true, position);
        }
        else
        {
            for(char& c : arg_name)
            {
                r = begin_argument(std::string(1, c), true, position);
                if(r)
                {
                    return r;
                }
                r = end_argument();
                if(r)
                {
                    return r;
                }
            }
        }
    }
    return arg_result{};
}
 
TIMEMORY_UTILITY_INLINE argument_parser::arg_result
                        argument_parser::add_value(const std::string& value, int location)
{
    auto unnamed = [&]() {
        auto itr = m_positional_map.find(location);
        if(itr != m_positional_map.end())
        {
            argument& a = m_arguments[static_cast<size_t>(itr->second)];
            a.m_values.push_back(value);
            a.m_found = true;
        }
        else
        {
            auto idx = m_positional_values.size();
            m_positional_values.emplace(idx, value);
            if(idx < m_positional_arguments.size())
            {
                auto& a   = m_positional_arguments.at(idx);
                a.m_found = true;
                auto err  = a.check_choice(value);
                if(err)
                    return err;
                a.m_values.push_back(value);
                a.execute_actions(*this);
            }
        }
        return arg_result{};
    };
 
    if(m_current >= 0)
    {
        arg_result err;
        size_t     c = static_cast<size_t>(m_current);
        consume_parameters(c);
        argument& a = m_arguments[static_cast<size_t>(m_current)];
 
        err = a.check_choice(value);
        if(err)
            return err;
 
        auto num_values = [&]() { return static_cast<int>(a.m_values.size()); };
 
        // check {m_count, m_max_count} > COUNT::ANY && m_values.size() >= {value}
        if((a.m_count >= 0 && num_values() >= a.m_count) ||
           (a.m_max_count >= 0 && num_values() >= a.m_max_count))
        {
            err = end_argument();
            if(err)
                return err;
            return unnamed();
        }
 
        a.m_values.push_back(value);
 
        // check {m_count, m_max_count} > COUNT::ANY && m_values.size() >= {value}
        if((a.m_count >= 0 && num_values() >= a.m_count) ||
           (a.m_max_count >= 0 && num_values() >= a.m_max_count))
        {
            err = end_argument();
            if(err)
                return err;
        }
        return arg_result{};
    }
 
    return unnamed();
}
 
TIMEMORY_UTILITY_INLINE argument_parser::arg_result
                        argument_parser::end_argument()
{
    if(m_current >= 0)
    {
        argument& a = m_arguments[static_cast<size_t>(m_current)];
        m_current   = -1;
        if(static_cast<int>(a.m_values.size()) < a.m_count)
            return arg_result("Too few arguments given for " + a.m_names.at(0));
        if(a.m_max_count >= 0)
        {
            if(static_cast<int>(a.m_values.size()) > a.m_max_count)
                return arg_result("Too many arguments given for " + a.m_names.at(0));
        }
        else if(a.m_count >= 0)
        {
            if(static_cast<int>(a.m_values.size()) > a.m_count)
                return arg_result("Too many arguments given for " + a.m_names.at(0));
        }
    }
    return arg_result{};
}
 
TIMEMORY_UTILITY_INLINE std::ostream&
                        operator<<(std::ostream& os, const argument_parser::arg_result& r)
{
    os << r.what();
    return os;
}
 
}  // namespace argparse
}  // namespace tim
 
#endif