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 "core/core.h"

namespace Phasor
{

class VM
{
  public:
    void 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(ImportHandler handler);

    void freeVariable(const size_t index);

    size_t addVariable(const Value &value);

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

    Value getVariable(const 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
    {
        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 // If you are here to try adding more, step back and think about what got you here in the first place
    };

    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);

    void push(const Value &value);

    Value pop();

    Value peek();

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

    std::string getInformation();

    void log(const Value &msg);
    void logerr(const Value &msg);
 
  private:
    ImportHandler importHandler;

    std::array<Value, 256> registers;

    std::vector<Value> stack;

    std::vector<int> callStack;

    std::vector<Value> variables;

    const Bytecode *bytecode;

    size_t pc = 0;

    std::map<std::string, NativeFunction> nativeFunctions;
};
} // namespace Phasor