Repl.cpp

Go to the documentation of this file.

#include <fstream>
#include <filesystem>
#include <fmt/core.h>
#include <fmt/color.h>
#include <ranges>
 
#include <Ark/Builtins/Builtins.hpp>
#include <Ark/VM/DefaultValues.hpp>
#include <Ark/TypeChecker.hpp>
#include <Ark/Utils/Files.hpp>
#include <Ark/Utils/Utils.hpp>
 
#include <CLI/REPL/Repl.hpp>
#include <CLI/REPL/Utils.hpp>
 
namespace Ark
{
    using namespace internal;
    using namespace replxx;
 
    Repl::Repl(const std::vector<std::filesystem::path>& lib_env) :
        m_line_count(1), m_running(true),
        m_old_ip(0), m_lib_env(lib_env),
        m_state(m_lib_env), m_vm(m_state), m_has_init_vm(false),
        m_keywords(getAllKeywords()),
        m_words_colors(getColorPerKeyword())
    {}
 
    int Repl::run()
    {
        fmt::println("ArkScript REPL -- Version {} [LICENSE: Mozilla Public License 2.0] -- Built on {}", ARK_FULL_VERSION, ARK_BUILD_DATE);
        fmt::println(R"(Type "quit" to quit. Try "help" for more information)");
        cuiSetup();
        registerBuiltins();
 
        if (const char* arkrc = std::getenv("ARKSCRIPT_REPL_STARTUP"))
            m_code = fmt::format("## Loaded via ARKSCRIPT_REPL_STARTUP environment variable: ##\n{}\n## END ##\n", Utils::readFile(arkrc));
 
        while (m_running)
        {
            std::optional<std::string> maybe_block = getCodeBlock();
 
            // save a valid ip if execution failed
            m_old_ip = m_vm.m_execution_contexts[0]->ip;
            if (maybe_block.has_value() && !maybe_block.value().empty())
            {
                std::string new_code = m_code + maybe_block.value();
                if (m_state.doString(new_code, Ark::DefaultFeatures))
                {
                    // for only one vm init
                    if (!m_has_init_vm)
                    {
                        m_vm.init();
                        m_has_init_vm = true;
                    }
                    else
                        std::ignore = m_vm.forceReloadPlugins();
 
                    if (m_vm.safeRun(*m_vm.m_execution_contexts[0]) == 0)
                    {
                        // save good code
                        m_code = new_code + m_temp_additional_code;
                        m_temp_additional_code.clear();
                        // place ip to end of bytecode instruction (HALT)
                        m_vm.m_execution_contexts[0]->ip -= 4;
 
                        const Value* maybe_value = m_vm.peekAndResolveAsPtr(*m_vm.getDefaultContext());
                        if (maybe_value != nullptr && maybe_value->valueType() != ValueType::Undefined && maybe_value->valueType() != ValueType::InstPtr)
                            fmt::println("{}", fmt::styled(maybe_value->toString(m_vm), fmt::fg(fmt::color::chocolate)));
                    }
                    else
                    {
                        // reset ip if execution failed
                        m_vm.m_execution_contexts[0]->ip = m_old_ip;
                    }
 
                    m_state.reset();
                    registerBuiltins();
                }
            }
        }
 
        return 0;
    }
 
    void Repl::cuiSetup()
    {
        m_repl.set_completion_callback([this](const std::string& ctx, int& len) {
            return hookCompletion(m_keywords, ctx, len);
        });
        m_repl.set_highlighter_callback([this](const std::string& ctx, Replxx::colors_t& colors) {
            return hookColor(m_words_colors, ctx, colors);
        });
        m_repl.set_hint_callback([this](const std::string& ctx, int& len, Replxx::Color& color) {
            return hookHint(m_keywords, ctx, len, color);
        });
 
        m_repl.set_word_break_characters(" \t.,-%!;:=*~^'\"/?<>|[](){}");
        m_repl.set_completion_count_cutoff(128);
        m_repl.set_double_tab_completion(true);
        m_repl.set_complete_on_empty(true);
        m_repl.set_beep_on_ambiguous_completion(false);
        m_repl.set_no_color(false);
 
        m_repl.bind_key_internal(Replxx::KEY::HOME, "move_cursor_to_begining_of_line");
        m_repl.bind_key_internal(Replxx::KEY::END, "move_cursor_to_end_of_line");
        m_repl.bind_key_internal(Replxx::KEY::TAB, "complete_line");
        m_repl.bind_key_internal(Replxx::KEY::control(Replxx::KEY::LEFT), "move_cursor_one_word_left");
        m_repl.bind_key_internal(Replxx::KEY::control(Replxx::KEY::RIGHT), "move_cursor_one_word_right");
        m_repl.bind_key_internal(Replxx::KEY::control(Replxx::KEY::UP), "hint_previous");
        m_repl.bind_key_internal(Replxx::KEY::control(Replxx::KEY::DOWN), "hint_next");
        m_repl.bind_key_internal(Replxx::KEY::control('R'), "history_incremental_search");
        m_repl.bind_key_internal(Replxx::KEY::control('W'), "kill_to_begining_of_word");
        m_repl.bind_key_internal(Replxx::KEY::control('U'), "kill_to_begining_of_line");
        m_repl.bind_key_internal(Replxx::KEY::control('K'), "kill_to_end_of_line");
        m_repl.bind_key_internal(Replxx::KEY::control('L'), "clear_screen");
        m_repl.bind_key_internal(Replxx::KEY::control('D'), "send_eof");
        m_repl.bind_key_internal(Replxx::KEY::control('C'), "abort_line");
        m_repl.bind_key_internal(Replxx::KEY::control('T'), "transpose_characters");
    }
 
