8 files changed, 148 insertions, 68 deletions

diff --git a/ue4/mycpu/Makefile b/ue4/mycpu/Makefile
index 8022614..9e6db7a 100644
--- a/ue4/mycpu/Makefile
+++ b/ue4/mycpu/Makefile
@@ -12,7 +12,8 @@ LIBS=		-L/usr/local/lib -lboost_program_options
 
 BIN=            mycpu
 OBJS=           mycpu.o
-HEADERS=        cdat.h cmem.h cinstruction.h instructions.h cprogram.h cdisplay.h displays.h ccpu.h
+HEADERS=        cdat.h cdatn.h cdatset.h cmem.h cinstruction.h instructions.h \
+                                                        cprogram.h cdisplay.h displays.h ccpu.h 
 
 .SUFFIXES: .cpp .o
 
diff --git a/ue4/mycpu/ccpu.h b/ue4/mycpu/ccpu.h
index 519cee9..545b870 100644
--- a/ue4/mycpu/ccpu.h
+++ b/ue4/mycpu/ccpu.h
@@ -22,7 +22,7 @@
 #include "cprogram.h"
 
 /* forward declare CProgram */
-template <class T>
+template <class T=CDat<int>, int width=0>
 class CProgram;
 
 /**
@@ -31,7 +31,7 @@ class CProgram;
  * CPU implementation. Used as a container for memory and instructions.
  * Implements a run method to execute the program (= the instructions).
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CCPU
 {
   typedef typename std::set<CDisplay<T> *>::iterator displayiterator;
@@ -250,8 +250,8 @@ class CCPU
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
-CCPU<T>::CCPU(const unsigned cnt)
+template<class T, int width>
+CCPU<T, width>::CCPU(const unsigned cnt)
   : m_regcnt(cnt), m_memory(NULL), m_program(NULL), m_flagzero(false), m_flagsign(false)
 {
   /* create registers */
