VM.hpp

Go to the documentation of this file.

/**
 * @file VM.hpp
 * @author Lexy Plateau (lexplt.dev@gmail.com)
 * @brief The ArkScript virtual machine
 * @date 2020-10-27
 *
 * @copyright Copyright (c) 2020-2026
 *
 */
 
#ifndef ARK_VM_VM_HPP
#define ARK_VM_VM_HPP
 
#include <array>
#include <vector>
#include <string>
#include <ranges>
#include <cinttypes>
 
#include <Ark/VM/Value/Value.hpp>
#include <Ark/State.hpp>
#include <Ark/VM/ScopeView.hpp>
#include <Ark/VM/ErrorKind.hpp>
#include <Ark/VM/ExecutionContext.hpp>
#include <Ark/Builtins/Builtins.hpp>
#include <Ark/Utils/Platform.hpp>
#include <Ark/VM/SharedLibrary.hpp>
#include <Ark/VM/Value/Future.hpp>
#include <Ark/VM/Debugger.hpp>
 
namespace Ark
{
    using namespace std::string_literals;
 
    /**
     * @brief The ArkScript virtual machine, executing ArkScript bytecode
     *
     */
    class ARK_API VM final
    {
    public:
        /**
         * @brief Construct a new vm t object
         *
         * @param state a reference to an ArkScript state, which can be reused for multiple VMs
         */
        explicit VM(State& state) noexcept;
 
        /**
         * @brief Run the bytecode held in the state
         *
         * @param fail_with_exception throw if true, display a stacktrace if false
         * @return int the exit code (default to 0 if no error)
         */
        int run(bool fail_with_exception = false);
 
        /**
         * @brief Retrieve a value from the virtual machine, given its symbol name
         *
         * @param name the name of the variable to retrieve
         * @return Value&
         */
        Value& operator[](const std::string& name) noexcept;
 
        /**
         * @brief Call a function from ArkScript, by giving it arguments
         *
         * @tparam Args
         * @param name the function name in the ArkScript code
         * @param args C++ argument list, converted to internal representation
         * @return Value
         */
        template <typename... Args>
        Value call(const std::string& name, Args&&... args);
 
        // ================================================
        //         function calling from plugins
        // ================================================
 
        /**
         * @brief Resolves a function call (called by plugins and builtins)
         *
         * @param context the execution context to use
         * @param n the function and its arguments
         * @return Value
         */
        inline Value resolve(internal::ExecutionContext* context, const std::vector<Value>& n);
 
        /**
         * @brief Ask the VM to exit with a given exit code
         *
         * @param code an exit code
         */
        void exit(int code) noexcept;
 
        /**
         * @brief Return a pointer to the first execution context, for the main thread of the app
         * @return internal::ExecutionContext*
         */
        [[nodiscard]] internal::ExecutionContext* getDefaultContext() const
        {
            return m_execution_contexts.front().get();
        }
 
        /**
         * @brief Create an execution context and returns it
         * @details This method is thread-safe VM wise.
         *
         * @return internal::ExecutionContext*
         */
        internal::ExecutionContext* createAndGetContext();
 
        /**
         * @brief Free a given execution context
         * @details This method is thread-safe VM wise.
         *
         * @param ec
         */
        void deleteContext(internal::ExecutionContext* ec);
 
        /**
         * @brief Create a Future object from a function and its arguments and return a managed pointer to it
         * @details This method is thread-safe VM wise.
         *
         * @param args
         * @return internal::Future*
         */
        internal::Future* createFuture(std::vector<Value>& args);
 
        /**
         * @brief Free a given future
         * @details This method is thread-safe VM wise.
         *
         * @param f
         */
        void deleteFuture(internal::Future* f);
 
        /**
         * @brief Used by the REPL to force reload all the plugins and their bound methods
         *
         * @return true on success
         * @return false if one or more plugins couldn't be reloaded
         */
        [[nodiscard]] bool forceReloadPlugins() const;
 
        /**
         * @brief Configure the debugger to use a prompt file instead of asking the user for an input
         *
         * @param path path to prompt file (one prompt per line)
         * @param os output stream
         */
        void usePromptFileForDebugger(const std::string& path, std::ostream& os = std::cout);
 
        /**
         * @brief Throw a VM error message
         *
         * @param kind type of VM error
         * @param message
         */
        [[noreturn]] static void throwVMError(internal::ErrorKind kind, const std::string& message);
 
