command_line.hpp

// Copyright Take Vos 2021-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "utility/module.hpp"
#include "generator.hpp"
#include <optional>
#include <string>
#include <variant>
 
namespace hi::inline v1 {
 
struct cmdline_short_option {
    char32_t option;
    std::optional<std::string> argument;
};
 
struct cmdline_long_option {
    std::string option;
    std::optional<std::string> argument;
};
 
struct cmdline_executable {
    std::string executable;
};
 
struct cmdline_non_option {
    std::string argument;
};
 
using cmdline_option = std::variant<cmline_executable, cmdline_short_option, cmdline_long_option, cmdline_argument>;
 
template<typename It>
generator<cmdln_option> command_line_parser(It first, It last, std::string_view options_with_arguments)
{
    hilet options_with_arguments_ = hi::to_u32string(options_with_arguments);
    auto it = first;
 
    if (it != last) {
        co_yield cmdln_option::executable{*it};
        ++it;
    }
 
    char32_t short_option_name = 0;
    for (; it != last; ++it) {
        if (short_option_name) {
            // Add the argument to the option.
            co_yield cmdln_short_option{short_option_name, *it};
            short_option_name = 0;
 
        } else if (*it == "--") {
            break;
 
        } else if (it->starts_with("--")) {
            // Long-option
            hilet eq_index = it->find('=');
            if (eq_index == std::string::npos) {
                // Long-option without argument
                co_yield cmdln_long_option{it->substr(2), {}};
 
            } else {
                // Long-option with argument in same token.
                hi_assert(eq_index >= 2);
                hilet name_length = eq_index - 2;
                co_yield cmdln_long_option(it->substr(2, name_length), it->substr(eq_index + 1));
            }
 
        } else if (it.front() == '-' or it.front() == '+') {
            // List of short-options.
            // Short options are processed as UTF-32 units.
            hilet token = to_u32string(*it);
            hilet first_c = std::next(begin(token));
            hilet last_c = end(token);
            negative = it.front() == '+';
 
            for (auto jt = first_c; jt != last_c; ++jt) {
                hilet c = *jt;
                auto name = hi::to_string(std::u32string(1, c));
 
                if (not options_with_arguments_.contains(c)) {
                    // Option without argument
                    co_yield cmdln_short_option(c, {});
 
                } else if (std::next(jt) == last) {
                    // Option with the argument in the next token.
                    short_option_name = c;
 
                } else {
                    // Option with argument, where the argument is inside this token
                    auto argument = hi::to_string(std::u32string(std::next(jt), last_c));
                    co_yield cmdln_short_option(c, std::move(argument));
                    break;
                }
            }
 
        } else {
            // Anything not looking like an option is a non-option
            co_yield cmdln_non_option{*it};
        }
    }
 
    // All tokens after double hyphen '--' are non-options.
    for (; it != last; ++it) {
        co_yield cmdln_non_option{*it};
    }
 
    if (short_option_name) {
        throw parse_error("Missing argument for option -{}", short_option_name);
    }
}
 
class command_line_option {
public:
    char32_t short_option;
    std::string long_option;
    std::string argument_name;
    std::string description;
    hi::notifier<void(std::string_view argument)> notifier;
 
    constexpr command_line_option(std::string_view option_help)
    {
        auto it = begin(option_help);
        hilet last = end(option_help);
    }
 
    static char32_t parse_short_option(std::string_view::iterator &it, std::string_view::iterator last)
    {
        if (it == last || *it != '-') {
            throw parse_error("Expecting '-'");
        }
 
        ++it;
 
        if (it == last) {
            throw parse_error("Missing character after '-'");
        }
        if (*it == '-') {
            return 0;
        }
    }
};
 
class command_line {
public:
#if HI_OPERATING_SYSTEM == HI_OS_WINDOWS
    void parse();
#else
    void parse(int argc, char **argv);
#endif
 
    template<typename... Args>
    command_line_option &add_option(Args &&...args) noexcept
    {
        return _options.emplace(std::forward<Args>(args)...);
    }
 
private:
    std::vector<command_line_option> _options = {};
};
 
} // namespace hi::inline v1