/**
 * @module instructions
 * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
 * @brief  TODO
 * @date   10.05.2009
 */

#ifndef INSTRUCTIONS_H
#define INSTRUCTIONS_H 1

#include "cinstruction.h"
#include "ccpu.h"

/**
 * @class CInstructionInc
 *
 * TODO
 */
class CInstructionInc
 : public CInstruction
{
  public:
    CInstructionInc()
      : CInstruction("inc")
    {}

    CInstructionInc *factory()
    {
      return new CInstructionInc;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
};

/*============================================================================*/

/**
 * @class CInstructionDec
 *
 * TODO
 */
class CInstructionDec
 : public CInstruction
{
  public:
    CInstructionDec()
      : CInstruction("dec")
    {}

    CInstructionDec *factory()
    {
      return new CInstructionDec;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
};

/*============================================================================*/

/**
 * @class CInstructionAdd
 *
 * TODO
 */
class CInstructionAdd
 : public CInstruction
{
  public:
    CInstructionAdd()
      : CInstruction("add")
    {}

    CInstructionAdd *factory()
    {
      return new CInstructionAdd;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
    unsigned m_regidx2;
    unsigned m_regidx3;
};

/*============================================================================*/

/**
 * @class CInstructionSub
 *
 * TODO
 */
class CInstructionSub
 : public CInstruction
{
  public:
    CInstructionSub()
      : CInstruction("sub")
    {}

    CInstructionSub *factory()
    {
      return new CInstructionSub;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
    unsigned m_regidx2;
    unsigned m_regidx3;
};

/*============================================================================*/

/**
 * @class CInstructionMul
 *
 * TODO
 */
class CInstructionMul
 : public CInstruction
{
  public:
    CInstructionMul()
      : CInstruction("mul")
    {}

    CInstructionMul *factory()
    {
      return new CInstructionMul;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
    unsigned m_regidx2;
    unsigned m_regidx3;
};

/*============================================================================*/

/**
 * @class CInstructionDiv
 *
 * TODO
 */
class CInstructionDiv
 : public CInstruction
{
  public:
    CInstructionDiv()
      : CInstruction("div")
    {}

    CInstructionDiv *factory()
    {
      return new CInstructionDiv;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
    unsigned m_regidx2;
    unsigned m_regidx3;
};

/*============================================================================*/

/**
 * @class CInstructionLoad
 *
 * TODO
 */
class CInstructionLoad
 : public CInstruction
{
  public:
    CInstructionLoad()
      : CInstruction("load")
    {}

    CInstructionLoad *factory()
    {
      return new CInstructionLoad;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
    unsigned m_regidx2;
};

/*============================================================================*/

/**
 * @class CInstructionStore
 *
 * TODO
 */
class CInstructionStore
 : public CInstruction
{
  public:
    CInstructionStore()
      : CInstruction("store")
    {}

    CInstructionStore *factory()
    {
      return new CInstructionStore;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
    unsigned m_regidx2;
};

/*============================================================================*/

/**
 * @class CInstructionTest
 *
 * TODO
 */
class CInstructionTest
 : public CInstruction
{
  public:
    CInstructionTest()
      : CInstruction("test")
    {}

    CInstructionTest *factory()
    {
      return new CInstructionTest;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
};

/*============================================================================*/

/**
 * @class CInstructionLabel
 *
 * TODO
 */
class CInstructionLabel
 : public CInstruction
{
  public:
    CInstructionLabel()
      : CInstruction("label")
    {}

    CInstructionLabel *factory()
    {
      return new CInstructionLabel;
    }

    void compile(std::list<std::string>& params)
    {}

    void execute(CCPU *cpu)
    {}
};

/*============================================================================*/

/**
 * @class CInstructionJumpA
 *
 * TODO
 */
class CInstructionJumpA
 : public CInstruction
{
  public:
    CInstructionJumpA()
      : CInstruction("jumpa"), m_addr("")
    {}

    CInstructionJumpA *factory()
    {
      return new CInstructionJumpA;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    std::string m_addr;
};

/*============================================================================*/

/**
 * @class CInstructionJumpZ
 *
 * TODO
 */
class CInstructionJumpZ
 : public CInstruction
{
  public:
    CInstructionJumpZ()
      : CInstruction("jumpz"), m_addr("")
    {}

    CInstructionJumpZ *factory()
    {
      return new CInstructionJumpZ;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    std::string m_addr;
};

/*============================================================================*/

/**
 * @class CInstructionJumpS
 *
 * TODO
 */
class CInstructionJumpS
 : public CInstruction
{
  public:
    CInstructionJumpS()
      : CInstruction("jumps"), m_addr("")
    {}

    CInstructionJumpS *factory()
    {
      return new CInstructionJumpS;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    std::string m_addr;
};

/*============================================================================*/

/**
 * @class CInstructionWrite
 *
 * TODO
 */
class CInstructionWrite
 : public CInstruction
{
  public:
    CInstructionWrite()
      : CInstruction("write"), m_dev("")
    {}

    CInstructionWrite *factory()
    {
      return new CInstructionWrite;
    }

    void compile(std::list<std::string>& params);
    void execute(CCPU *cpu);

  protected:
    unsigned m_regidx1;
    std::string m_dev;
};

#endif

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