        [[nodiscard]] const bytecode_t& bytecode() const
        {
            return m_state.m_bytecode;
        }
 
        friend class Value;
        friend class Repl;
        friend class internal::Closure;
        friend class internal::Debugger;
 
    private:
        State& m_state;
        std::vector<std::unique_ptr<internal::ExecutionContext>> m_execution_contexts;
        int m_exit_code;  ///< VM exit code, defaults to 0. Can be changed through `sys:exit`
        bool m_running;
        std::mutex m_mutex, m_mutex_futures;
        std::vector<std::shared_ptr<internal::SharedLibrary>> m_shared_lib_objects;
        std::vector<std::unique_ptr<internal::Future>> m_futures;  ///< Storing the promises while we are resolving them
        std::unique_ptr<internal::Debugger> m_debugger { nullptr };
 
        // a little trick for operator[] and for pop
        Value m_no_value = internal::Builtins::nil;
        Value m_undefined_value;
 
        /**
         * @brief Run ArkScript bytecode inside a try catch to retrieve all the exceptions and display a stack trace if needed
         *
         * @param context
         * @param untilFrameCount the frame count we need to reach before stopping the VM
         * @param fail_with_exception throw if true, display a stacktrace if false
         * @return int the exit code
         */
        int safeRun(internal::ExecutionContext& context, std::size_t untilFrameCount = 0, bool fail_with_exception = false);
 
        template <bool WithDebugger>
        void unsafeRun(internal::ExecutionContext& context, std::size_t untilFrameCount = 0);
 
        [[noreturn]] static ARK_ALWAYS_INLINE void stackOverflowError(const internal::ExecutionContext& context)
        {
            if (context.pp != 0)
                throw Error("Stack overflow. You could consider rewriting your function to make use of tail-call optimization.");
            else
                throw Error("Stack overflow. Are you trying to call a function with too many arguments?");
        }
 
        /**
         * @brief Initialize the VM according to the parameters
         *
         */
        void init() noexcept;
 
        // ================================================
        //               instruction helpers
        // ================================================
 
        /**
         * @brief Load a symbol by its id in the current context. Performs a lookup in the scope stack, in reverse order.
         *
         * @param id symbol id
         * @param context
         * @return Value* nullptr if the symbol could not be loaded
         */
        [[nodiscard]] inline ARK_ALWAYS_INLINE Value* loadSymbol(uint16_t id, internal::ExecutionContext& context);
 
        /**
         * @brief Load a symbol by its (reversed) index in the current scope
         *
         * @param index index of the symbol to load, starting from the end
         * @param context
         * @return Value*
         */
        [[nodiscard]] inline ARK_ALWAYS_INLINE Value* loadSymbolFromIndex(uint16_t index, internal::ExecutionContext& context);
 
        /**
         * @brief Load a constant from the constant table by its id
         *
         * @param id
         * @return Value*
         */
        [[nodiscard]] inline ARK_ALWAYS_INLINE Value* loadConstAsPtr(uint16_t id) const;
 
        /**
         * @brief Find the nearest variable of a given id
         *
         * @param id the id to find
         * @param context
         * @return Value*
         */
        inline ARK_ALWAYS_INLINE Value* findNearestVariable(uint16_t id, internal::ExecutionContext& context) noexcept;
 
        /**
         * @brief Create a new symbol with an associated value in the current scope
         *
         * @param id
         * @param val
         * @param context
         */
        inline ARK_ALWAYS_INLINE void store(uint16_t id, const Value* val, internal::ExecutionContext& context);
 
        /**
         * @brief Change the value of a symbol given its identifier
         *
         * @param id
         * @param val
         * @param context
         */
        inline ARK_ALWAYS_INLINE void setVal(uint16_t id, const Value* val, internal::ExecutionContext& context);
 
        inline ARK_ALWAYS_INLINE void jump(uint16_t address, internal::ExecutionContext& context);
 
        [[nodiscard]] Value getField(Value* closure, uint16_t id, const internal::ExecutionContext& context, bool push_with_env = false);
 
        [[nodiscard]] Value createList(std::size_t count, internal::ExecutionContext& context);
 
        void listAppendInPlace(Value* list, std::size_t count, internal::ExecutionContext& context);
 
        // ================================================
        //                 stack related
        // ================================================
 
        /**
         * @brief Pop a value from the stack
         *
         * @param context
         * @return Value*
         */
        inline ARK_ALWAYS_INLINE Value* pop(internal::ExecutionContext& context);
 
