mycpu/cinstruction.h

#ifndef CINSTRUCTION_H
#define CINSTRUCTION_H 1

#include <iostream>
#include <list>
#include <sstream>
#include <boost/lexical_cast.hpp>
#include <assert.h>
#include <stdexcept>

class CInstructionError
 : public std::invalid_argument
{
  public:
    CInstructionError(const std::string& what)
      : std::invalid_argument(what)
    {}
};

#include "ccpu.h"

/* forward declare CCPU */
template <class T>
class CCPU;

template <class T>
class CInstruction
{
  public:
    CInstruction(std::string name)
      : m_name(name)
    {}

    virtual ~CInstruction()
    {}

    virtual bool operator==(std::string& name)
    {
      return name == m_name;
    }

    virtual CInstruction& operator()(CCPU<T> *cpu)
    {
      execute(cpu);
      return *this;
    }

    virtual const std::string& getName()
    {
      return m_name;
    }

    virtual std::ostream& dump(std::ostream& stream)
    {
      stream << m_name;
      return stream;
    }

    friend std::ostream& operator<<(std::ostream& stream, CInstruction& instr)
    {
      return instr.dump(stream);
    }

    virtual const unsigned parseRegister(const std::string& str);

    virtual void checkRegister(CCPU<T> *cpu, const unsigned regidx);

    virtual CInstruction *factory() = 0;

    virtual void compile(std::list<std::string>& params) = 0;

    virtual void execute(CCPU<T> *cpu) = 0;

  protected:
    /* members */
    std::string m_name;
};

/*----------------------------------------------------------------------------*/

template<class T>
const unsigned CInstruction<T>::parseRegister(const std::string& str)
{
  unsigned reg;
  if (str.length() < 2 || str[0] != 'r')
    throw CInstructionError("Invalid syntax of register");

  try
  {
    reg = boost::lexical_cast<unsigned>(str.substr(1));
  }
  catch(boost::bad_lexical_cast& ex)
  {
    throw CInstructionError("Invalid syntax of register");
  }

  return reg;
}

/*----------------------------------------------------------------------------*/

template<class T>
inline void CInstruction<T>::checkRegister(CCPU<T> *cpu, const unsigned regidx)
{
  assert(cpu != NULL);
  if (regidx >= cpu->getRegisterCount())
  {
    std::stringstream sstr;
    sstr << "Register R" << regidx << " doesn't exist (out of bound)";
    throw CInstructionError(sstr.str());
  }
}

#endif

/* vim: set et sw=2 ts=2: */

---