From 8f740d1979d4ca40011a0879d02317d6d37049ba Mon Sep 17 00:00:00 2001
From: Owen Smith <yeeetari@gmail.com>
Date: Wed, 6 Mar 2024 00:05:31 +0000
Subject: [PATCH] wip args parser

---
 engine/include/vull/support/args_parser.hh |  59 +++++
 engine/include/vull/support/string.hh      |  11 +-
 engine/include/vull/support/string_view.hh |  37 +++
 engine/sources/CMakeLists.txt              |   1 +
 engine/sources/support/args_parser.cc      | 295 +++++++++++++++++++++
 engine/sources/support/string.cc           |  35 ++-
 engine/sources/support/string_builder.cc   |   5 +
 tools/vsi.cc                               |  27 +-
 8 files changed, 438 insertions(+), 32 deletions(-)
 create mode 100644 engine/include/vull/support/args_parser.hh
 create mode 100644 engine/sources/support/args_parser.cc

diff --git a/engine/include/vull/support/args_parser.hh b/engine/include/vull/support/args_parser.hh
new file mode 100644
index 00000000..5dde5f50
--- /dev/null
+++ b/engine/include/vull/support/args_parser.hh
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <vull/container/vector.hh>
+#include <vull/support/function.hh>
+#include <vull/support/optional.hh>
+#include <vull/support/string.hh>
+#include <vull/support/string_builder.hh>
+
+namespace vull {
+
+enum class ArgsParseResult {
+    Continue,
+    ExitFailure,
+    ExitSuccess,
+};
+
+class ArgsParser {
+    struct Argument {
+        String name;
+        uint32_t min_values;
+        uint32_t max_values;
+        Function<ArgsParseResult(StringView, StringView)> accept_value;
+
+        String to_string() const;
+    };
+
+    struct Option {
+        String help_string;
+        String long_name;
+        char short_name;
+        bool has_argument;
+        Function<ArgsParseResult(StringView, StringView)> accept_value;
+    };
+
+private:
+    String m_name;
+    String m_description;
+    String m_version;
+    Vector<Argument> m_arguments;
+    Vector<Option> m_options;
+
+    void print_help(StringView program_path);
+    ArgsParseResult handle_long_option(Option *&option_waiting_for_argument, StringView program_path,
+                                       StringView option_name);
+    ArgsParseResult handle_short_option(Option *&option_waiting_for_argument, StringView program_path,
+                                        char option_name);
+
+public:
+    ArgsParser(String name, String description, String version);
+
+    template <typename T>
+    void add_argument(T &value, String name, bool required);
+    void add_flag(bool &present, String help_string, String long_name, char short_name = '\0');
+    template <typename T>
+    void add_option(T &value, String help_string, String long_name, char short_name = '\0');
+    ArgsParseResult parse_args(int argc, const char *const *argv);
+};
+
+} // namespace vull
diff --git a/engine/include/vull/support/string.hh b/engine/include/vull/support/string.hh
index 602d49bc..6253f4c5 100644
--- a/engine/include/vull/support/string.hh
+++ b/engine/include/vull/support/string.hh
@@ -16,6 +16,7 @@ class String {
 public:
     static String copy_raw(const char *data, size_t length);
     static String move_raw(char *data, size_t length);
+    static String repeated(char ch, size_t length);
 
     constexpr String() = default;
     explicit String(size_t length);
@@ -28,6 +29,14 @@ public:
     String &operator=(const String &) = delete;
     String &operator=(String &&);
 
+    int compare(StringView other) const;
+
+    bool starts_with(char ch) const;
+    bool ends_with(char ch) const;
+
+    bool starts_with(StringView other) const;
+    bool ends_with(StringView other) const;
+
     char *begin() const { return m_data; }
     char *end() const { return m_data + m_length; }
 
@@ -37,8 +46,6 @@ public:
     char &operator[](size_t index) { return m_data[index]; }
     const char &operator[](size_t index) const { return m_data[index]; }
 
-    bool ends_with(StringView end);
-
     operator StringView() const { return view(); }
     StringView view() const { return {m_data, m_length}; }
 
diff --git a/engine/include/vull/support/string_view.hh b/engine/include/vull/support/string_view.hh
index a65d4271..6019e2f1 100644
--- a/engine/include/vull/support/string_view.hh
+++ b/engine/include/vull/support/string_view.hh
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <vull/maths/common.hh>
 #include <vull/support/assert.hh>
 #include <vull/support/span.hh>
 
@@ -12,12 +13,32 @@ public:
     using Span::Span;
     constexpr StringView(const char *c_string) : Span(c_string, __builtin_strlen(c_string)) {}
 
+    constexpr int compare(StringView other) const;
     constexpr StringView substr(size_t offset) const;
     constexpr StringView substr(size_t offset, size_t length) const;
+
+    constexpr bool starts_with(char ch) const;
+    constexpr bool ends_with(char ch) const;
+
+    constexpr bool starts_with(StringView other) const;
+    constexpr bool ends_with(StringView other) const;
+
     constexpr bool operator==(StringView other) const;
     constexpr size_t length() const { return size(); }
 };
 