        /**
         * @brief Return a pointer to the top of the stack without consuming it
         *
         * @param context
         * @param offset
         * @return Value*
         */
        inline ARK_ALWAYS_INLINE Value* peek(internal::ExecutionContext& context, std::size_t offset = 0);
 
        /**
         * @brief Return a pointer to the top of the stack without consuming it, and resolve it if possible
         *
         * @param context
         * @param offset
         * @return Value*
         */
        inline ARK_ALWAYS_INLINE Value* peekAndResolveAsPtr(internal::ExecutionContext& context, std::size_t offset = 0);
 
        /**
         * @brief Push a value on the stack
         *
         * @param value
         * @param context
         */
        inline ARK_ALWAYS_INLINE void push(const Value& value, internal::ExecutionContext& context) noexcept;
 
        /**
         * @brief Push a value on the stack
         *
         * @param value
         * @param context
         */
        inline ARK_ALWAYS_INLINE void push(Value&& value, internal::ExecutionContext& context) noexcept;
 
        /**
         * @brief Push a value on the stack as a reference
         *
         * @param valptr
         * @param context
         */
        inline ARK_ALWAYS_INLINE void push(Value* valptr, internal::ExecutionContext& context) noexcept;
 
        /**
         * @brief Pop a value from the stack and resolve it if possible, then return it
         *
         * @param context
         * @return Value*
         */
        inline ARK_ALWAYS_INLINE Value* popAndResolveAsPtr(internal::ExecutionContext& context);
 
        // ================================================
        //                 function calls
        // ================================================
 
        /**
         * @brief Destroy the current frame and get back to the previous one, resuming execution
         *
         * Doing the job nobody wants to do: cleaning after everyone has finished to play.
         * This is a sort of primitive garbage collector
         *
         * @param context
         */
        inline ARK_ALWAYS_INLINE void returnFromFuncCall(internal::ExecutionContext& context);
 
        /**
         * @brief Function called when the CALL instruction is met in the bytecode
         *
         * @param context
         * @param argc number of arguments already sent
         * @param function_ptr optional pointer to the function to call. If not provided, obtain it from the stack (unless or_address is not 0)
         * @param or_address optional page address, used if non-zero and function_ptr is nullptr
         */
        inline void call(internal::ExecutionContext& context, uint16_t argc, Value* function_ptr = nullptr, internal::PageAddr_t or_address = 0);
 
        /**
         * @brief Builtin called when the CALL_BUILTIN instruction is met in the bytecode
         *
         * @param context
         * @param builtin the builtin to call
         * @param argc number of arguments already sent
         * @param remove_return_address remove the return address pushed by the compiler
         * @param remove_builtin remove the builtin that was pushed to the stack for the call
         */
        inline void callBuiltin(internal::ExecutionContext& context, const Value& builtin, uint16_t argc, bool remove_return_address = true, bool remove_builtin = true);
 
        /**
         * @brief Load a plugin from a constant id
         *
         * @param id Id of the constant
         * @param context
         */
        void loadPlugin(uint16_t id, internal::ExecutionContext& context);
 
        // ================================================
        //                  error handling
        // ================================================
 
        /**
         * @brief Find the nearest variable id with a given value
         *
         * Only used to display the call stack traceback
         *
         * @param value the value to search for
         * @param context
         * @return uint16_t
         */
        uint16_t findNearestVariableIdWithValue(const Value& value, internal::ExecutionContext& context) const noexcept;
 
        [[noreturn]] void throwArityError(std::size_t passed_arg_count, std::size_t expected_arg_count, internal::ExecutionContext& context, bool skip_function = true);
 
        void initDebugger(internal::ExecutionContext& context);
 
        void showBacktraceWithException(const std::exception& e, internal::ExecutionContext& context);
 
        /**
         * @brief Find the nearest source location information given instruction and page pointers
         *
         * @param ip
         * @param pp
         * @return std::optional<InstLoc>
         */
        [[nodiscard]] std::optional<internal::InstLoc> findSourceLocation(std::size_t ip, std::size_t pp) const;
 
        [[nodiscard]] std::string debugShowSource() const;
 
        /**
         * @brief Display a backtrace when the VM encounter an exception
         *
         * @param context
         * @param os
         * @param colorize
         */
        void backtrace(internal::ExecutionContext& context, std::ostream& os = std::cerr, bool colorize = true);
    };
}
 
#include "VM.inl"
 
#endif