trying merging cpu-mm with default branch

1 files changed, 146 insertions, 160 deletions

diff --git a/ue3/mycpu/cinstruction.h b/ue3/mycpu/cinstruction.h
index 7d929a5..4cc69de 100644
--- a/ue3/mycpu/cinstruction.h
+++ b/ue3/mycpu/cinstruction.h
@@ -1,39 +1,38 @@
 /**
  * @module cinstruction
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  abstract class cpu instructions
- * @date   17.04.2009
+ * @brief  Abstract class for displays
+ * @date   13.05.2009
  */
 
 #ifndef CINSTRUCTION_H
-#define CINSTRUCTION_H
-#include <map>
-#include <vector>
-#include "cmem.h"
+#define CINSTRUCTION_H 1
 
+#include <iostream>
+#include <list>
+
+/* forward declare CCPU */
+class CCPU;
 
-        
 /**
  * @class CInstruction
  *
- * Parses a simple line based scriptfile with some limitations:
- * first function (starting a block) must be a read-command,
- * last must be a write-command (ending this block).
- *
- * read- and write-commands have hard coded parameters, number#1 being a filetype.
- * Classes handling certain filetypes must be of type CFile.
- * Custom functions will be passed to CFile::callFunc().
- *
- * On error ParserError will be thrown.
+ * Abstract class for displays
  */
 class CInstruction
 {
   public:
-       
-    CInstruction()
-    {}    
-    CInstruction(std::map<std::string, unsigned int>& jumpaddr)
-         : m_jumpaddr(jumpaddr)
+    /**
+     * @method CInstruction
+     * @brief  Default ctor
+     * @param  name  name of instruction
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    CInstruction(std::string name)
+      : m_name(name)
     {}
 
     /**
@@ -47,157 +46,144 @@ class CInstruction
      */
     virtual ~CInstruction()
     {}
-   
-    
-     virtual void exec(CMem& mem, std::vector<std::string>& instr) = 0;
-
-   protected:
-      std::map<std::string, unsigned int> m_jumpaddr;
-
-   
-};
-
-
-
-
-class CFlagInstruction : public CInstruction
-{
-  public:
-    public: 
-      CFlagInstruction(bool& zero, bool& sign) 
-        : f_zero(zero), f_sign(sign)
-      {}
-      CFlagInstruction(bool& zero, bool& sign, std::map<std::string, unsigned int>& jumpaddr) 
-        : CInstruction::CInstruction(jumpaddr), f_zero(zero), f_sign(sign)
-      {} 
-      virtual void exec(CMem& mem, std::vector<std::string>& instr) = 0;
-    
-    protected:
-      bool &f_zero,  &f_sign;
-      
-};
-
-
-
-class CInc : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-
-class CDec : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-
-
-class CAdd : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-
-
-class CSub : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-
-
-class CMul : public CInstruction
-{
-  public:
-     void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-
-
-class CDiv : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-
-
-class CLoad : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-
-
-class CStore : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
-
-class CTest : public CFlagInstruction
-{
-  public:
-    CTest(bool& zero, bool& sign) 
-      : CFlagInstruction::CFlagInstruction(zero, sign)
-    {}
-  
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
 
+    /**
+     * @method operator==
+     * @brief  implementation of operator ==
+     * @param  name reference to std::string
+     * @return true if instructionname is name
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual bool operator==(std::string& name)
+    {
+      return name == m_name;
+    }
 
-class CLabel : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr)
-    {}
-   
-};
-
+    /**
+     * @method operator()
+     * @brief  implementation of operator (CCPU)
+     * @param  cpu  pointer to cpu
+     * @return -
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    virtual CInstruction& operator()(CCPU *cpu)
+    {
+      execute(cpu);
+      return *this;
+    }
 
-class CJumpa : public CInstruction
-{
-  public:
-   CJumpa(std::map<std::string, unsigned int>& jumpaddr) 
-        : CInstruction::CInstruction(jumpaddr)
-    {}
-    void exec(CMem& mem, std::vector<std::string>& instr);
+    /**
+     * @method getName
+     * @brief  returns instruction name
+     * @param  -
+     * @return name of instruction
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual const std::string& getName()
+    {
+      return m_name;
+    }
 
-};
+    /**
+     * @method dump
+     * @brief  dumps information about instruction to outputstream
+     * @param  stream  outputstream
+     * @return reference to outputstream
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual std::ostream& dump(std::ostream& stream)
+    {
+      stream << m_name;
+      return stream;
+    }
 
+    /**
+     * @method operator<<
+     * @brief  Shift/output operator for outputstream
+     * @param  stream  reference to outputstream
+     * @param  instr   object which will be printed to stream
+     * @return reference to outputstream
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    friend std::ostream& operator<<(std::ostream& stream, CInstruction& instr)
+    {
+      return instr.dump(stream);
+    }
 
-class CJumpz : public CFlagInstruction
-{
-  
-  public:
-    CJumpz(bool& zero, bool& sign, std::map<std::string, unsigned int>& jumpaddr) 
-        : CFlagInstruction::CFlagInstruction(zero, sign, jumpaddr)
-    {}
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
+    /**
+     * @method parseRegister
+     * @brief  parses register syntax Rx (e.g. "R1")
+     * @param  str  register in assembler syntax
+     * @return registernumber
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    virtual const unsigned parseRegister(const std::string& str);
 
+    /**
+     * @method checkRegister
+     * @brief  performs a register boundary check
+     *         does the register exist in cpu?
+     * @param  cpu     pointer to cpu
+     * @param  regidx  registernumber
+     * @return -
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    virtual void checkRegister(CCPU *cpu, const unsigned regidx);
 
-class CJumps : public CFlagInstruction
-{
-  public:
-    CJumps(bool& zero ,bool& sign, std::map<std::string, unsigned int>& jumpaddr) 
-      : CFlagInstruction::CFlagInstruction(zero, sign, jumpaddr)
-    {}
-    void exec(CMem& mem, std::vector<std::string>& instr);
-};
+    /**
+     * @method factory
+     * @brief  creates a new instance of this instruction
+     * @param  -
+     * @return new instruction instance
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual CInstruction *factory() = 0;
 
+    /**
+     * @method compile
+     * @brief  parses instruction parameters and prepares the
+     *         instruction for executing
+     * @param  params  list of parameters of this instruction
+     * @return -
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    virtual void compile(std::list<std::string>& params) = 0;
 
+    /**
+     * @method execute
+     * @brief  executes the instruction
+     * @param  cpu  pointer to cpu
+     * @return -
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    virtual void execute(CCPU *cpu) = 0;
 
-class CWrite : public CInstruction
-{
-  public:
-    void exec(CMem& mem, std::vector<std::string>& instr);
+  protected:
+    /* members */
+    /** name of instruction */
+    std::string m_name;
 };
 
 #endif
+
 /* vim: set et sw=2 ts=2: */