VM.hpp

Go to the documentation of this file.

#pragma once
#include "../../Codegen/CodeGen.hpp"
#include <Value.hpp>
#include <vector>
#include <filesystem>
#include <functional>
#include <map>
#include <array>
#include <ranges>
#include "core/core.h"
#include <iostream>
#include <stdexcept>
#include <platform.h>
#ifndef SANDBOXED
    #include "../FFI/ffi.hpp"
#endif
 
#ifdef TRACING
#include <format>
#include "../../ISA/map.hpp"
#endif

namespace Phasor
{

class VM
{
  public:
    explicit VM()
    {
#ifdef TRACING
        log(std::format("VM::{}(): normal instance created {:#x}\n", __func__, (uintptr_t)this));
        flush();
#endif
    }
    explicit VM(const Bytecode &bytecode)
    {
#ifdef TRACING
        log(std::format("VM::{}(): fast instance created {:#x}\n", __func__, (uintptr_t)this));
        flush();
#endif
        run(bytecode);
    }
    explicit VM(const OpCode &op, const int &operand1 = 0, const int &operand2 = 0, const int &operand3 = 0,
                const int &operand4 = 0, const int &operand5 = 0)
    {
#ifdef TRACING
        log(std::format("VM::{}(): operation instance created {:#x}\n", __func__, (uintptr_t)this));
        flush();
#endif
        operation(op, operand1, operand2, operand3, operand4, operand5);
 
    }
    ~VM()
    {
        cleanup();
#ifdef TRACING
        log(std::format("VM::{}(): deconstructed {:#x}\n", __func__, (uintptr_t)this));
        flush();
#endif
    }
 
    inline void initFFI(const std::filesystem::path &path) {
#ifndef SANDBOXED
        ffi = std::make_unique<FFI>(path, this);
#endif
    }

    class Halt : public std::exception
    {
      public:
        const char *what() const noexcept override
        {
            return "";
        }
    };

    int run(const Bytecode &bytecode);

    using NativeFunction = std::function<Value(const std::vector<Value> &args, VM *vm)>;

    void registerNativeFunction(const std::string &name, NativeFunction fn);
 
    using ImportHandler = std::function<void(const std::filesystem::path &path)>;
    void setImportHandler(const ImportHandler &handler);

    void freeVariable(size_t index);

    size_t addVariable(const Value &value);

    void setVariable(size_t index, const Value &value);

    Value getVariable(size_t index);

    size_t getVariableCount();

    void setRegister(uint8_t index, const Value &value);

    void freeRegister(uint8_t index);

    Value getRegister(uint8_t index);

    size_t getRegisterCount();

    enum Register : uint8_t
    {
        r0,
        r1,
        r2,
        r3,
        r4,
        r5,
        r6,
        r7,
        r8,
        r9,
        r10,
        r11,
        r12,
        r13,
        r14,
        r15,
        r16,
        r17,
        r18,
        r19,
        r20,
        r21,
        r22,
        r23,
        r24,
        r25,
        r26,
        r27,
        r28,
        r29,
        r30,
        r31
    };
 
    #define REGISTER1 VM::Register::r0
    #define REGISTER2 VM::Register::r1
    #define REGISTER3 VM::Register::r2
 
#ifdef _WIN32
    inline Value __fastcall operation(const OpCode &op, const int &operand1 = 0, const int &operand2 = 0,
                               const int &operand3 = 0, const int &operand4 = 0, const int &operand5 = 0);
#else
    inline Value operation(const OpCode &op, const int &operand1 = 0, const int &operand2 = 0, const int &operand3 = 0,
                    const int &operand4 = 0, const int &operand5 = 0);
#endif
    void push(const Value &value);

    Value pop();

    Value peek();

    void cleanup();

    void reset(const bool &resetStack = true, const bool &resetFunctions = true, const bool &resetVariables = true);

    std::string getInformation();

    std::string getBytecodeInformation();

    void log(const Value &msg);

    void logerr(const Value &msg);

    void flush();

    void flusherr();
    
    inline void setStatus(int newStatus) { status = newStatus; }

    template <typename... Args> inline Value regRun(OpCode opcode, Args &&...args)
    {
        int regIndex = 0;
        (setRegister(regIndex++, std::forward<Args>(args)), ...);
        return operation(opcode);
    }

    template <typename... Args> inline Value stackRun(OpCode opcode, Args&&... args) {
        Value arr[] = {Value(std::forward<Args>(args))...};
        for (Value& v : arr | std::views::reverse)
            push(v);
        operation(opcode);
        return pop();
    }
 
  private:
#ifndef SANDBOXED
    std::unique_ptr<FFI> ffi;
#endif
    int status = 0;
    
    ImportHandler importHandler;

    std::array<Value, MAX_REGISTERS> registers;

    std::vector<Value> stack;

    std::vector<int> callStack;

    std::vector<Value> variables;

    const Bytecode *m_bytecode{};

    size_t pc = 0;

    std::map<std::string, NativeFunction> nativeFunctions;
};
} // namespace Phasor
 
#define OPS_ARE_INCLUDED
#include "Operations.cc.inl"