command_line.hpp

// Copyright Take Vos 2021.
// 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)
 
#include "coroutine"
#include "os_detect.hpp"
 
#pragma once
 
namespace tt {
 
struct cmdline_short_option {
    char32_t option;
    std::option<std::string> argument;
};
 
struct cmdline_long_option {
    std::string option;
    std::option<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)
{
    ttlet options_with_arguments_ = tt::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
            ttlet 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.
                tt_axiom(eq_index >= 2);
                ttlet name_length = eq_index - 2;
                co_yield cmdln_long_option(it->substr(2, name_length), it->substr(eq_index + 1));
            }
 
        } else if (it.front() == '-' || it.front() == '+') {
            // List of short-options.
            // Short options are processed as UTF-32 units.
            ttlet token = to_u32string(*it);
            ttlet first_c = std::next(std::begin(token));
            ttlet last_c = std::end(token);
            negative = it.front() == '+';
 
            for (auto jt = first_c; jt != last_c; ++jt) {
                ttlet c = *jt;
                auto name = tt::to_string(std::u32string(1, c));
 
                if (options_with_arguments_.find(c) == std::u32string::npos) {
                    // 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 = tt::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;
    tt::notifier<void(std::string_view argument)> notifier;
 
    constexpr command_line_option(std::string_view option_help) {
        auto it = std::begin(option_help);
        ttlet last = std::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 TT_OPERATING_SYSTEM == TT_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 = {};
};
 
 
}