path: root/ue4/mycpu/ccpu.h

/**
 * @module ccpu
 * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
 * @brief  CPU implementation. Used as a container for memory and instructions.
 *         Implements a run method to execute the program (= the instructions).
 * @date   26.05.2009
 */

#ifndef CCPU_H
#define CCPU_H 1

#include <iostream>
#include <set>
#include <stdexcept>
#ifdef DEBUG
# include <iostream>
# include <iomanip>
#endif
#include "cdat.h"
#include "cmem.h"
#include "displays.h"
#include "cprogram.h"

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

/**
 * @class CCPU
 *
 * CPU implementation. Used as a container for memory and instructions.
 * Implements a run method to execute the program (= the instructions).
 */
template <class T>
class CCPU
{
  typedef typename std::set<CDisplay<T> *>::iterator displayiterator;

  public:
    /**
     * @method CCPU
     * @brief  Default ctor
     * @param  cnt  number of registers to allocate for this cpu
     * @return -
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    CCPU(const unsigned cnt);

    /**
     * @method ~CCPU
     * @brief  Default dtor
     * @param  -
     * @return -
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    ~CCPU();

    /**
     * @method getRegisterCount
     * @brief  get number of registers
     * @param  -
     * @return number of registers
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    const unsigned getRegisterCount() const
    {
      return m_regcnt;
    }

    /**
     * @method getRegisters
     * @brief  get pointer to registers array
     * @param  -
     * @return pointer to registers array
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    T *getRegisters() const
    {
      return m_registers;
    }

    /**
     * @method setMemory
     * @brief  set memory of cpu
     * @param  memory  pointer to memory
     * @return -
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    void setMemory(CMem<T> *memory)
    {
      m_memory = memory;
    }

    /**
     * @method getMemory
     * @brief  get pointer to memory
     * @param  -
     * @return pointer to memory
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    CMem<T> *getMemory() const
    {
      return m_memory;
    }

    /**
     * @method setProgram
     * @brief  set program to execute
     * @param  program  pointer to program
     * @return -
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    void setProgram(const CProgram<T> *program)
    {
      m_program = program;
    }

    /**
     * @method getProgram
     * @brief  get pointer to program
     * @param  -
     * @return pointer to program
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    const CProgram<T> *getProgram()
    {
      return m_program;
    }

    /**
     * @method getDisplays
     * @brief  get set of pointers to displays
     * @param  -
     * @return reference to set of pointers to displays
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    const std::set<CDisplay<T> *>& getDisplays()
    {
      return m_displays;
    }

    /**
     * @method setFlagZero
     * @brief  set zero flag
     * @param  value  new value of zero flag
     * @return -
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    void setFlagZero(const bool value)
    {
      m_flagzero = value;
    }

    /**
     * @method getFlagZero
     * @brief  get value of zero flag
     * @param  -
     * @return value of zero flag
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    const bool getFlagZero()
    {
      return m_flagzero;
    }

    /**
     * @method setFlagSign
     * @brief  set sign flag
     * @param  value  new value of sign flag
     * @return -
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    void setFlagSign(const bool value)
    {
      m_flagsign = value;
    }

    /**
     * @method getFlagSign
     * @brief  get value of sign flag
     * @param  -
     * @return value of sign flag
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    const bool getFlagSign()
    {
      return m_flagsign;
    }

    /**
     * @method run
     * @brief  execute current program
     * @param  -
     * @return -
     * @globalvars none
     * @exception  std::runtime_error
     * @conditions none
     */
    void run();

#if DEBUG
    /**
     * @method dumpRegisters
     * @brief  dump content of registers to outputstream
     * @param  out  outputstream to write to
     * @return void
     * @globalvars none
     * @exception  none
     * @conditions none
     */
    void dumpRegisters(std::ostream& out);
#endif

  private:
    /* members */
    T *m_registers;
    unsigned m_regcnt;
    CMem<T> *m_memory;
    const CProgram<T> *m_program;
    std::set<CDisplay<T> *> m_displays;
    bool m_flagzero;
    bool m_flagsign;
};

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

template <class T>
CCPU<T>::CCPU(const unsigned cnt)
  : m_regcnt(cnt), m_memory(NULL), m_program(NULL), m_flagzero(false), m_flagsign(false)
{
  /* create registers */
  m_registers = new T[cnt];
  for(unsigned i = 0; i < cnt; ++i)
    m_registers[i] = 0;

  /* create displays */
  m_displays.insert(new CDisplayWDEZ<T>);
  m_displays.insert(new CDisplayWHEX<T>);
}

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

template <class T>
CCPU<T>::~CCPU()
{
  /* delete registers */
  delete[] m_registers;
  m_registers = NULL;

  /* delete displays */
  for (displayiterator it = m_displays.begin() ; it != m_displays.end(); ++it)
    delete *it;
}

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

template <class T>
void CCPU<T>::run()
{
  if (m_memory == NULL)
    throw std::runtime_error("CPU has no memory");
  if (m_program == NULL)
    throw std::runtime_error("CPU has no program to execute");
  if (m_regcnt == 0)
    throw std::runtime_error("CPU has no registers");

  bool run = true;
  while(run)
  {
    unsigned pc = static_cast<unsigned>(m_registers[0]);

    /* end of the program reached */
    if (pc == m_program->size())
      break;

    /* pc is out of bound */
    if (pc > m_program->size())
      throw std::runtime_error("Programcounter is out of bound");

    /* execute instruction */
    (*m_program->at(pc))(this);
    ++m_registers[0];
  }
}

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

#if DEBUG
template <class T>
void CCPU<T>::dumpRegisters(std::ostream& out)
{
  out << "[REGISTER DUMP]" << std::endl;
  for(unsigned i = 0; i < getRegisterCount(); ++i)
  {
    out << "[" << std::setw(4) << std::setfill('0') << i << "]  "
        << m_registers[i] << std::endl;
  }
}
#endif

#endif

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