vm.h

Go to the documentation of this file.

// === vm.h ============================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_LANG_VM_H
#define SEN_CORE_LANG_VM_H
 
// sen
#include "sen/core/base/numbers.h"
#include "sen/core/base/result.h"
#include "sen/core/base/span.h"
#include "sen/core/base/static_vector.h"
#include "sen/core/lang/stl_statement.h"
 
// std
#include <cstdint>
#include <functional>
#include <stack>
#include <string>
#include <variant>
#include <vector>
 
namespace sen::lang
{

 
constexpr std::size_t stackMax = 256U;

enum OpCode : uint8_t
{
  opReturn = 0,               
  opConstant = 1,             
  opNegate = 2,               
  opAdd = 3,                  
  opSub = 4,                  
  opMul = 5,                  
  opDiv = 6,                  
  opEqual = 7,                
  opNotEqual = 8,             
  opGreaterThan = 9,          
  opGreaterOrEqualThan = 10,  
  opLowerThan = 11,           
  opLowerOrEqualThan = 12,    
  opAnd = 13,                 
  opOr = 14,                  
  opJumpIfTrue = 15,          
  opJumpIfFalse = 16,         
  opFetchVariable = 17,       
  opBetween = 18              
};

struct VariantAccessError
{
};

using Value = std::variant<float32_t,
                           float64_t,
                           int32_t,
                           uint32_t,
                           int64_t,
                           uint64_t,
                           bool,
                           std::string,
                           uint8_t,
                           int16_t,
                           uint16_t,
                           VariantAccessError>;

using ValueGetter = std::function<Value()>;

using Environment = Span<ValueGetter>;

template <typename T>
[[nodiscard]] inline T extract(const Value& value)
{
  return std::get<T>(value);
}

template <typename T>
[[nodiscard]] inline bool holds(const Value& value) noexcept
{
  return std::holds_alternative<T>(value);
}

class Chunk
{
  SEN_MOVE_ONLY(Chunk)
 
public:  // special members
  Chunk() = default;
  ~Chunk() = default;
 
public:
  void disassemble(const std::string& name) const;

  [[nodiscard]] uint8_t addConstant(const Value& value);

  [[nodiscard]] const Value& getConstant(uint8_t offset) const;

  void addCode(uint8_t byte);

  [[nodiscard]] Span<const std::string> getVariables() const;

  [[nodiscard]] uint8_t getOrRegisterVariable(const std::string& name);

  [[nodiscard]] bool isValid() const noexcept;

  [[nodiscard]] const uint8_t* code() const noexcept;

  [[nodiscard]] int count() const noexcept;

  void patch(std::size_t offset, uint8_t byte);

  [[nodiscard]] std::size_t disassembleInstruction(std::size_t offset) const;

  static void printValue(const Value& value);
 
private:
  [[nodiscard]] std::size_t printSimpleInstruction(std::string_view name, std::size_t offset) const;
  [[nodiscard]] std::size_t printConstantInstruction(std::string_view name, std::size_t offset) const;
  [[nodiscard]] std::size_t printJumpInstruction(std::string_view name, std::size_t offset) const;
  [[nodiscard]] std::size_t printVariableInstruction(std::size_t offset) const;
 
private:
  std::vector<uint8_t> code_;
  StaticVector<Value, stackMax> constants_;
  StaticVector<std::string, stackMax> variablesDef_;
};

class VM
{
  SEN_MOVE_ONLY(VM)
 
public:
  VM() = default;
  ~VM() = default;
 
public:
  struct CompileError
  {
    std::string what;
  };

  struct RuntimeError
  {
    std::string what;
  };
 
public:
  [[nodiscard]] Result<Value, RuntimeError> interpret(const Chunk& chunk, Environment environment = {});

  [[nodiscard]] QueryStatement parse(const std::string& query) const;

  [[nodiscard]] Result<Chunk, CompileError> compile(const QueryStatement& statement) const;
 
private:
  [[nodiscard]] SEN_ALWAYS_INLINE uint8_t readByte();
  [[nodiscard]] SEN_ALWAYS_INLINE uint16_t readShort();
  [[nodiscard]] SEN_ALWAYS_INLINE Value readConstant();
  [[nodiscard]] inline Value pop();
  inline void push(Value value);
  inline void negate();
  inline void add();
  inline void subtract();
  inline void multiply();
  inline void divide();
  inline void equal();
  inline void notEqual();
  inline void lowerThan();
  inline void lowerOrEqualThan();
  inline void greaterThan();
  inline void greaterOrEqualThan();
  inline void doAnd();
  inline void doOr();
  inline void jumpIfFalse(uint16_t offset);
  inline void jumpIfTrue(uint16_t offset);
  inline void fetchVariable(uint8_t index);
  inline void between();
 
private:
  template <typename C>
  inline void mathOperation(const Value& a, const Value& b, C op);
 
  template <typename C>
  inline void comparisonOperation(const Value& a, const Value& b, C op);
 
private:
  using Stack = std::stack<Value, StaticVector<Value, stackMax>>;
 
private:
  const Chunk* currentChunk_ = nullptr;
  Environment environment_;
  const uint8_t* ip_ = nullptr;
  Stack stack_;
};

 
}  // namespace sen::lang
 
#endif  // SEN_CORE_LANG_VM_H