emu_context.h

#pragma once
 
#include "libmicroemu/register_id.h"
#include "libmicroemu/special_register_id.h"
#include "libmicroemu/types.h"
#include <cstddef>
#include <string_view>
 
namespace libmicroemu {
 
struct OpCode {
  u16 low;
  u16 high;
  bool is_32bit;
};
 
class IInstrToMnemonic {
public:
  virtual void Build(char *buf, std::size_t buf_len) const = 0;
};

class IRegAccessor {
public:
  virtual std::string_view GetRegisterName(const RegisterId &reg_id) const = 0;

  virtual u32 ReadRegister(const RegisterId &reg_id) const = 0;

  virtual void WriteRegister(const RegisterId &reg_id, u32 value) = 0;
};

class ISpecialRegAccessor {
public:
  virtual std::string_view GetRegisterName(const SpecialRegisterId &reg_id) const = 0;

  virtual u32 ReadRegister(const SpecialRegisterId &reg_id) const = 0;

  virtual void WriteRegister(const SpecialRegisterId &reg_id, u32 value) = 0;
};
 
class EmuContext {
public:
  EmuContext(const me_adr_t &pc, const OpCode &op_code, const IInstrToMnemonic &instr_decoder,
             IRegAccessor &reg_access, ISpecialRegAccessor &spec_reg_access) noexcept
 
      : pc_(pc), op_code_(op_code), instr_decoder_(instr_decoder), reg_access_(reg_access),
        spec_reg_access_(spec_reg_access) {}

  inline me_adr_t GetPc() const noexcept { return pc_; }

  inline IRegAccessor &GetRegisterAccessor() noexcept { return reg_access_; }

  inline ISpecialRegAccessor &GetSpecialRegisterAccessor() noexcept { return spec_reg_access_; }

  inline const OpCode &GetOpCode() const noexcept { return op_code_; }

  inline void BuildMnemonic(char *buf, std::size_t buf_len) const noexcept {
    instr_decoder_.Build(buf, buf_len);
  }
 
private:
  const me_adr_t &pc_;
  const OpCode &op_code_;
  const IInstrToMnemonic &instr_decoder_;
 
  IRegAccessor &reg_access_;
  ISpecialRegAccessor &spec_reg_access_;
};
 
} // namespace libmicroemu