@@ -266,7 +266,7 @@ CCPU<T>::CCPU(const unsigned cnt)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T, int width>
 CCPU<T>::~CCPU()
 {
   /* delete registers */
@@ -280,7 +280,7 @@ CCPU<T>::~CCPU()
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T, int width>
 void CCPU<T>::run()
 {
   if (m_memory == NULL)
@@ -312,7 +312,7 @@ void CCPU<T>::run()
 /*----------------------------------------------------------------------------*/
 
 #if DEBUG
-template <class T>
+template<class T, int width>
 void CCPU<T>::dumpRegisters(std::ostream& out)
 {
   out << "[REGISTER DUMP]" << std::endl;
diff --git a/ue4/mycpu/cdatset.h b/ue4/mycpu/cdatset.h
new file mode 100644
index 0000000..03e71f4
--- /dev/null
+++ b/ue4/mycpu/cdatset.h
@@ -0,0 +1,49 @@
+/**
+ * @module cdat
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  Datatype template and datatype definition for CCPU and CMem
+ * @date   26.05.2009
+ */
+
+#ifndef CDATSET_H
+#define CDATSET_H 1
+
+#include <boost/operators.hpp>
+#include <iostream>
+
+/**
+ * @class CDat
+ *
+ * Datatype template for CCPU and CMem.
+ */
+template <class T>
+class CDatSet
+  : public CDat<T> 
+{
+  public:
+    /**
+     * @method operator>>
+     * @brief  Shift/read operator for inputstream
+     * @param  stream  reference to inputstream
+     * @param  cdat    reference to object which will be read from stream
+     * @return reference to inputstream
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    friend std::istream& operator>>(std::istream & stream, CDatSet& cdat)
+    {
+      std::string s;
+      stream >> s;
+      cdat.m_value = s.size();
+      return stream;
+    }
+
+  private:
+    /* members */
+    T m_value;
+};
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue4/mycpu/cinstruction.h b/ue4/mycpu/cinstruction.h
index 8c35d2c..a2e3743 100644
--- a/ue4/mycpu/cinstruction.h
+++ b/ue4/mycpu/cinstruction.h
@@ -17,7 +17,7 @@
 #include "ccpu.h"
 
 /* forward declare CCPU */
-template <class T>
+template<class T, int >
 class CCPU;
 
 /**
@@ -25,7 +25,7 @@ class CCPU;
  *
  * Abstract class for displays
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstruction
 {
   public:
@@ -193,7 +193,7 @@ class CInstruction
 
 /*----------------------------------------------------------------------------*/
 
-template<class T>
+template<class T=CDat<int>, int width=0>
 const unsigned CInstruction<T>::parseRegister(const std::string& str)
 {
   unsigned reg;
@@ -214,7 +214,7 @@ const unsigned CInstruction<T>::parseRegister(const std::string& str)
 
 /*----------------------------------------------------------------------------*/
 
-template<class T>
+template<class T=CDat<int>, int width=0>
 inline void CInstruction<T>::checkRegister(CCPU<T> *cpu, const unsigned regidx)
 {
   assert(cpu != NULL);
diff --git a/ue4/mycpu/cmem.h b/ue4/mycpu/cmem.h
index 6b23111..c6b8735 100644
--- a/ue4/mycpu/cmem.h
+++ b/ue4/mycpu/cmem.h
@@ -13,6 +13,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
 #ifdef DEBUG
 # include <iostream>
 # include <iomanip>
@@ -23,7 +24,7 @@
  *
  * Extends std::vector template for use as memory for CCPU.
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CMem
  : public std::vector<T>
 {
@@ -55,7 +56,8 @@ class CMem
       {
         ++i;
         std::getline(in, line);
-
+        boost::algorithm::trim(line);
+        
         /* skip last line if it's empty */
         if (line.empty() && in.eof())
           break;
@@ -63,8 +65,9 @@ class CMem
         T value;
         try
         {
-          if (!line.empty())
-            value = boost::lexical_cast<T>(line);
+        if (!line.empty())
+        {
+          value = boost::lexical_cast<T>(line);
         }
         catch(boost::bad_lexical_cast& ex)
         {
diff --git a/ue4/mycpu/cprogram.h b/ue4/mycpu/cprogram.h
index 43193ac..d8f7d5e 100644
--- a/ue4/mycpu/cprogram.h
+++ b/ue4/mycpu/cprogram.h
@@ -21,7 +21,7 @@
 #include "instructions.h"
 
 /* forward declare CInstruction */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstruction;
 
 /**
@@ -30,7 +30,7 @@ class CInstruction;
  * CProgram extends std::vector and adds a method for parsing
  * programfile. This adds instances of CInstruction to CProgram itself.
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CProgram
  : public std::vector<CInstruction<T> *>
 {
@@ -122,7 +122,7 @@ class CProgram
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 CProgram<T>::CProgram()
 {
   m_instrset.insert(new CInstructionInc<T>);
@@ -143,7 +143,7 @@ CProgram<T>::CProgram()
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 CProgram<T>::~CProgram()
 {
   /* free instruction set */
@@ -157,7 +157,7 @@ CProgram<T>::~CProgram()
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CProgram<T>::compile(std::istream& in)
 {
   if (!in.good())
@@ -241,7 +241,7 @@ void CProgram<T>::compile(std::istream& in)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 unsigned CProgram<T>::findLabel(const std::string& label) const
 {
   std::map<std::string, unsigned>::const_iterator it;
@@ -254,7 +254,7 @@ unsigned CProgram<T>::findLabel(const std::string& label) const
 /*----------------------------------------------------------------------------*/
 
 #if DEBUG
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CProgram<T>::dump(std::ostream& out)
 {
   out << "[PROGRAM DUMP]" << std::endl;
diff --git a/ue4/mycpu/instructions.h b/ue4/mycpu/instructions.h
index fcff3e7..3f2fd51 100644
--- a/ue4/mycpu/instructions.h
+++ b/ue4/mycpu/instructions.h
@@ -19,7 +19,7 @@
  * Syntax: inc R1
  *   (R1++)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionInc
  : public CInstruction<T>
 {
@@ -45,7 +45,7 @@ class CInstructionInc
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionInc<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -56,7 +56,7 @@ void CInstructionInc<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionInc<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -74,7 +74,7 @@ void CInstructionInc<T>::execute(CCPU<T> *cpu)
  * Syntax: dec R1
  *   (R1--)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionDec
  : public CInstruction<T>
 {
@@ -100,7 +100,7 @@ class CInstructionDec
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDec<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -111,7 +111,7 @@ void CInstructionDec<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDec<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -129,7 +129,7 @@ void CInstructionDec<T>::execute(CCPU<T> *cpu)
  * Syntax: add R1, R2, R3
  *   (R1 = R2 + R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionAdd
  : public CInstruction<T>
 {
@@ -159,7 +159,7 @@ class CInstructionAdd
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionAdd<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -174,7 +174,7 @@ void CInstructionAdd<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionAdd<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -195,7 +195,7 @@ void CInstructionAdd<T>::execute(CCPU<T> *cpu)
  * Syntax: sub R1, R2, R3
  *   (R1 = R2 - R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionSub
  : public CInstruction<T>
 {
@@ -225,7 +225,7 @@ class CInstructionSub
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionSub<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -240,7 +240,7 @@ void CInstructionSub<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionSub<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -261,7 +261,7 @@ void CInstructionSub<T>::execute(CCPU<T> *cpu)
  * Syntax: mul R1, R2, R3
  *   (R1 = R2 * R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionMul
  : public CInstruction<T>
 {
@@ -291,7 +291,7 @@ class CInstructionMul
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionMul<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -306,7 +306,7 @@ void CInstructionMul<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionMul<T>::execute(CCPU<T> *cpu)
 {
   super::checkRegister(cpu, m_regidx1);
@@ -325,7 +325,7 @@ void CInstructionMul<T>::execute(CCPU<T> *cpu)
  * Syntax: div R1, R2, R3
  *   (R1 = R2 / R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionDiv
  : public CInstruction<T>
 {
@@ -355,7 +355,7 @@ class CInstructionDiv
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDiv<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -370,7 +370,7 @@ void CInstructionDiv<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDiv<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -391,7 +391,7 @@ void CInstructionDiv<T>::execute(CCPU<T> *cpu)
  * Syntax: load R1, R2
  *   (R1 = memory[R2])
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionLoad
  : public CInstruction<T>
 {
@@ -419,7 +419,7 @@ class CInstructionLoad
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionLoad<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 2)
@@ -432,7 +432,7 @@ void CInstructionLoad<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionLoad<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -453,7 +453,7 @@ void CInstructionLoad<T>::execute(CCPU<T> *cpu)
  * Syntax: store R1, R2
  *   (memory[R2] = R1)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionStore
  : public CInstruction<T>
 {
@@ -481,7 +481,7 @@ class CInstructionStore
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionStore<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 2)
@@ -494,7 +494,7 @@ void CInstructionStore<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionStore<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -515,7 +515,7 @@ void CInstructionStore<T>::execute(CCPU<T> *cpu)
  * Syntax: test R1
  *   (R1 == 0: zeroflag: true, R1 < 0: signflag: true)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionTest
  : public CInstruction<T>
 {
@@ -541,7 +541,7 @@ class CInstructionTest
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionTest<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -552,7 +552,7 @@ void CInstructionTest<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionTest<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -572,7 +572,7 @@ void CInstructionTest<T>::execute(CCPU<T> *cpu)
  * Implementation of assembler command "label"
  * Syntax: label name:
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionLabel
  : public CInstruction<T>
 {
@@ -604,7 +604,7 @@ class CInstructionLabel
  * Syntax: jumpa labelname
  *   (jump to labelname)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionJumpA
  : public CInstruction<T>
 {
@@ -630,7 +630,7 @@ class CInstructionJumpA
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpA<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -641,7 +641,7 @@ void CInstructionJumpA<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpA<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -661,7 +661,7 @@ void CInstructionJumpA<T>::execute(CCPU<T> *cpu)
  * Syntax: jumpz labelname
  *   (jump to labelname if zeroflag)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionJumpZ
  : public CInstruction<T>
 {
@@ -687,7 +687,7 @@ class CInstructionJumpZ
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpZ<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -698,7 +698,7 @@ void CInstructionJumpZ<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpZ<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -720,7 +720,7 @@ void CInstructionJumpZ<T>::execute(CCPU<T> *cpu)
  * Syntax: jumps labelname
  *   (jump to labelname if signflag)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionJumpS
  : public CInstruction<T>
 {
@@ -746,7 +746,7 @@ class CInstructionJumpS
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpS<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -757,7 +757,7 @@ void CInstructionJumpS<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpS<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -779,7 +779,7 @@ void CInstructionJumpS<T>::execute(CCPU<T> *cpu)
  * Syntax: write DEV, R1
  *   (write R1 to DEV, which is a name of a display)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionWrite
  : public CInstruction<T>
 {
@@ -808,7 +808,7 @@ class CInstructionWrite
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionWrite<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 2)
@@ -821,7 +821,7 @@ void CInstructionWrite<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionWrite<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
diff --git a/ue4/mycpu/mycpu.cpp b/ue4/mycpu/mycpu.cpp
index 6c9f71a..2d73177 100644
--- a/ue4/mycpu/mycpu.cpp
+++ b/ue4/mycpu/mycpu.cpp
@@ -17,6 +17,8 @@
 #include <stdexcept>
 #include <stdlib.h>
 #include "cdat.h"
+#include "cdatn.h"
+#include "cdatset.h"
 #include "cmem.h"
 #include "cprogram.h"
 #include "ccpu.h"
@@ -73,7 +75,32 @@ int main(int argc, char* argv[])
   }
 
   /* create memory and optionally initialize memory from file */
-  CMem<CDat<int> > memory;
+  
+  CMem *memory = NULL;
+  if (vm.count("format"))
+  {
+    string format(vm["format"].as<string>());
+    if(format == "s")
+        memory = new CMem<CDatSet<int> >();
+    else
+    {
+      try
+      {
+        int bc = boost::lexical_cast<int>(format);
+        if (bc > 1 && bc < 33)
+          memory = new CMem<CDatN<int> >();
+      }   
+      catch(boost::bad_lexical_cast& ex)
+      {
+        std::stringstream sstr;
+        sstr << "Illegal format: (" << format << "): " << ex.what();
+        throw std::runtime_error(sstr.str());
+      }
+    }
+  }
+  else
+   
+  
   if (vm.count("memory"))
   {
     string memoryfile(vm["memory"].as<string>());
@@ -86,7 +113,7 @@ int main(int argc, char* argv[])
 
     try
     {
-      memory.initialize(file);
+      memory->initialize(file);
       file.close();
     }
     catch(runtime_error& ex)
@@ -98,7 +125,7 @@ int main(int argc, char* argv[])
     }
 
 #if DEBUG
-    memory.dump(cerr);
+    memory->dump(cerr);
 #endif
   }
 
@@ -134,7 +161,7 @@ int main(int argc, char* argv[])
   try
   {
     CCPU<CDat<int> > cpu(256);
-    cpu.setMemory(&memory);
+    cpu.setMemory(memory);
     cpu.setProgram(&program);
     cpu.run();
 #if DEBUG
@@ -146,7 +173,7 @@ int main(int argc, char* argv[])
     cerr << me << ": Error while executing program:" << endl
          << "  " << ex.what() << endl;
 #if DEBUG
-    memory.dump(cerr);
+    memory->dump(cerr);
 #endif
     return 1;
   }