    void Repl::registerBuiltins()
    {
        m_state.loadFunction("repl:history", [this]([[maybe_unused]] const std::vector<Value>&, [[maybe_unused]] VM*) {
            return Value(m_code);
        });
 
        m_state.loadFunction("repl:save", [this](const std::vector<Value>& n, [[maybe_unused]] VM*) {
            if (!types::check(n, ValueType::String))
                throw types::TypeCheckingError(
                    "repl:save",
                    { { types::Contract { { types::Typedef("filename", ValueType::String) } } } },
                    n);
 
            std::ofstream history_file(n[0].string());
            history_file << m_code;
            return Nil;
        });
 
        m_state.loadFunction("repl:load", [this](const std::vector<Value>& n, [[maybe_unused]] VM*) {
            if (!types::check(n, ValueType::String))
                throw types::TypeCheckingError(
                    "repl:load",
                    { { types::Contract { { types::Typedef("filename", ValueType::String) } } } },
                    n);
 
            const std::string path = n[0].string();
            if (!Utils::fileExists(path))
                throw Error(fmt::format("`repl:load` expected a valid path to a file. {} doesn't exist, or can't be reached (try with an absolute path?)", path));
 
            // we use += so that it can be called multiple times without overwriting previous code
            m_temp_additional_code += fmt::format("## (repl:load \"{}\") ##\n{}\n## END ##\n", path, Utils::readFile(path));
            return Nil;
        });
    }
 
    std::optional<std::string> Repl::getLine(const bool continuation)
    {
        const std::string prompt = fmt::format("main:{:0>3}{} ", m_line_count, continuation ? ":" : ">");
 
        const char* buf { nullptr };
        do
        {
            buf = m_repl.input(prompt);
        } while ((buf == nullptr) && (errno == EAGAIN));
        std::string line = (buf != nullptr) ? std::string(buf) : "";
 
        // line history
        m_repl.history_add(line);
        Utils::trimWhitespace(line);
 
        // specific commands handling
        if (line == "quit" || buf == nullptr)
        {
            fmt::println("\nExiting REPL");
            m_running = false;
 
            return std::nullopt;
        }
        if (line == "help")
        {
            fmt::println("Available commands:");
            fmt::println("  help -- display this message");
            fmt::println("  quit -- quit the REPL");
            fmt::println("  save -- save the history to disk");
            fmt::println("  history -- print saved code");
            fmt::println("  reset -- reset the VM state");
            fmt::println("Available builtins:");
            fmt::println("  (repl:history): returns the REPL history as a string");
            fmt::println("  (repl:save filename): saves the REPL history to a file");
            fmt::println("  (repl:load filename): loads code from a file in the REPL");
 
            return std::nullopt;
        }
        if (line == "save")
        {
            std::ofstream history_file("arkscript_repl_history.ark");
            m_repl.history_save(history_file);
 
            fmt::println("Saved {} lines of history to arkscript_repl_history.ark", m_line_count);
            return std::nullopt;
        }
        if (line == "history")
        {
            fmt::println("\n{}", m_code);
            return std::nullopt;
        }
        if (line == "reset")
        {
            m_state.reset();
            m_has_init_vm = false;
            m_code.clear();
 
            return std::nullopt;
        }
 
        return line;
    }
 
    std::optional<std::string> Repl::getCodeBlock()
    {
        std::string code_block;
        long open_parentheses = 0;
        long open_braces = 0;
 
        while (m_running)
        {
            const bool unfinished_block = open_parentheses != 0 || open_braces != 0;
 
            auto maybe_line = getLine(unfinished_block);
            if (!maybe_line.has_value() && !unfinished_block)
                return std::nullopt;
 
            if (maybe_line.has_value() && !maybe_line.value().empty())
            {
                code_block += maybe_line.value() + "\n";
                open_parentheses += Utils::countOpenEnclosures(maybe_line.value(), '(', ')');
                open_braces += Utils::countOpenEnclosures(maybe_line.value(), '{', '}');
 
                // lines number incrementation
                ++m_line_count;
                if (open_parentheses == 0 && open_braces == 0)
                    break;
            }
        }
 
        return code_block;
    }
}