+constexpr int StringView::compare(StringView other) const {
+    int ret = __builtin_memcmp(data(), other.data(), vull::min(length(), other.length()));
+    if (ret == 0) {
+        if (length() < other.length()) {
+            ret = -1;
+        } else if (length() > other.length()) {
+            ret = 1;
+        }
+    }
+    return ret;
+}
+
 constexpr StringView StringView::substr(size_t offset) const {
     return substr(offset, length() - offset);
 }
@@ -27,6 +48,22 @@ constexpr StringView StringView::substr(size_t offset, size_t length) const {
     return {data() + offset, length};
 }
 
+constexpr bool StringView::starts_with(char ch) const {
+    return !empty() && begin()[0] == ch;
+}
+
+constexpr bool StringView::ends_with(char ch) const {
+    return !empty() && end()[-1] == ch;
+}
+
+constexpr bool StringView::starts_with(StringView other) const {
+    return length() >= other.length() && substr(0, other.length()).compare(other) == 0;
+}
+
+constexpr bool StringView::ends_with(StringView other) const {
+    return length() >= other.length() && substr(length() - other.length()).compare(other) == 0;
+}
+
 constexpr bool StringView::operator==(StringView other) const {
     if (data() == nullptr) {
         return other.data() == nullptr;
diff --git a/engine/sources/CMakeLists.txt b/engine/sources/CMakeLists.txt
index b25f186b..8f8a75c9 100644
--- a/engine/sources/CMakeLists.txt
+++ b/engine/sources/CMakeLists.txt
@@ -7,6 +7,7 @@ target_sources(vull-core PRIVATE
     platform/linux.cc
     scene/scene.cc
     scene/transform.cc
+    support/args_parser.cc
     support/assert.cc
     support/stream.cc
     support/string.cc
diff --git a/engine/sources/support/args_parser.cc b/engine/sources/support/args_parser.cc
new file mode 100644
index 00000000..0dd80a34
--- /dev/null
+++ b/engine/sources/support/args_parser.cc
@@ -0,0 +1,295 @@
+#include <vull/support/args_parser.hh>
+
+#include <vull/container/vector.hh>
+#include <vull/core/log.hh>
+#include <vull/support/algorithm.hh>
+#include <vull/support/string_view.hh>
+#include <vull/support/utility.hh>
+
+namespace vull {
+
+ArgsParser::ArgsParser(String name, String description, String version)
+    : m_name(vull::move(name)), m_description(vull::move(description)), m_version(vull::move(version)) {
+    m_options.push(Option{
+        .help_string = "Print this help information",
+        .long_name = "help",
+        .accept_value =
+            [this](StringView program_path, StringView) {
+                print_help(program_path);
+                return ArgsParseResult::ExitSuccess;
+            },
+    });
+    m_options.push(Option{
+        .help_string = "Print version information",
+        .long_name = "version",
+        .accept_value =
+            [this](StringView, StringView) {
+                vull::println("{} {}", m_name, m_version);
+                return ArgsParseResult::ExitSuccess;
+            },
+    });
+}
+
+template <>
+void ArgsParser::add_argument(String &value, String name, bool required) {
+    m_arguments.push(Argument{
+        .name = vull::move(name),
+        .min_values = required ? 1u : 0u,
+        .max_values = 1,
+        .accept_value =
+            [&value](StringView, StringView argument) {
+                value = argument;
+                return ArgsParseResult::Continue;
+            },
+    });
+}
+
+template <>
+void ArgsParser::add_argument(Vector<String> &value, String name, bool required) {
+    m_arguments.push(Argument{
+        .name = vull::move(name),
+        .min_values = required ? 1u : 0u,
+        .max_values = UINT32_MAX,
+        .accept_value =
+            [&value](StringView, StringView argument) {
+                value.push(argument);
+                return ArgsParseResult::Continue;
+            },
+    });
+}
+
+void ArgsParser::add_flag(bool &present, String help_string, String long_name, char short_name) {
+    m_options.push(Option{
+        .help_string = vull::move(help_string),
+        .long_name = vull::move(long_name),
+        .short_name = short_name,
+        .accept_value =
+            [&present](StringView, StringView) {
+                present = true;
+                return ArgsParseResult::Continue;
+            },
+    });
+}
+
+template <>
+void ArgsParser::add_option(String &value, String help_string, String long_name, char short_name) {
+    m_options.push(Option{
+        .help_string = vull::move(help_string),
+        .long_name = vull::move(long_name),
+        .short_name = short_name,
+        .has_argument = true,
+        .accept_value =
+            [&value](StringView, StringView argument) {
+                value = argument;
+                return ArgsParseResult::Continue;
+            },
+    });
+}
+
+String ArgsParser::Argument::to_string() const {
+    StringBuilder sb;
+    if (min_values > 0) {
+        sb.append("<{}>", name);
+    } else {
+        sb.append("[{}]", name);
+    }
+    if (max_values > 1) {
+        sb.append("...");
+    }
+    return sb.build();
+}
+
+void ArgsParser::print_help(StringView program_path) {
+    vull::println("{} - {}\n", m_name, m_description);
+
+    StringBuilder usage_sb;
+    usage_sb.append("Usage: {} [options] ", program_path);
+    for (const auto &argument : m_arguments) {
+        usage_sb.append(argument.to_string());
+        usage_sb.append(' ');
+    }
+    vull::println(usage_sb.build());
+
+    vull::println("Options:");
+    for (const auto &option : m_options) {
+        StringBuilder sb;
+        sb.append("  ");
+
+        // Print short name or whitespace.
+        if (option.short_name != '\0') {
+            sb.append('-');
+            sb.append(option.short_name);
+            sb.append(", ");
+        } else {
+            sb.append("    ");
+        }
+
+        // Print long name.
+        sb.append("--");
+        sb.append(option.long_name);
+
+        // Print alignment whitespace for help string.
+        if (option.long_name.length() >= 20) {
+            sb.append('\n');
+            sb.append(String::repeated(' ', 28));
+        } else {
+            sb.append(String::repeated(' ', 20 - option.long_name.length()));
+        }
+
+        // Insert alignment on newlines in help string.
+        for (char ch : option.help_string) {
+            if (ch == '\n') {
+                sb.append('\n');
+                sb.append(String::repeated(' ', 28));
+                continue;
+            }
+            sb.append(ch);
+        }
+        vull::println(sb.build());
+    }
+}
+
+ArgsParseResult ArgsParser::handle_long_option(Option *&option_waiting_for_argument, StringView program_path,
+                                               StringView option_name) {
+    StringView argument;
+    for (size_t i = 0; i < option_name.length(); i++) {
+        if (option_name[i] == '=') {
+            argument = option_name.substr(i + 1);
+            option_name = option_name.substr(0, i);
+            break;
+        }
+    }
+
+    auto *option = vull::find_if(m_options.begin(), m_options.end(), [option_name](const Option &option) {
+        return option_name == option.long_name.view();
+    });
+
+    if (option == m_options.end()) {
+        vull::println("{}: unrecognised option '--{}'", program_path, option_name);
+        return ArgsParseResult::ExitFailure;
+    }
+
+    if (!option->has_argument && !argument.empty()) {
+        vull::println("{}: option '--{}' doesn't allow an argument", program_path, option->long_name);
+        return ArgsParseResult::ExitFailure;
+    }
+
+    if (option->has_argument && argument.empty()) {
+        option_waiting_for_argument = option;
+        return ArgsParseResult::Continue;
+    }
+
+    return option->accept_value(program_path, argument);
+}
+
+ArgsParseResult ArgsParser::handle_short_option(Option *&option_waiting_for_argument, StringView program_path,
+                                                char option_name) {
+    auto *option = vull::find_if(m_options.begin(), m_options.end(), [option_name](const Option &option) {
+        return option_name == option.short_name;
+    });
+
+    if (option == m_options.end()) {
+        vull::println("{}: unrecognised option '-{c}'", program_path, option_name);
+        return ArgsParseResult::ExitFailure;
+    }
+
+    if (option->has_argument) {
+        option_waiting_for_argument = option;
+        return ArgsParseResult::Continue;
+    }
+
+    return option->accept_value(program_path, {});
+}
+
+ArgsParseResult ArgsParser::parse_args(int argc, const char *const *argv) {
+    Vector<StringView> args(argv, argv + argc);
+    if (args.empty()) {
+        args.push(m_name);
+    }
+
+    bool accepting_options = true;
+    uint32_t argument_index = 0;
+    uint32_t argument_value_count = 0;
+    Option *option_waiting_for_argument = nullptr;
+    for (const auto &arg : vull::slice(args, 1u)) {
+        if (auto *option = vull::exchange(option_waiting_for_argument, nullptr)) {
+            if (auto result = option->accept_value(args[0], arg); result != ArgsParseResult::Continue) {
+                return result;
+            }
+            continue;
+        }
+
+        if (accepting_options && arg == "--") {
+            accepting_options = false;
+            continue;
+        }
+
+        // Handle long options.
+        if (accepting_options && arg.starts_with("--")) {
+            if (auto result = handle_long_option(option_waiting_for_argument, args[0], arg.substr(2));
+                result != ArgsParseResult::Continue) {
+                return result;
+            }
+            continue;
+        }
+
+        // Handle (potentially multiple) short options.
+        if (accepting_options && arg.starts_with('-') && arg.length() >= 2) {
+            StringView arg_view = arg.substr(1);
+            while (!arg_view.empty()) {
+                if (auto result = handle_short_option(option_waiting_for_argument, args[0], arg_view[0]);
+                    result != ArgsParseResult::Continue) {
+                    return result;
+                }
+
+                arg_view = arg_view.substr(1);
+
+                // Check if the last option was expecting an argument.
+                if (option_waiting_for_argument != nullptr) {
+                    // Use remainder of string if there is anything, e.g. -Afoo.
+                    if (!arg_view.empty()) {
+                        if (auto result = option_waiting_for_argument->accept_value(args[0], arg_view);
+                            result != ArgsParseResult::Continue) {
+                            return result;
+                        }
+                        option_waiting_for_argument = nullptr;
+                    }
+                    break;
+                }
+            }
+            continue;
+        }
+
+        // Otherwise we have a positional argument.
+        if (argument_index >= m_arguments.size()) {
+            vull::println("{}: extraneous argument '{}'", args[0], arg);
+            return ArgsParseResult::ExitFailure;
+        }
+
+        const auto &argument = m_arguments[argument_index];
+        if (auto result = argument.accept_value(args[0], arg); result != ArgsParseResult::Continue) {
+            return result;
+        }
+
+        // Check if we should increment the argument index.
+        if (++argument_value_count >= argument.max_values) {
+            argument_index++;
+            argument_value_count = 0;
+            continue;
+        }
+    }
+
+    if (option_waiting_for_argument != nullptr) {
+        vull::println("{}: option '--{}' requires an argument", args[0], option_waiting_for_argument->long_name);
+        return ArgsParseResult::ExitFailure;
+    }
+
+    if (argument_index < m_arguments.size() && argument_value_count < m_arguments[argument_index].min_values) {
+        vull::println("{}: missing value for argument {}", args[0], m_arguments[argument_index].to_string());
+        return ArgsParseResult::ExitFailure;
+    }
+
+    return ArgsParseResult::Continue;
+}
+
+} // namespace vull
diff --git a/engine/sources/support/string.cc b/engine/sources/support/string.cc
index c6013d99..1ef0c026 100644
--- a/engine/sources/support/string.cc
+++ b/engine/sources/support/string.cc
@@ -25,6 +25,12 @@ String String::move_raw(char *data, size_t length) {
     return string;
 }
 
+String String::repeated(char ch, size_t length) {
+    String string(length);
+    memset(string.m_data, ch, length);
+    return string;
+}
+
 String::String(size_t length) : m_length(length) {
     m_data = new char[length + 1];
     m_data[length] = '\0';
@@ -41,17 +47,24 @@ String &String::operator=(String &&other) {
     return *this;
 }
 
-bool String::ends_with(StringView end) {
-    if (end.empty()) {
-        return true;
-    }
-    if (empty()) {
-        return false;
-    }
-    if (end.length() > m_length) {
-        return false;
-    }
-    return memcmp(&m_data[m_length - end.length()], end.data(), end.length()) == 0;
+int String::compare(StringView other) const {
+    return view().compare(other);
+}
+
+bool String::starts_with(char ch) const {
+    return view().starts_with(ch);
+}
+
+bool String::ends_with(char ch) const {
+    return view().ends_with(ch);
+}
+
+bool String::starts_with(StringView other) const {
+    return view().starts_with(other);
+}
+
+bool String::ends_with(StringView other) const {
+    return view().ends_with(other);
 }
 
 bool String::operator==(const String &other) const {
diff --git a/engine/sources/support/string_builder.cc b/engine/sources/support/string_builder.cc
index d339ffdf..fc2bb3bd 100644
--- a/engine/sources/support/string_builder.cc
+++ b/engine/sources/support/string_builder.cc
@@ -20,6 +20,11 @@ void StringBuilder::append_single(double arg, const char *) {
 }
 
 void StringBuilder::append_single(size_t arg, const char *opts) {
+    if (opts[0] == 'c') {
+        m_buffer.push(static_cast<char>(arg));
+        return;
+    }
+
     const size_t base = opts[0] == 'h' ? 16 : 10;
     Array<char, 30> buf{};
     uint8_t len = 0;
diff --git a/tools/vsi.cc b/tools/vsi.cc
index 3d4853c9..fc4a7b5c 100644
--- a/tools/vsi.cc
+++ b/tools/vsi.cc
@@ -11,6 +11,7 @@
 #include <vull/script/value.hh>
 #include <vull/script/vm.hh>
 #include <vull/support/algorithm.hh>
+#include <vull/support/args_parser.hh>
 #include <vull/support/result.hh>
 #include <vull/support/span.hh>
 #include <vull/support/string.hh>
@@ -37,26 +38,14 @@ static void print_message(script::Lexer &lexer, const script::ParseMessage &mess
 }
 
 int main(int argc, char **argv) {
-    Vector<StringView> args(argv, argv + argc);
-    if (args.size() < 2) {
-        vull::println("usage: {} [--dump-bc] <script>", args[0]);
-        return EXIT_SUCCESS;
-    }
-
-    StringView script_path;
     bool dump_bytecode = false;
-    for (const auto &arg : vull::slice(args, 1u)) {
-        if (arg == "--dump-bc") {
-            dump_bytecode = true;
-        } else if (arg[0] == '-') {
-            vull::println("fatal: unknown option {}", arg);
-            return EXIT_FAILURE;
-        } else if (script_path.empty()) {
-            script_path = arg;
-        } else {
-            vull::println("fatal: unexpected argument {}", arg);
-            return EXIT_FAILURE;
-        }
+    String script_path;
+
+    ArgsParser args_parser("vsi", "Vull Script Interpreter", "0.1.0");
+    args_parser.add_flag(dump_bytecode, "Dump generated bytecode", "dump-bc");
+    args_parser.add_argument(script_path, "script", true);
+    if (auto result = args_parser.parse_args(argc, argv); result != ArgsParseResult::Continue) {
+        return result == ArgsParseResult::ExitSuccess ? EXIT_SUCCESS : EXIT_FAILURE;
     }
 
     Timer timer;