From 45581d3d376e8deed84952cb838ae330549e5241 Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Tue, 12 May 2009 23:18:17 +0200
Subject: my cpu design

---
 ue3/mycpu/Makefile         |   8 +--
 ue3/mycpu/ccpu.cpp         |  78 +++++++++++++++++++++
 ue3/mycpu/ccpu.h           | 167 +++++++++++++++++++++++++++++++++++++++++++++
 ue3/mycpu/cdat.h           |  29 ++++++--
 ue3/mycpu/cdisplay.h       |  48 +++++++++++++
 ue3/mycpu/cinstruction.cpp |  46 +++++++++++++
 ue3/mycpu/cinstruction.h   |  98 ++++++++++++++++++++++++++
 ue3/mycpu/cmem.h           | 109 +++++++++++++++++++++++++++++
 ue3/mycpu/cprogram.cpp     | 126 ++++++++++++++++++++++++++++++++++
 ue3/mycpu/cprogram.h       |  78 +++++++++++++++++++++
 ue3/mycpu/instructions.cpp |  27 ++++++++
 ue3/mycpu/instructions.h   |  66 ++++++++++++++++++
 ue3/mycpu/mycpu.cpp        | 152 +++++++++++++++++++++++++++++++++++++++++
 13 files changed, 1022 insertions(+), 10 deletions(-)
 create mode 100644 ue3/mycpu/ccpu.cpp
 create mode 100644 ue3/mycpu/ccpu.h
 create mode 100644 ue3/mycpu/cdisplay.h
 create mode 100644 ue3/mycpu/cinstruction.cpp
 create mode 100644 ue3/mycpu/cinstruction.h
 create mode 100644 ue3/mycpu/cmem.h
 create mode 100644 ue3/mycpu/cprogram.cpp
 create mode 100644 ue3/mycpu/cprogram.h
 create mode 100644 ue3/mycpu/instructions.cpp
 create mode 100644 ue3/mycpu/instructions.h
 create mode 100644 ue3/mycpu/mycpu.cpp

diff --git a/ue3/mycpu/Makefile b/ue3/mycpu/Makefile
index 6f57741..16067d1 100644
--- a/ue3/mycpu/Makefile
+++ b/ue3/mycpu/Makefile
@@ -6,13 +6,13 @@ CXX=		g++
 LD=		$(CXX)
 DEBUGFLAGS=	-DNDEBUG
 INCLUDE_PATH=	-I/usr/local/include
-CXXFLAGS=	-O -ansi -pedantic-errors -Wall $(INCLUDE_PATH) $(DEBUGFLAGS)
+CXXFLAGS=	-O -ansi -pedantic-errors -Wall -Wno-long-long $(INCLUDE_PATH) $(DEBUGFLAGS)
 LDFLAGS=
-LIBS=		-L/usr/local/lib
+LIBS=		-L/usr/local/lib -lboost_program_options
 
 BIN=		mycpu
-OBJS=		mycpu.o cdat.o
-HEADERS=	cdat.h
+OBJS=		cinstruction.o instructions.o cprogram.o ccpu.o mycpu.o
+HEADERS=	cdat.h cmem.h cinstruction.h instructions.h cprogram.h cdisplay.h ccpu.h
 
 .SUFFIXES: .cpp .o
 
diff --git a/ue3/mycpu/ccpu.cpp b/ue3/mycpu/ccpu.cpp
new file mode 100644
index 0000000..6f364f8
--- /dev/null
+++ b/ue3/mycpu/ccpu.cpp
@@ -0,0 +1,78 @@
+/**
+ * @module ccpu
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#ifdef DEBUG
+# include <iostream>
+# include <iomanip>
+#endif
+#include "ccpu.h"
+
+using namespace std;
+
+CCPU::CCPU(const unsigned cnt)
+  : m_regcnt(cnt), m_memory(NULL), m_program(NULL), m_flagzero(0), m_flagsign(0)
+{
+  m_registers = new CDat[cnt];
+  for(unsigned i = 0; i < cnt; ++i)
+    m_registers[i] = 0;
+}
+
+/*----------------------------------------------------------------------------*/
+
+CCPU::~CCPU()
+{
+  delete[] m_registers;
+  m_registers = NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CCPU::run()
+{
+  if (m_memory == NULL)
+    throw runtime_error("CPU has no memory");
+  if (m_program == NULL)
+    throw runtime_error("CPU has no program to execute");
+  if (m_regcnt == 0)
+    throw 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())
+      return;
+
+    /* pc is out of bound */
+    if (pc > m_program->size())
+      throw runtime_error("Programcounter is out of bound");
+
+    /* execute instruction */
+    m_program->at(pc)->execute(this);
+    ++m_registers[0];
+  }
+
+  cout << "LALA" << endl;
+}
+
+/*----------------------------------------------------------------------------*/
+
+#if DEBUG
+void CCPU::dumpRegisters(std::ostream& out)
+{
+  out << "[REGISTER DUMP]" << endl;
+  for(unsigned i = 0; i < getRegisterCount(); ++i)
+  {
+    out << "[" << std::setw(4) << std::setfill('0') << i << "]  "
+        << m_registers[i] << endl;
+  }
+}
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/ccpu.h b/ue3/mycpu/ccpu.h
new file mode 100644
index 0000000..e28a7cc
--- /dev/null
+++ b/ue3/mycpu/ccpu.h
@@ -0,0 +1,167 @@
+/**
+ * @module ccpu
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#ifndef CCPU_H
+#define CCPU_H 1
+
+#include <vector>
+#include <iostream>
+#include "cdat.h"
+#include "cmem.h"
+#include "cprogram.h"
+
+/**
+ * @class CCPU
+ *
+ * TODO
+ */
+class CCPU
+{
+  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()
+    {
+      return m_regcnt;
+    }
+
+    /**
+     * @method getRegisters
+     * @brief  get pointer to registers array
+     * @param  -
+     * @return pointer to registers array
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    CDat *getRegisters()
+    {
+      return m_registers;
+    }
+
+    /**
+     * @method setMemory
+     * @brief  set memory of cpu
+     * @param  memory  pointer to memory
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    void setMemory(const CMem *memory)
+    {
+      m_memory = memory;
+    }
+
+    /**
+     * @method getMemory
+     * @brief  get pointer to memory
+     * @param  -
+     * @return pointer to memory
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    const CMem *getMemory()
+    {
+      return m_memory;
+    }
+
+    /**
+     * @method setProgram
+     * @brief  set program to execute
+     * @param  memory  pointer to program
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    void setProgram(const CProgram *program)
+    {
+      m_program = program;
+    }
+
+    /**
+     * @method getProgram
+     * @brief  get pointer to program
+     * @param  -
+     * @return pointer to program
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    const CProgram *getProgram()
+    {
+      return m_program;
+    }
+
+    /**
+     * @method run
+     * @brief  execute current program
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  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 */
+    CDat *m_registers;
+    unsigned m_regcnt;
+    const CMem *m_memory;
+    const CProgram *m_program;
+    bool m_flagzero;
+    bool m_flagsign;
+};
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/cdat.h b/ue3/mycpu/cdat.h
index dc8a07c..365bd88 100644
--- a/ue3/mycpu/cdat.h
+++ b/ue3/mycpu/cdat.h
@@ -1,12 +1,12 @@
 /**
  * @module cdat
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  Datatype template for mycpu
+ * @brief  Datatype template and datatype definition for CCPU and CMem
  * @date   10.05.2009
  */
 
-#ifndef CDATT_H
-#define CDATT_H
+#ifndef CDAT_H
+#define CDAT_H 1
 
 #include <boost/operators.hpp>
 #include <iostream>
@@ -14,7 +14,7 @@
 /**
  * @class CDatT
  *
- * Datatype template for mycpu.
+ * Datatype template for CCPU and CMem.
  */
 template <class T>
 class CDatT
@@ -85,6 +85,20 @@ class CDatT
       return m_value;
     }
 
+    /**
+     * @method operator T
+     * @brief  convert to T
+     * @param  -
+     * @return T
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    operator T()
+    {
+      return m_value;
+    }
+
     /**
      * @method operator<
      * @brief  implementation of operator <
@@ -300,8 +314,11 @@ class CDatT
     T m_value;
 };
 
-
-/** define CDat */
+/**
+ * @class CDat
+ *
+ * Datatype for CCPU and CMem
+ */
 typedef CDatT<int> CDat;
 
 #endif
diff --git a/ue3/mycpu/cdisplay.h b/ue3/mycpu/cdisplay.h
new file mode 100644
index 0000000..629ec88
--- /dev/null
+++ b/ue3/mycpu/cdisplay.h
@@ -0,0 +1,48 @@
+/**
+ * @module cdisplay
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#ifndef CDISPLAY_H
+#define CDISPLAY_H #1
+
+/**
+ * @class CDisplay
+ *
+ * TODO
+ */
+class CDisplay
+{
+  public:
+    /**
+     * @method CDisplay
+     * @brief  Default ctor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    CDisplay()
+    {};
+
+    /**
+     * @method ~CDisplay
+     * @brief  Default dtor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    ~CDisplay();
+
+  private:
+    /* members */
+};
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/cinstruction.cpp b/ue3/mycpu/cinstruction.cpp
new file mode 100644
index 0000000..32bdd2f
--- /dev/null
+++ b/ue3/mycpu/cinstruction.cpp
@@ -0,0 +1,46 @@
+/**
+ * @module cinstruction
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#include <sstream>
+#include <stdexcept>
+#include <boost/lexical_cast.hpp>
+#include "cinstruction.h"
+#include "ccpu.h"
+
+using namespace std;
+
+const unsigned CInstruction::parseRegister(const std::string& str)
+{
+  unsigned reg;
+  if (str.length() < 2 || str[0] != 'R')
+    throw runtime_error("Invalid syntax of register");
+
+  try
+  {
+    reg = boost::lexical_cast<unsigned>(str.substr(1));
+  }
+  catch(boost::bad_lexical_cast& ex)
+  {
+    throw runtime_error("Invalid syntax of register");
+  }
+
+  return reg;
+}
+
+/*----------------------------------------------------------------------------*/
+
+inline void CInstruction::checkRegister(CCPU *cpu, unsigned regidx)
+{
+  if (regidx >= cpu->getRegisterCount())
+  {
+    stringstream sstr;
+    sstr << "Register R" << regidx << " doesn't exist (out of bound)";
+    throw runtime_error(sstr.str());
+  }
+}
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/cinstruction.h b/ue3/mycpu/cinstruction.h
new file mode 100644
index 0000000..b16c067
--- /dev/null
+++ b/ue3/mycpu/cinstruction.h
@@ -0,0 +1,98 @@
+/**
+ * @module cinstruction
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#ifndef CINSTRUCTION_H
+#define CINSTRUCTION_H 1
+
+#include <iostream>
+#include <list>
+//#include "ccpu.h"
+
+/* declare CCPU */
+class CCPU;
+
+/**
+ * @class CInstruction
+ *
+ * TODO
+ */
+class CInstruction
+{
+  public:
+    /**
+     * @method CInstruction
+     * @brief  Default ctor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    CInstruction(std::string name)
+      : m_name(name)
+    {};
+
+    /**
+     * @method ~CInstruction
+     * @brief  Default dtor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual ~CInstruction()
+    {};
+
+    /* TODO */
+    virtual bool operator==(std::string& name)
+    {
+      return name == m_name;
+    }
+
+    /* TODO */
+    virtual const std::string& getName()
+    {
+      return m_name;
+    }
+
+    /* TODO */
+    virtual std::ostream& dump(std::ostream& stream)
+    {
+      stream << m_name;
+      return stream;
+    }
+
+    /* TODO */
+    friend std::ostream& operator<<(std::ostream& stream, CInstruction& instr)
+    {
+      return instr.dump(stream);
+    }
+
+    /* TODO */
+    virtual const unsigned parseRegister(const std::string& str);
+
+    /* TODO */
+    virtual void checkRegister(CCPU *cpu, unsigned regidx);
+
+    /* TODO */
+    virtual CInstruction *factory() = 0;
+
+    /* TODO */
+    virtual void compile(std::list<std::string>& params) = 0;
+
+    /* TODO */
+    virtual void execute(CCPU *cpu) = 0;
+
+  protected:
+    /* members */
+    std::string m_name;
+};
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/cmem.h b/ue3/mycpu/cmem.h
new file mode 100644
index 0000000..5045c34
--- /dev/null
+++ b/ue3/mycpu/cmem.h
@@ -0,0 +1,109 @@
+/**
+ * @module cmem
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  Memory template and memory definition for CCPU
+ * @date   10.05.2009
+ */
+
+#ifndef CMEM_H
+#define CMEM_H 1
+
+#include <vector>
+#include <istream>
+#include <sstream>
+#include <stdexcept>
+#include <boost/lexical_cast.hpp>
+#ifdef DEBUG
+# include <iostream>
+# include <iomanip>
+#endif
+#include "cdat.h"
+
+/**
+ * @class CVectorMem
+ *
+ * Extends std::vector template for use as memory for CCPU.
+ */
+template <class T, class Allocator=std::allocator<T> >
+class CVectorMem
+  : public std::vector<T, Allocator>
+{
+  public:
+    using std::vector<T, Allocator>::size;
+    using std::vector<T, Allocator>::at;
+
+    /**
+     * @method initialize
+     * @brief  initialize the vector with the content of istream. istream is
+     *         read per line. empty lines will add unitialized elements.
+     * @param  in  inputstream to read from
+     * @return void
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    void initialize(std::istream& in)
+    {
+      if (!in.good())
+        return;
+
+      std::string line;
+      unsigned i = 0;
+      while (!in.eof() && in.good())
+      {
+        ++i;
+        std::getline(in, line);
+
+        /* skip last line if it's empty */
+        if (line.empty() && in.eof())
+          break;
+
+        T value;
+        try
+        {
+          if (!line.empty())
+            value = boost::lexical_cast<T>(line);
+        }
+        catch(boost::bad_lexical_cast& ex)
+        {
+          std::stringstream sstr;
+          sstr << "Unable to convert input (line " << i << "): " << ex.what();
+          throw std::runtime_error(sstr.str());
+        }
+
+        push_back(value);
+      }
+    }
+
+#if DEBUG
+    /**
+     * @method dump
+     * @brief  dumps contents of vector to outputstream
+     * @param  out  outputstream to write to
+     * @return void
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    void dump(std::ostream& out)
+    {
+      out << "[MEMORY DUMP]" << std::endl;
+      for(unsigned i = 0; i < size(); ++i)
+      {
+        out << "[" << std::setw(4) << std::setfill('0') << i << "]  "
+            << at(i) << std::endl;
+      }
+    }
+#endif
+};
+
+/**
+ * @class CMem
+ *
+ * Memory definition for CCPU
+ */
+typedef CVectorMem<CDat> CMem;
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/cprogram.cpp b/ue3/mycpu/cprogram.cpp
new file mode 100644
index 0000000..03d4c30
--- /dev/null
+++ b/ue3/mycpu/cprogram.cpp
@@ -0,0 +1,126 @@
+/**
+ * @module cprogram
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   12.05.2009
+ */
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/split.hpp>
+#ifdef DEBUG
+# include <iostream>
+# include <iomanip>
+#endif
+#include "cprogram.h"
+#include "instructions.h"
+
+using namespace std;
+
+CProgram::CProgram()
+{
+  m_instrset.insert(new CInstructionInc);
+}
+
+/*----------------------------------------------------------------------------*/
+
+CProgram::~CProgram()
+{
+  /* free instruction set */
+  set<CInstruction *>::iterator it;
+  for (it = m_instrset.begin(); it != m_instrset.end(); ++it)
+    delete *it;
+
+  /* free instruction */
+  for (iterator it = begin(); it != end(); ++it)
+    delete *it;
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CProgram::compile(std::istream& in)
+{
+  if (!in.good())
+    return;
+
+  string line;
+  unsigned i = 0;
+  while (!in.eof() && in.good())
+  {
+    ++i;
+
+    /* read stream per line */
+    getline(in, line);
+    if (line.empty())
+      continue;
+
+    boost::trim(line);
+
+    /* ignore comments */
+    if (line.find_first_of('#') == 0)
+      continue;
+
+    /* get instruction name */
+    size_t pos = line.find_first_of(' ');
+    string instrname = line.substr(0, pos);
+
+    /* search and create instruction */
+    CInstruction *instrptr = NULL;
+    set<CInstruction *>::iterator it;
+    for (it = m_instrset.begin(); it != m_instrset.end(); ++it)
+    {
+      if (*(*it) == instrname)
+      {
+        instrptr = *it;
+        break;
+      }
+    }
+    if (instrptr == NULL)
+    {
+      stringstream sstr;
+      sstr << "Unknown instruction '" << instrname << "' on line " << i << ".";
+      throw runtime_error(sstr.str());
+    }
+
+    /* create instruction */
+    CInstruction *instr = instrptr->factory();
+
+    /* parse instruction parameters */
+    string params = (pos == string::npos) ? "" : line.substr(pos + 1);
+    boost::trim(params);
+    list<string> instrparams;
+    boost::split(instrparams, params, boost::is_any_of(", "), boost::token_compress_on);
+
+    /* let instruction parse the parameters. catch+throw exception */
+    try
+    {
+      instr->compile(instrparams);
+    }
+    catch(runtime_error& ex)
+    {
+      stringstream sstr;
+      sstr << "Unable to compile instruction '" << instrname
+           << "' (line " << i << "): " << ex.what();
+      throw runtime_error(sstr.str());
+    }
+
+    push_back(instr);
+  }
+}
+
+/*----------------------------------------------------------------------------*/
+
+#if DEBUG
+void CProgram::dump(std::ostream& out)
+{
+  out << "[PROGRAM DUMP]" << endl;
+  unsigned i = 0;
+  for(iterator it = begin(); it < end(); ++it)
+  {
+    out << "[" << std::setw(4) << std::setfill('0') << i << "]  "
+        << *(*it) << endl;
+    ++i;
+  }
+}
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/cprogram.h b/ue3/mycpu/cprogram.h
new file mode 100644
index 0000000..bf161b8
--- /dev/null
+++ b/ue3/mycpu/cprogram.h
@@ -0,0 +1,78 @@
+/**
+ * @module cprogram
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#ifndef CPROGRAM_H
+#define CPROGRAM_H 1
+
+#include <vector>
+#include <set>
+#include "cinstruction.h"
+
+/**
+ * @class CProgram
+ *
+ * TODO
+ */
+class CProgram
+  : public std::vector<CInstruction *>
+{
+  public:
+    /**
+     * @method CProgram
+     * @brief  Default ctor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    CProgram();
+
+    /**
+     * @method ~CProgram
+     * @brief  Default dtor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    ~CProgram();
+
+    /**
+     * @method compile
+     * @brief  create instructions from parsing stream
+     * @param  in  inputstream to read from
+     * @return void
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    void compile(std::istream& in);
+
+#if DEBUG
+    /**
+     * @method dump
+     * @brief  dumps contents to outputstream
+     * @param  out  outputstream to write to
+     * @return void
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    void dump(std::ostream& out);
+#endif
+
+  private:
+    /* members */
+    /** set of known instructions */
+    std::set<CInstruction *> m_instrset;
+};
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/instructions.cpp b/ue3/mycpu/instructions.cpp
new file mode 100644
index 0000000..c283e57
--- /dev/null
+++ b/ue3/mycpu/instructions.cpp
@@ -0,0 +1,27 @@
+/**
+ * @module instructions
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#include "instructions.h"
+
+using namespace std;
+
+void CInstructionInc::compile(std::list<std::string>& params)
+{
+  if (params.size() != 1)
+    throw runtime_error("Invalid paramater count - must be 1");
+  m_regidx1 = parseRegister(params.front());
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionInc::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  cpu->getRegisters()[m_regidx1]++;
+}
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/instructions.h b/ue3/mycpu/instructions.h
new file mode 100644
index 0000000..ebd1533
--- /dev/null
+++ b/ue3/mycpu/instructions.h
@@ -0,0 +1,66 @@
+/**
+ * @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:
+    /**
+     * @method CInstruction
+     * @brief  Default ctor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    CInstructionInc()
+      : CInstruction("inc")
+    {};
+
+    /**
+     * @method ~CInstruction
+     * @brief  Default dtor
+     * @param  -
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    ~CInstructionInc()
+    {};
+
+    /* TODO */
+    CInstructionInc *factory()
+    {
+      return new CInstructionInc;
+    }
+
+    /* TODO */
+    void compile(std::list<std::string>& params);
+
+    /* TODO */
+    void execute(CCPU *cpu);
+
+  protected:
+    unsigned m_regidx1;
+};
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/mycpu.cpp b/ue3/mycpu/mycpu.cpp
new file mode 100644
index 0000000..af91fe7
--- /dev/null
+++ b/ue3/mycpu/mycpu.cpp
@@ -0,0 +1,152 @@
+/**
+ * @module mycpu
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   11.05.2009
+ * @par Exercise
+ *      3
+ */
+
+#include <boost/program_options.hpp>
+#include <iostream>
+#include <fstream>
+#include <stdexcept>
+#include <stdlib.h>
+#include "ccpu.h"
+#include "cmem.h"
+#include "cprogram.h"
+
+using namespace std;
+namespace po = boost::program_options;
+
+/** TODO */
+void myterminate()
+{
+  cerr << "Unexpected termination" << endl;
+  abort();
+}
+
+/**
+ * @func   main
+ * @brief  program entry point
+ * @param  argc  standard parameter of main
+ * @param  argv  standard parameter of main
+ * @return 0 on success, not 0 otherwise
+ * @globalvars none
+ * @exception  none
+ * @conditions none
+ *
+ * TODO
+ */
+int main(int argc, char* argv[])
+{
+  //TODO set_terminate(myterminate);
+  string me(argv[0]);
+
+  /* define commandline options */
+  po::options_description desc("Allowed options");
+  desc.add_options()
+    ("help,h",    "this help message")
+    ("compile,c", po::value<string>(), "input programfile")
+    ("memory,m",  po::value<string>(), "input memoryfile");
+
+  /* parse commandline options */
+  po::variables_map vm;
+  try
+  {
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm);
+  }
+  catch(po::error& ex)
+  {
+    cerr << me << ": Error: " << ex.what() << endl;
+  }
+
+  /* print usage upon request or missing params */
+  if (vm.count("help") || !vm.count("compile"))
+  {
+    cout << "Usage: " << me << " -c <programfile> [-m <memoryfile>]" << endl;
+    cout << desc << endl;
+    return 0;
+  }
+
+  /* create memory and optionally initialize memory from file */
+  CMem memory;
+  if (vm.count("memory"))
+  {
+    string memoryfile(vm["memory"].as<string>());
+    ifstream file(memoryfile.c_str(), ios::in);
+    if (!file.is_open())
+    {
+      cerr << me << ": Unable to open memoryfile '" << memoryfile << "' for reading." << endl;
+      return 1;
+    }
+
+    try
+    {
+      memory.initialize(file);
+      file.close();
+    }
+    catch(runtime_error& ex)
+    {
+      file.close();
+      cerr << me << ": Error while reading from memoryfile:" << endl
+           << "  " << ex.what() << endl;
+      return 1;
+    }
+
+#if DEBUG
+    memory.dump(cout);
+#endif
+  }
+
+  /* create program instance */
+  CProgram program;
+  string programfile(vm["compile"].as<string>());
+  ifstream file(programfile.c_str(), ios::in);
+  if (!file.is_open())
+  {
+    cerr << me << ": Unable to open programfile '" << programfile << "' for reading." << endl;
+    return 1;
+  }
+
+  try
+  {
+    program.compile(file);
+    file.close();
+  }
+  catch(runtime_error& ex)
+  {
+    file.close();
+    cerr << me << ": Error while compiling programfile:" << endl
+         << "  " << ex.what() << endl;
+    return 1;
+  }
+
+#if DEBUG
+  program.dump(cout);
+#endif
+
+
+  /* create cpu and execute the program */
+  try
+  {
+    CCPU cpu(256);
+    cpu.setMemory(&memory);
+    cpu.setProgram(&program);
+    cpu.run();
+#if DEBUG
+    cpu.dumpRegisters(cout);
+#endif
+  }
+  catch(runtime_error& ex)
+  {
+    cerr << me << ": Error while executing program:" << endl
+        << "  " << ex.what() << endl;
+    return 1;
+  }
+
+  return 0;
+}
+
+/* vim: set et sw=2 ts=2: */
-- 
cgit v1.2.3


From 89e202f49b9857dcd3627fbc4e0262125d729bbc Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Wed, 13 May 2009 04:09:39 +0200
Subject: adding all instructions and displays

---
 ue3/mycpu/Makefile         |   2 +-
 ue3/mycpu/ccpu.cpp         |  18 +-
 ue3/mycpu/ccpu.h           |  84 +++++++++-
 ue3/mycpu/cdat.h           |   4 +-
 ue3/mycpu/cdisplay.h       |  41 ++++-
 ue3/mycpu/cinstruction.cpp |   4 +-
 ue3/mycpu/cinstruction.h   | 133 +++++++++++++--
 ue3/mycpu/cprogram.cpp     |  14 ++
 ue3/mycpu/displays.h       |  56 +++++++
 ue3/mycpu/instructions.cpp | 339 +++++++++++++++++++++++++++++++++++++-
 ue3/mycpu/instructions.h   | 399 ++++++++++++++++++++++++++++++++++++++++++---
 ue3/mycpu/mycpu.cpp        |  16 +-
 ue3/mycpu/test/memory1     |   1 +
 ue3/mycpu/test/program1    |  13 ++
 14 files changed, 1051 insertions(+), 73 deletions(-)
 create mode 100644 ue3/mycpu/displays.h
 create mode 100644 ue3/mycpu/test/memory1
 create mode 100644 ue3/mycpu/test/program1

diff --git a/ue3/mycpu/Makefile b/ue3/mycpu/Makefile
index 16067d1..eec8b47 100644
--- a/ue3/mycpu/Makefile
+++ b/ue3/mycpu/Makefile
@@ -12,7 +12,7 @@ LIBS=		-L/usr/local/lib -lboost_program_options
 
 BIN=		mycpu
 OBJS=		cinstruction.o instructions.o cprogram.o ccpu.o mycpu.o
-HEADERS=	cdat.h cmem.h cinstruction.h instructions.h cprogram.h cdisplay.h ccpu.h
+HEADERS=	cdat.h cmem.h cinstruction.h instructions.h cprogram.h cdisplay.h displays.h ccpu.h
 
 .SUFFIXES: .cpp .o
 
diff --git a/ue3/mycpu/ccpu.cpp b/ue3/mycpu/ccpu.cpp
index 6f364f8..b1539a4 100644
--- a/ue3/mycpu/ccpu.cpp
+++ b/ue3/mycpu/ccpu.cpp
@@ -10,23 +10,35 @@
 # include <iomanip>
 #endif
 #include "ccpu.h"
+#include "displays.h"
 
 using namespace std;
 
 CCPU::CCPU(const unsigned cnt)
-  : m_regcnt(cnt), m_memory(NULL), m_program(NULL), m_flagzero(0), m_flagsign(0)
+  : m_regcnt(cnt), m_memory(NULL), m_program(NULL), m_flagzero(false), m_flagsign(false)
 {
+  /* create registers */
   m_registers = new CDat[cnt];
   for(unsigned i = 0; i < cnt; ++i)
     m_registers[i] = 0;
+
+  /* create displays */
+  m_displays.insert(new CDisplayWDEZ);
+  m_displays.insert(new CDisplayWHEX);
 }
 
 /*----------------------------------------------------------------------------*/
 
 CCPU::~CCPU()
 {
+  /* delete registers */
   delete[] m_registers;
   m_registers = NULL;
+
+  /* delete displays */
+  std::set<CDisplay *>::iterator it;
+  for (it = m_displays.begin() ; it != m_displays.end(); ++it)
+    delete *it;
 }
 
 /*----------------------------------------------------------------------------*/
@@ -47,7 +59,7 @@ void CCPU::run()
 
     /* end of the program reached */
     if (pc == m_program->size())
-      return;
+      break;
 
     /* pc is out of bound */
     if (pc > m_program->size())
@@ -57,8 +69,6 @@ void CCPU::run()
     m_program->at(pc)->execute(this);
     ++m_registers[0];
   }
-
-  cout << "LALA" << endl;
 }
 
 /*----------------------------------------------------------------------------*/
diff --git a/ue3/mycpu/ccpu.h b/ue3/mycpu/ccpu.h
index e28a7cc..1ef1923 100644
--- a/ue3/mycpu/ccpu.h
+++ b/ue3/mycpu/ccpu.h
@@ -8,11 +8,12 @@
 #ifndef CCPU_H
 #define CCPU_H 1
 
-#include <vector>
 #include <iostream>
+#include <set>
 #include "cdat.h"
 #include "cmem.h"
 #include "cprogram.h"
+#include "cdisplay.h"
 
 /**
  * @class CCPU
@@ -53,7 +54,7 @@ class CCPU
      * @exception  none
      * @conditions none
      */
-    const unsigned getRegisterCount()
+    const unsigned getRegisterCount() const
     {
       return m_regcnt;
     }
@@ -67,7 +68,7 @@ class CCPU
      * @exception  none
      * @conditions none
      */
-    CDat *getRegisters()
+    CDat *getRegisters() const
     {
       return m_registers;
     }
@@ -81,7 +82,7 @@ class CCPU
      * @exception  none
      * @conditions none
      */
-    void setMemory(const CMem *memory)
+    void setMemory(CMem *memory)
     {
       m_memory = memory;
     }
@@ -95,7 +96,7 @@ class CCPU
      * @exception  none
      * @conditions none
      */
-    const CMem *getMemory()
+    CMem *getMemory() const
     {
       return m_memory;
     }
@@ -128,6 +129,76 @@ class CCPU
       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 *>& 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
@@ -156,8 +227,9 @@ class CCPU
     /* members */
     CDat *m_registers;
     unsigned m_regcnt;
-    const CMem *m_memory;
+    CMem *m_memory;
     const CProgram *m_program;
+    std::set<CDisplay *> m_displays;
     bool m_flagzero;
     bool m_flagsign;
 };
diff --git a/ue3/mycpu/cdat.h b/ue3/mycpu/cdat.h
index 365bd88..c656b99 100644
--- a/ue3/mycpu/cdat.h
+++ b/ue3/mycpu/cdat.h
@@ -72,7 +72,7 @@ class CDatT
     {}
 
     /**
-     * @method value
+     * @method getValue
      * @brief  returns value of CDatT
      * @param  -
      * @return value of CDatT
@@ -80,7 +80,7 @@ class CDatT
      * @exception  none
      * @conditions none
      */
-    T value() const
+    T getValue() const
     {
       return m_value;
     }
diff --git a/ue3/mycpu/cdisplay.h b/ue3/mycpu/cdisplay.h
index 629ec88..ed9b84d 100644
--- a/ue3/mycpu/cdisplay.h
+++ b/ue3/mycpu/cdisplay.h
@@ -6,7 +6,7 @@
  */
 
 #ifndef CDISPLAY_H
-#define CDISPLAY_H #1
+#define CDISPLAY_H 1
 
 /**
  * @class CDisplay
@@ -19,14 +19,16 @@ class CDisplay
     /**
      * @method CDisplay
      * @brief  Default ctor
-     * @param  -
+     * @param  name  name of display
      * @return -
      * @globalvars none
      * @exception  none
      * @conditions none
      */
-    CDisplay()
-    {};
+    CDisplay(std::string name)
+    {
+      m_name = name;
+    }
 
     /**
      * @method ~CDisplay
@@ -37,10 +39,37 @@ class CDisplay
      * @exception  none
      * @conditions none
      */
-    ~CDisplay();
+    virtual ~CDisplay()
+    {}
+
+    /**
+     * @method getName
+     * @brief  returns name of display
+     * @param  -
+     * @return name of display
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual const std::string& getName()
+    {
+      return m_name;
+    }
+
+    /**
+     * @method getName
+     * @brief  prints value to display
+     * @param  value  value to display
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual void display(const CDat &value) = 0;
 
-  private:
+  protected:
     /* members */
+    std::string m_name;
 };
 
 #endif
diff --git a/ue3/mycpu/cinstruction.cpp b/ue3/mycpu/cinstruction.cpp
index 32bdd2f..57acd5f 100644
--- a/ue3/mycpu/cinstruction.cpp
+++ b/ue3/mycpu/cinstruction.cpp
@@ -16,7 +16,7 @@ using namespace std;
 const unsigned CInstruction::parseRegister(const std::string& str)
 {
   unsigned reg;
-  if (str.length() < 2 || str[0] != 'R')
+  if (str.length() < 2 || str[0] != 'r')
     throw runtime_error("Invalid syntax of register");
 
   try
@@ -33,7 +33,7 @@ const unsigned CInstruction::parseRegister(const std::string& str)
 
 /*----------------------------------------------------------------------------*/
 
-inline void CInstruction::checkRegister(CCPU *cpu, unsigned regidx)
+inline void CInstruction::checkRegister(CCPU *cpu, const unsigned regidx)
 {
   if (regidx >= cpu->getRegisterCount())
   {
diff --git a/ue3/mycpu/cinstruction.h b/ue3/mycpu/cinstruction.h
index b16c067..57fcff1 100644
--- a/ue3/mycpu/cinstruction.h
+++ b/ue3/mycpu/cinstruction.h
@@ -10,9 +10,8 @@
 
 #include <iostream>
 #include <list>
-//#include "ccpu.h"
 
-/* declare CCPU */
+/* forward declare CCPU */
 class CCPU;
 
 /**
@@ -26,7 +25,7 @@ class CInstruction
     /**
      * @method CInstruction
      * @brief  Default ctor
-     * @param  -
+     * @param  name  name of instruction
      * @return -
      * @globalvars none
      * @exception  none
@@ -34,7 +33,7 @@ class CInstruction
      */
     CInstruction(std::string name)
       : m_name(name)
-    {};
+    {}
 
     /**
      * @method ~CInstruction
@@ -46,46 +45,150 @@ class CInstruction
      * @conditions none
      */
     virtual ~CInstruction()
-    {};
+    {}
 
-    /* TODO */
+    /**
+     * @method operator==
+     * @brief  implementation of operator ==
+     * @param  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;
     }
 
-    /* TODO */
+    /**
+     * @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;
     }
 
-    /* TODO */
+    /**
+     * @method isLabel
+     * @brief  returns true if the instruction defines a label
+     * @param  -
+     * @return true if the instruction defines a label
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual const bool isLabel()
+    {
+      return false;
+    }
+
+    /**
+     * @method getLabelName
+     * @brief  returns labelname if the instruction defines a label
+     * @param  -
+     * @return labelname if the instruction defines a label
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    virtual const std::string getLabelName()
+    {
+      return "";
+    }
+
+    /**
+     * @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;
     }
 
-    /* TODO */
+    /**
+     * @method operator<<
+     * @brief  Shift/output operator for outputstream
+     * @param  stream  reference to outputstream
+     * @param  cdat    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);
     }
 
-    /* TODO */
+    /**
+     * @method parseRegister
+     * @brief  parses register syntax Rx (e.g. "R1")
+     * @param  str  register in assembler syntax
+     * @return registernumber
+     * @globalvars none
+     * @exception  runtime_error
+     * @conditions none
+     */
     virtual const unsigned parseRegister(const std::string& str);
 
-    /* TODO */
-    virtual void checkRegister(CCPU *cpu, unsigned regidx);
+    /**
+     * @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  runtime_error
+     * @conditions none
+     */
+    virtual void checkRegister(CCPU *cpu, const unsigned regidx);
 
-    /* TODO */
+    /**
+     * @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;
 
-    /* TODO */
+    /**
+     * @method compile
+     * @brief  parses instruction parameters and prepares the
+     *         instruction for executing
+     * @param  params  list of parameters of this instruction
+     * @return -
+     * @globalvars none
+     * @exception  runtime_error
+     * @conditions none
+     */
     virtual void compile(std::list<std::string>& params) = 0;
 
-    /* TODO */
+    /**
+     * @method execute
+     * @brief  executes the instruction
+     * @param  cpu  pointer to cpu
+     * @return -
+     * @globalvars none
+     * @exception  runtime_error
+     * @conditions none
+     */
     virtual void execute(CCPU *cpu) = 0;
 
   protected:
diff --git a/ue3/mycpu/cprogram.cpp b/ue3/mycpu/cprogram.cpp
index 03d4c30..f6fc3cb 100644
--- a/ue3/mycpu/cprogram.cpp
+++ b/ue3/mycpu/cprogram.cpp
@@ -19,6 +19,19 @@ using namespace std;
 CProgram::CProgram()
 {
   m_instrset.insert(new CInstructionInc);
+  m_instrset.insert(new CInstructionDec);
+  m_instrset.insert(new CInstructionAdd);
+  m_instrset.insert(new CInstructionSub);
+  m_instrset.insert(new CInstructionMul);
+  m_instrset.insert(new CInstructionDiv);
+  m_instrset.insert(new CInstructionLoad);
+  m_instrset.insert(new CInstructionStore);
+  m_instrset.insert(new CInstructionTest);
+  m_instrset.insert(new CInstructionLabel);
+  m_instrset.insert(new CInstructionJumpA);
+  m_instrset.insert(new CInstructionJumpZ);
+  m_instrset.insert(new CInstructionJumpS);
+  m_instrset.insert(new CInstructionWrite);
 }
 
 /*----------------------------------------------------------------------------*/
@@ -54,6 +67,7 @@ void CProgram::compile(std::istream& in)
       continue;
 
     boost::trim(line);
+    boost::to_lower(line);
 
     /* ignore comments */
     if (line.find_first_of('#') == 0)
diff --git a/ue3/mycpu/displays.h b/ue3/mycpu/displays.h
new file mode 100644
index 0000000..f7adbdb
--- /dev/null
+++ b/ue3/mycpu/displays.h
@@ -0,0 +1,56 @@
+/**
+ * @module displays
+ * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
+ * @brief  TODO
+ * @date   10.05.2009
+ */
+
+#ifndef DISPLAYS_H
+#define DISPLAYS_H 1
+
+#include <iomanip>
+#include "cdisplay.h"
+
+/**
+ * @class CDisplayWDEZ
+ *
+ * TODO
+ */
+class CDisplayWDEZ
+  : public CDisplay
+{
+  public:
+    CDisplayWDEZ()
+      : CDisplay("wdez")
+    {}
+
+    void display(const CDat &value)
+    {
+      std::cout << std::dec << value << std::endl;
+    }
+};
+
+/*============================================================================*/
+
+/**
+ * @class CDisplayWHEX
+ *
+ * TODO
+ */
+class CDisplayWHEX
+  : public CDisplay
+{
+  public:
+    CDisplayWHEX()
+      : CDisplay("whex")
+    {}
+
+    void display(const CDat &value)
+    {
+      std::cout << std::hex << value << std::endl;
+    }
+};
+
+#endif
+
+/* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/instructions.cpp b/ue3/mycpu/instructions.cpp
index c283e57..609cd1c 100644
--- a/ue3/mycpu/instructions.cpp
+++ b/ue3/mycpu/instructions.cpp
@@ -14,6 +14,7 @@ void CInstructionInc::compile(std::list<std::string>& params)
   if (params.size() != 1)
     throw runtime_error("Invalid paramater count - must be 1");
   m_regidx1 = parseRegister(params.front());
+  params.pop_front();
 }
 
 /*----------------------------------------------------------------------------*/
@@ -21,7 +22,343 @@ void CInstructionInc::compile(std::list<std::string>& params)
 void CInstructionInc::execute(CCPU *cpu)
 {
   checkRegister(cpu, m_regidx1);
-  cpu->getRegisters()[m_regidx1]++;
+  cpu->getRegisters()[ m_regidx1 ]++;
 }
 
+/*============================================================================*/
+
+void CInstructionDec::compile(std::list<std::string>& params)
+{
+  if (params.size() != 1)
+    throw runtime_error("Invalid paramater count - must be 1");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionDec::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  cpu->getRegisters()[ m_regidx1 ]--;
+}
+
+/*============================================================================*/
+
+void CInstructionAdd::compile(std::list<std::string>& params)
+{
+  if (params.size() != 3)
+    throw runtime_error("Invalid paramater count - must be 3");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx2 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx3 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionAdd::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  checkRegister(cpu, m_regidx2);
+  checkRegister(cpu, m_regidx3);
+  cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+    + cpu->getRegisters()[ m_regidx3 ];
+}
+
+/*============================================================================*/
+
+void CInstructionSub::compile(std::list<std::string>& params)
+{
+  if (params.size() != 3)
+    throw runtime_error("Invalid paramater count - must be 3");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx2 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx3 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionSub::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  checkRegister(cpu, m_regidx2);
+  checkRegister(cpu, m_regidx3);
+  cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+    - cpu->getRegisters()[ m_regidx3 ];
+}
+
+/*============================================================================*/
+
+void CInstructionMul::compile(std::list<std::string>& params)
+{
+  if (params.size() != 3)
+    throw runtime_error("Invalid paramater count - must be 3");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx2 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx3 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionMul::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  checkRegister(cpu, m_regidx2);
+  checkRegister(cpu, m_regidx3);
+  cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+    * cpu->getRegisters()[ m_regidx3 ];
+}
+
+/*============================================================================*/
+
+void CInstructionDiv::compile(std::list<std::string>& params)
+{
+  if (params.size() != 3)
+    throw runtime_error("Invalid paramater count - must be 3");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx2 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx3 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionDiv::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  checkRegister(cpu, m_regidx2);
+  checkRegister(cpu, m_regidx3);
+  cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+    / cpu->getRegisters()[ m_regidx3 ];
+}
+
+/*============================================================================*/
+
+void CInstructionLoad::compile(std::list<std::string>& params)
+{
+  if (params.size() != 2)
+    throw runtime_error("Invalid paramater count - must be 2");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx2 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionLoad::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  checkRegister(cpu, m_regidx2);
+  CDat val = cpu->getRegisters()[ m_regidx2 ];
+  cpu->getRegisters()[ m_regidx1 ] = (*cpu->getMemory())[ val ];
+}
+
+/*============================================================================*/
+
+void CInstructionStore::compile(std::list<std::string>& params)
+{
+  if (params.size() != 2)
+    throw runtime_error("Invalid paramater count - must be 2");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+  m_regidx2 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionStore::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  checkRegister(cpu, m_regidx2);
+  CDat val = cpu->getRegisters()[ m_regidx2 ];
+  (*cpu->getMemory())[ val ] = cpu->getRegisters()[ m_regidx1 ];
+}
+
+/*============================================================================*/
+
+void CInstructionTest::compile(std::list<std::string>& params)
+{
+  if (params.size() != 1)
+    throw runtime_error("Invalid paramater count - must be 1");
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionTest::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  if (cpu->getRegisters()[ m_regidx1 ] == CDat(0))
+    cpu->setFlagZero(true);
+  if (cpu->getRegisters()[ m_regidx1 ] < CDat(0))
+    cpu->setFlagSign(true);
+}
+
+/*============================================================================*/
+
+void CInstructionLabel::compile(std::list<std::string>& params)
+{
+  if (params.size() != 1)
+    throw runtime_error("Invalid paramater count - must be 1");
+  string label = params.front();
+  params.pop_front();
+  if (label.length() < 2 || label[ label.length() - 1] != ':')
+    throw runtime_error("Label has invalid syntax");
+  m_label = label.substr(0, label.length() - 1);
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionLabel::execute(CCPU *cpu)
+{
+  if (m_label.empty())
+    throw runtime_error("Empty label");
+}
+
+/*============================================================================*/
+
+void CInstructionJumpA::compile(std::list<std::string>& params)
+{
+  if (params.size() != 1)
+    throw runtime_error("Invalid paramater count - must be 1");
+  m_addr = params.front();
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionJumpA::execute(CCPU *cpu)
+{
+  if (m_addr.empty())
+    throw runtime_error("Empty address");
+
+  const CProgram *progam = cpu->getProgram();
+  for(unsigned i = 0; i < progam->size(); i++)
+  {
+    if (progam->at(i)->isLabel() && progam->at(i)->getLabelName() == m_addr)
+    {
+      cpu->getRegisters()[ 0 ] = i;
+      return;
+    }
+  }
+
+  throw runtime_error("Unknown label '" + m_addr + "'");
+}
+
+/*============================================================================*/
+
+void CInstructionJumpZ::compile(std::list<std::string>& params)
+{
+  if (params.size() != 1)
+    throw runtime_error("Invalid paramater count - must be 1");
+  m_addr = params.front();
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionJumpZ::execute(CCPU *cpu)
+{
+  if (!cpu->getFlagZero())
+    return;
+  if (m_addr.empty())
+    throw runtime_error("Empty address");
+
+  const CProgram *progam = cpu->getProgram();
+  for(unsigned i = 0; i < progam->size(); i++)
+  {
+    if (progam->at(i)->isLabel() && progam->at(i)->getLabelName() == m_addr)
+    {
+      cpu->getRegisters()[ 0 ] = i;
+      return;
+    }
+  }
+
+  throw runtime_error("Unknown label '" + m_addr + "'");
+}
+
+/*============================================================================*/
+
+void CInstructionJumpS::compile(std::list<std::string>& params)
+{
+  if (params.size() != 1)
+    throw runtime_error("Invalid paramater count - must be 1");
+  m_addr = params.front();
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionJumpS::execute(CCPU *cpu)
+{
+  if (!cpu->getFlagSign())
+    return;
+  if (m_addr.empty())
+    throw runtime_error("Empty address");
+
+  const CProgram *progam = cpu->getProgram();
+  for(unsigned i = 0; i < progam->size(); i++)
+  {
+    if (progam->at(i)->isLabel() && progam->at(i)->getLabelName() == m_addr)
+    {
+      cpu->getRegisters()[ 0 ] = i;
+      return;
+    }
+  }
+
+  throw runtime_error("Unknown label '" + m_addr + "'");
+}
+
+/*============================================================================*/
+
+void CInstructionWrite::compile(std::list<std::string>& params)
+{
+  if (params.size() != 2)
+    throw runtime_error("Invalid paramater count - must be 2");
+  m_dev = params.front();
+  params.pop_front();
+  m_regidx1 = parseRegister(params.front());
+  params.pop_front();
+}
+
+/*----------------------------------------------------------------------------*/
+
+void CInstructionWrite::execute(CCPU *cpu)
+{
+  checkRegister(cpu, m_regidx1);
+  if (m_dev.empty())
+    throw runtime_error("Empty device");
+
+  CDisplay *display = NULL;
+  std::set<CDisplay *> displays = cpu->getDisplays();
+  std::set<CDisplay *>::iterator it;
+  for(it = displays.begin(); it != displays.end(); ++it)
+  {
+    if ((*it)->getName() == m_dev)
+    {
+      display = *it;
+      break;
+    }
+  }
+  if (display == NULL)
+    throw runtime_error("Unknown display");
+
+  display->display(cpu->getRegisters()[ m_regidx1 ]);
+}
+
+
 /* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/instructions.h b/ue3/mycpu/instructions.h
index ebd1533..8c62e0b 100644
--- a/ue3/mycpu/instructions.h
+++ b/ue3/mycpu/instructions.h
@@ -20,45 +20,392 @@ class CInstructionInc
  : public CInstruction
 {
   public:
-    /**
-     * @method CInstruction
-     * @brief  Default ctor
-     * @param  -
-     * @return -
-     * @globalvars none
-     * @exception  none
-     * @conditions none
-     */
     CInstructionInc()
       : CInstruction("inc")
-    {};
-
-    /**
-     * @method ~CInstruction
-     * @brief  Default dtor
-     * @param  -
-     * @return -
-     * @globalvars none
-     * @exception  none
-     * @conditions none
-     */
-    ~CInstructionInc()
-    {};
-
-    /* TODO */
+    {}
+
     CInstructionInc *factory()
     {
       return new CInstructionInc;
     }
 
-    /* TODO */
     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;
+};
 
-    /* TODO */
+/*============================================================================*/
+
+/**
+ * @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"), m_label("")
+    {}
+
+    const bool isLabel()
+    {
+      return true;
+    }
+
+    const std::string getLabelName()
+    {
+      return m_label;
+    }
+
+    CInstructionLabel *factory()
+    {
+      return new CInstructionLabel;
+    }
+
+    void compile(std::list<std::string>& params);
+    void execute(CCPU *cpu);
+
+  protected:
+    std::string m_label;
+};
+
+/*============================================================================*/
+
+/**
+ * @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
diff --git a/ue3/mycpu/mycpu.cpp b/ue3/mycpu/mycpu.cpp
index af91fe7..08861a4 100644
--- a/ue3/mycpu/mycpu.cpp
+++ b/ue3/mycpu/mycpu.cpp
@@ -19,13 +19,6 @@
 using namespace std;
 namespace po = boost::program_options;
 
-/** TODO */
-void myterminate()
-{
-  cerr << "Unexpected termination" << endl;
-  abort();
-}
-
 /**
  * @func   main
  * @brief  program entry point
@@ -40,7 +33,6 @@ void myterminate()
  */
 int main(int argc, char* argv[])
 {
-  //TODO set_terminate(myterminate);
   string me(argv[0]);
 
   /* define commandline options */
@@ -136,13 +128,17 @@ int main(int argc, char* argv[])
     cpu.setProgram(&program);
     cpu.run();
 #if DEBUG
-    cpu.dumpRegisters(cout);
+    //cpu.dumpRegisters(cout);
 #endif
   }
   catch(runtime_error& ex)
   {
     cerr << me << ": Error while executing program:" << endl
-        << "  " << ex.what() << endl;
+         << "  " << ex.what() << endl;
+#if DEBUG
+    memory.dump(cout);
+    //cpu.dumpRegisters(cout);
+#endif
     return 1;
   }
 
diff --git a/ue3/mycpu/test/memory1 b/ue3/mycpu/test/memory1
new file mode 100644
index 0000000..209e3ef
--- /dev/null
+++ b/ue3/mycpu/test/memory1
@@ -0,0 +1 @@
+20
diff --git a/ue3/mycpu/test/program1 b/ue3/mycpu/test/program1
new file mode 100644
index 0000000..ae5e9d2
--- /dev/null
+++ b/ue3/mycpu/test/program1
@@ -0,0 +1,13 @@
+# set R2 = 10
+LOAD R2, R1
+
+# start of loop
+label Loop:
+inc R3
+sub R4, R3, R2
+test R4
+jumpz EndLoop
+write WDEZ, R3
+jumpa Loop
+
+label EndLoop:
-- 
cgit v1.2.3


From 431bbac5a99abbccf33500e22aa353ec792eff94 Mon Sep 17 00:00:00 2001
From: manuel <manuel@clan-server.at>
Date: Wed, 13 May 2009 15:29:51 +0200
Subject: * adding -Wno-long-long to all Makefiles * adding execute operator to
 cinstruction * added labels map for better performance

---
 ue1/imgsynth/Makefile      |  2 +-
 ue2/imgsynth2/Makefile     |  2 +-
 ue3/mycpu/ccpu.cpp         |  2 +-
 ue3/mycpu/ccpu.h           |  2 +-
 ue3/mycpu/cinstruction.h   | 47 ++++++++++++---------------------
 ue3/mycpu/cprogram.cpp     | 21 +++++++++++++++
 ue3/mycpu/cprogram.h       | 27 +++++++++++++++++++
 ue3/mycpu/instructions.cpp | 65 +++-------------------------------------------
 ue3/mycpu/instructions.h   | 20 ++++----------
 9 files changed, 78 insertions(+), 110 deletions(-)

diff --git a/ue1/imgsynth/Makefile b/ue1/imgsynth/Makefile
index 6b52d60..71f57d7 100644
--- a/ue1/imgsynth/Makefile
+++ b/ue1/imgsynth/Makefile
@@ -5,7 +5,7 @@
 CC=		g++
 LD=		$(CC)
 DEBUGFLAGS=
-CFLAGS=		-O -ansi -pedantic-errors -Wall $(DEBUGFLAGS)
+CFLAGS=		-O -ansi -pedantic-errors -Wall -Wno-long-long $(DEBUGFLAGS)
 LDFLAGS=
 LIBS=		-lboost_program_options
 
diff --git a/ue2/imgsynth2/Makefile b/ue2/imgsynth2/Makefile
index 481230c..932ae97 100644
--- a/ue2/imgsynth2/Makefile
+++ b/ue2/imgsynth2/Makefile
@@ -6,7 +6,7 @@ CXX=		g++
 LD=		$(CXX)
 DEBUGFLAGS=	-DNDEBUG
 INCLUDE_PATH=	-I/usr/local/include
-CXXFLAGS=	-O -ansi -pedantic-errors -Wall $(INCLUDE_PATH) $(DEBUGFLAGS)
+CXXFLAGS=	-O -ansi -pedantic-errors -Wall -Wno-long-long $(INCLUDE_PATH) $(DEBUGFLAGS)
 LDFLAGS=
 LIBS=		-L/usr/local/lib -lboost_program_options
 
diff --git a/ue3/mycpu/ccpu.cpp b/ue3/mycpu/ccpu.cpp
index b1539a4..16209e2 100644
--- a/ue3/mycpu/ccpu.cpp
+++ b/ue3/mycpu/ccpu.cpp
@@ -66,7 +66,7 @@ void CCPU::run()
       throw runtime_error("Programcounter is out of bound");
 
     /* execute instruction */
-    m_program->at(pc)->execute(this);
+    (*m_program->at(pc))(this);
     ++m_registers[0];
   }
 }
diff --git a/ue3/mycpu/ccpu.h b/ue3/mycpu/ccpu.h
index 1ef1923..01c897f 100644
--- a/ue3/mycpu/ccpu.h
+++ b/ue3/mycpu/ccpu.h
@@ -205,7 +205,7 @@ class CCPU
      * @param  -
      * @return -
      * @globalvars none
-     * @exception  runtime_error
+     * @exception  std::runtime_error
      * @conditions none
      */
     void run();
diff --git a/ue3/mycpu/cinstruction.h b/ue3/mycpu/cinstruction.h
index 57fcff1..40e9ddc 100644
--- a/ue3/mycpu/cinstruction.h
+++ b/ue3/mycpu/cinstruction.h
@@ -62,45 +62,32 @@ class CInstruction
     }
 
     /**
-     * @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 isLabel
-     * @brief  returns true if the instruction defines a label
-     * @param  -
-     * @return true if the instruction defines a label
+     * @method operator()
+     * @brief  implementation of operator (CCPU)
+     * @param  cpu  pointer to cpu
+     * @return -
      * @globalvars none
-     * @exception  none
+     * @exception  std::runtime_error
      * @conditions none
      */
-    virtual const bool isLabel()
+    virtual CInstruction& operator()(CCPU *cpu)
     {
-      return false;
+      execute(cpu);
+      return *this;
     }
 
     /**
-     * @method getLabelName
-     * @brief  returns labelname if the instruction defines a label
+     * @method getName
+     * @brief  returns instruction name
      * @param  -
-     * @return labelname if the instruction defines a label
+     * @return name of instruction
      * @globalvars none
      * @exception  none
      * @conditions none
      */
-    virtual const std::string getLabelName()
+    virtual const std::string& getName()
     {
-      return "";
+      return m_name;
     }
 
     /**
@@ -139,7 +126,7 @@ class CInstruction
      * @param  str  register in assembler syntax
      * @return registernumber
      * @globalvars none
-     * @exception  runtime_error
+     * @exception  std::runtime_error
      * @conditions none
      */
     virtual const unsigned parseRegister(const std::string& str);
@@ -152,7 +139,7 @@ class CInstruction
      * @param  regidx  registernumber
      * @return -
      * @globalvars none
-     * @exception  runtime_error
+     * @exception  std::runtime_error
      * @conditions none
      */
     virtual void checkRegister(CCPU *cpu, const unsigned regidx);
@@ -175,7 +162,7 @@ class CInstruction
      * @param  params  list of parameters of this instruction
      * @return -
      * @globalvars none
-     * @exception  runtime_error
+     * @exception  std::runtime_error
      * @conditions none
      */
     virtual void compile(std::list<std::string>& params) = 0;
@@ -186,7 +173,7 @@ class CInstruction
      * @param  cpu  pointer to cpu
      * @return -
      * @globalvars none
-     * @exception  runtime_error
+     * @exception  std::runtime_error
      * @conditions none
      */
     virtual void execute(CCPU *cpu) = 0;
diff --git a/ue3/mycpu/cprogram.cpp b/ue3/mycpu/cprogram.cpp
index f6fc3cb..f904bce 100644
--- a/ue3/mycpu/cprogram.cpp
+++ b/ue3/mycpu/cprogram.cpp
@@ -107,6 +107,16 @@ void CProgram::compile(std::istream& in)
     /* let instruction parse the parameters. catch+throw exception */
     try
     {
+      /* handle label instruction ourself, but still add a dummy instruction */
+      if (instrname == "label")
+      {
+        if (instrparams.size() != 1)
+          throw runtime_error("Invalid paramater count - must be 1");
+        string label = instrparams.front();
+        if (label.length() < 2 || label[ label.length() - 1] != ':')
+          throw runtime_error("Label has invalid syntax");
+        m_labels[ label.substr(0, label.length() - 1) ] = size();
+      }
       instr->compile(instrparams);
     }
     catch(runtime_error& ex)
@@ -123,6 +133,17 @@ void CProgram::compile(std::istream& in)
 
 /*----------------------------------------------------------------------------*/
 
+unsigned CProgram::findLabel(const std::string& label) const
+{
+  map<string, unsigned>::const_iterator it;
+  it = m_labels.find(label);
+  if (it == m_labels.end())
+    throw runtime_error("Unknown label '" + label + "'");
+  return it->second;
+}
+
+/*----------------------------------------------------------------------------*/
+
 #if DEBUG
 void CProgram::dump(std::ostream& out)
 {
diff --git a/ue3/mycpu/cprogram.h b/ue3/mycpu/cprogram.h
index bf161b8..c145832 100644
--- a/ue3/mycpu/cprogram.h
+++ b/ue3/mycpu/cprogram.h
@@ -10,6 +10,7 @@
 
 #include <vector>
 #include <set>
+#include <map>
 #include "cinstruction.h"
 
 /**
@@ -43,6 +44,31 @@ class CProgram
      */
     ~CProgram();
 
+    /**
+     * @method getLabels
+     * @brief  get reference to labels map
+     * @param  -
+     * @return reference to labels map
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
+    const std::map<std::string, unsigned>& getLabels() const
+    {
+      return m_labels;
+    }
+
+    /**
+     * @method findLabel
+     * @brief  search for label
+     * @param  label  name of label to search for
+     * @return index of found label in program
+     * @globalvars none
+     * @exception  std::runtime_error
+     * @conditions none
+     */
+    unsigned findLabel(const std::string& label) const;
+
     /**
      * @method compile
      * @brief  create instructions from parsing stream
@@ -71,6 +97,7 @@ class CProgram
     /* members */
     /** set of known instructions */
     std::set<CInstruction *> m_instrset;
+    std::map<std::string, unsigned> m_labels;
 };
 
 #endif
diff --git a/ue3/mycpu/instructions.cpp b/ue3/mycpu/instructions.cpp
index 609cd1c..a6ac611 100644
--- a/ue3/mycpu/instructions.cpp
+++ b/ue3/mycpu/instructions.cpp
@@ -5,6 +5,7 @@
  * @date   10.05.2009
  */
 
+#include <map>
 #include "instructions.h"
 
 using namespace std;
@@ -210,27 +211,6 @@ void CInstructionTest::execute(CCPU *cpu)
 
 /*============================================================================*/
 
-void CInstructionLabel::compile(std::list<std::string>& params)
-{
-  if (params.size() != 1)
-    throw runtime_error("Invalid paramater count - must be 1");
-  string label = params.front();
-  params.pop_front();
-  if (label.length() < 2 || label[ label.length() - 1] != ':')
-    throw runtime_error("Label has invalid syntax");
-  m_label = label.substr(0, label.length() - 1);
-}
-
-/*----------------------------------------------------------------------------*/
-
-void CInstructionLabel::execute(CCPU *cpu)
-{
-  if (m_label.empty())
-    throw runtime_error("Empty label");
-}
-
-/*============================================================================*/
-
 void CInstructionJumpA::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -245,18 +225,7 @@ void CInstructionJumpA::execute(CCPU *cpu)
 {
   if (m_addr.empty())
     throw runtime_error("Empty address");
-
-  const CProgram *progam = cpu->getProgram();
-  for(unsigned i = 0; i < progam->size(); i++)
-  {
-    if (progam->at(i)->isLabel() && progam->at(i)->getLabelName() == m_addr)
-    {
-      cpu->getRegisters()[ 0 ] = i;
-      return;
-    }
-  }
-
-  throw runtime_error("Unknown label '" + m_addr + "'");
+  cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
 }
 
 /*============================================================================*/
@@ -275,20 +244,7 @@ void CInstructionJumpZ::execute(CCPU *cpu)
 {
   if (!cpu->getFlagZero())
     return;
-  if (m_addr.empty())
-    throw runtime_error("Empty address");
-
-  const CProgram *progam = cpu->getProgram();
-  for(unsigned i = 0; i < progam->size(); i++)
-  {
-    if (progam->at(i)->isLabel() && progam->at(i)->getLabelName() == m_addr)
-    {
-      cpu->getRegisters()[ 0 ] = i;
-      return;
-    }
-  }
-
-  throw runtime_error("Unknown label '" + m_addr + "'");
+  cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
 }
 
 /*============================================================================*/
@@ -307,20 +263,7 @@ void CInstructionJumpS::execute(CCPU *cpu)
 {
   if (!cpu->getFlagSign())
     return;
-  if (m_addr.empty())
-    throw runtime_error("Empty address");
-
-  const CProgram *progam = cpu->getProgram();
-  for(unsigned i = 0; i < progam->size(); i++)
-  {
-    if (progam->at(i)->isLabel() && progam->at(i)->getLabelName() == m_addr)
-    {
-      cpu->getRegisters()[ 0 ] = i;
-      return;
-    }
-  }
-
-  throw runtime_error("Unknown label '" + m_addr + "'");
+  cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
 }
 
 /*============================================================================*/
diff --git a/ue3/mycpu/instructions.h b/ue3/mycpu/instructions.h
index 8c62e0b..0e4d99c 100644
--- a/ue3/mycpu/instructions.h
+++ b/ue3/mycpu/instructions.h
@@ -274,29 +274,19 @@ class CInstructionLabel
 {
   public:
     CInstructionLabel()
-      : CInstruction("label"), m_label("")
+      : CInstruction("label")
     {}
 
-    const bool isLabel()
-    {
-      return true;
-    }
-
-    const std::string getLabelName()
-    {
-      return m_label;
-    }
-
     CInstructionLabel *factory()
     {
       return new CInstructionLabel;
     }
 
-    void compile(std::list<std::string>& params);
-    void execute(CCPU *cpu);
+    void compile(std::list<std::string>& params)
+    {}
 
-  protected:
-    std::string m_label;
+    void execute(CCPU *cpu)
+    {}
 };
 
 /*============================================================================*/
-- 
cgit v1.2.3


From 3c6f886d5a8bfd36c796b963d6e3178ad9577742 Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Wed, 13 May 2009 16:55:17 +0200
Subject: * added documentation (no more TODOs) * added testsuite + testcase *
 used copyctor instead of assign operator more often

---
 .hgignore                    |  1 +
 ue3/mycpu/ccpu.cpp           |  3 ++-
 ue3/mycpu/ccpu.h             |  6 +++--
 ue3/mycpu/cdisplay.h         |  9 ++++---
 ue3/mycpu/cinstruction.cpp   |  4 ++--
 ue3/mycpu/cinstruction.h     |  6 ++---
 ue3/mycpu/cprogram.cpp       |  6 ++---
 ue3/mycpu/cprogram.h         |  5 ++--
 ue3/mycpu/displays.h         |  8 ++++---
 ue3/mycpu/instructions.cpp   |  6 ++---
 ue3/mycpu/instructions.h     | 57 ++++++++++++++++++++++++++++++++------------
 ue3/mycpu/mycpu.cpp          | 25 ++++++++++++-------
 ue3/mycpu/test/test.sh       | 40 +++++++++++++++++++++++++++++++
 ue3/mycpu/test/test1_memory  |  1 +
 ue3/mycpu/test/test1_output  | 19 +++++++++++++++
 ue3/mycpu/test/test1_program | 13 ++++++++++
 16 files changed, 161 insertions(+), 48 deletions(-)
 create mode 100755 ue3/mycpu/test/test.sh
 create mode 100644 ue3/mycpu/test/test1_memory
 create mode 100644 ue3/mycpu/test/test1_output
 create mode 100644 ue3/mycpu/test/test1_program

diff --git a/.hgignore b/.hgignore
index 2dd5fef..b96a5d0 100644
--- a/.hgignore
+++ b/.hgignore
@@ -5,6 +5,7 @@ syntax: glob
 *.so
 *.swp
 *~
+tmpfile
 ue1/imgsynth/imgsynth
 ue2/imgsynth/test/*_out*
 ue2/imgsynth2/imgsynth2
diff --git a/ue3/mycpu/ccpu.cpp b/ue3/mycpu/ccpu.cpp
index 16209e2..af86200 100644
--- a/ue3/mycpu/ccpu.cpp
+++ b/ue3/mycpu/ccpu.cpp
@@ -1,7 +1,8 @@
 /**
  * @module ccpu
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  CPU implementation. Used as a container for memory and instructions.
+ *         Implements an run method to execute the program (= the instructions).
  * @date   10.05.2009
  */
 
diff --git a/ue3/mycpu/ccpu.h b/ue3/mycpu/ccpu.h
index 01c897f..05b5c03 100644
--- a/ue3/mycpu/ccpu.h
+++ b/ue3/mycpu/ccpu.h
@@ -1,7 +1,8 @@
 /**
  * @module ccpu
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  CPU implementation. Used as a container for memory and instructions.
+ *         Implements a run method to execute the program (= the instructions).
  * @date   10.05.2009
  */
 
@@ -18,7 +19,8 @@
 /**
  * @class CCPU
  *
- * TODO
+ * CPU implementation. Used as a container for memory and instructions.
+ * Implements a run method to execute the program (= the instructions).
  */
 class CCPU
 {
diff --git a/ue3/mycpu/cdisplay.h b/ue3/mycpu/cdisplay.h
index ed9b84d..c2a84a6 100644
--- a/ue3/mycpu/cdisplay.h
+++ b/ue3/mycpu/cdisplay.h
@@ -1,7 +1,7 @@
 /**
  * @module cdisplay
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  Abstract class for displays
  * @date   10.05.2009
  */
 
@@ -11,7 +11,7 @@
 /**
  * @class CDisplay
  *
- * TODO
+ * Abstract class for displays
  */
 class CDisplay
 {
@@ -26,9 +26,8 @@ class CDisplay
      * @conditions none
      */
     CDisplay(std::string name)
-    {
-      m_name = name;
-    }
+      : m_name(name)
+    {}
 
     /**
      * @method ~CDisplay
diff --git a/ue3/mycpu/cinstruction.cpp b/ue3/mycpu/cinstruction.cpp
index 57acd5f..5c1bd5c 100644
--- a/ue3/mycpu/cinstruction.cpp
+++ b/ue3/mycpu/cinstruction.cpp
@@ -1,8 +1,8 @@
 /**
  * @module cinstruction
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
- * @date   10.05.2009
+ * @brief  Abstract class for displays
+ * @date   13.05.2009
  */
 
 #include <sstream>
diff --git a/ue3/mycpu/cinstruction.h b/ue3/mycpu/cinstruction.h
index 40e9ddc..942d8cf 100644
--- a/ue3/mycpu/cinstruction.h
+++ b/ue3/mycpu/cinstruction.h
@@ -1,8 +1,8 @@
 /**
  * @module cinstruction
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
- * @date   10.05.2009
+ * @brief  Abstract class for displays
+ * @date   13.05.2009
  */
 
 #ifndef CINSTRUCTION_H
@@ -17,7 +17,7 @@ class CCPU;
 /**
  * @class CInstruction
  *
- * TODO
+ * Abstract class for displays
  */
 class CInstruction
 {
diff --git a/ue3/mycpu/cprogram.cpp b/ue3/mycpu/cprogram.cpp
index f904bce..1a450f5 100644
--- a/ue3/mycpu/cprogram.cpp
+++ b/ue3/mycpu/cprogram.cpp
@@ -1,7 +1,7 @@
 /**
  * @module cprogram
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  CProgram extends std::vector and adds a method for parsing programfile
  * @date   12.05.2009
  */
 
@@ -75,7 +75,7 @@ void CProgram::compile(std::istream& in)
 
     /* get instruction name */
     size_t pos = line.find_first_of(' ');
-    string instrname = line.substr(0, pos);
+    string instrname(line.substr(0, pos));
 
     /* search and create instruction */
     CInstruction *instrptr = NULL;
@@ -112,7 +112,7 @@ void CProgram::compile(std::istream& in)
       {
         if (instrparams.size() != 1)
           throw runtime_error("Invalid paramater count - must be 1");
-        string label = instrparams.front();
+        string label(instrparams.front());
         if (label.length() < 2 || label[ label.length() - 1] != ':')
           throw runtime_error("Label has invalid syntax");
         m_labels[ label.substr(0, label.length() - 1) ] = size();
diff --git a/ue3/mycpu/cprogram.h b/ue3/mycpu/cprogram.h
index c145832..27e7647 100644
--- a/ue3/mycpu/cprogram.h
+++ b/ue3/mycpu/cprogram.h
@@ -1,7 +1,7 @@
 /**
  * @module cprogram
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  CProgram extends std::vector and adds a method for parsing programfile
  * @date   10.05.2009
  */
 
@@ -16,7 +16,8 @@
 /**
  * @class CProgram
  *
- * TODO
+ * CProgram extends std::vector and adds a method for parsing
+ * programfile. This adds instances of CInstruction to CProgram itself.
  */
 class CProgram
   : public std::vector<CInstruction *>
diff --git a/ue3/mycpu/displays.h b/ue3/mycpu/displays.h
index f7adbdb..87b9408 100644
--- a/ue3/mycpu/displays.h
+++ b/ue3/mycpu/displays.h
@@ -1,7 +1,7 @@
 /**
  * @module displays
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  Implementations of CDisplay
  * @date   10.05.2009
  */
 
@@ -14,7 +14,8 @@
 /**
  * @class CDisplayWDEZ
  *
- * TODO
+ * Implementation of CDisplay
+ * Prints CDat to stdout as decimal
  */
 class CDisplayWDEZ
   : public CDisplay
@@ -35,7 +36,8 @@ class CDisplayWDEZ
 /**
  * @class CDisplayWHEX
  *
- * TODO
+ * Implementation of CDisplay
+ * Prints CDat to stdout as decimal
  */
 class CDisplayWHEX
   : public CDisplay
diff --git a/ue3/mycpu/instructions.cpp b/ue3/mycpu/instructions.cpp
index a6ac611..c2ce096 100644
--- a/ue3/mycpu/instructions.cpp
+++ b/ue3/mycpu/instructions.cpp
@@ -1,7 +1,7 @@
 /**
  * @module instructions
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  Implementations of CInstruction
  * @date   10.05.2009
  */
 
@@ -162,7 +162,7 @@ void CInstructionLoad::execute(CCPU *cpu)
 {
   checkRegister(cpu, m_regidx1);
   checkRegister(cpu, m_regidx2);
-  CDat val = cpu->getRegisters()[ m_regidx2 ];
+  CDat val(cpu->getRegisters()[ m_regidx2 ]);
   cpu->getRegisters()[ m_regidx1 ] = (*cpu->getMemory())[ val ];
 }
 
@@ -184,7 +184,7 @@ void CInstructionStore::execute(CCPU *cpu)
 {
   checkRegister(cpu, m_regidx1);
   checkRegister(cpu, m_regidx2);
-  CDat val = cpu->getRegisters()[ m_regidx2 ];
+  CDat val(cpu->getRegisters()[ m_regidx2 ]);
   (*cpu->getMemory())[ val ] = cpu->getRegisters()[ m_regidx1 ];
 }
 
diff --git a/ue3/mycpu/instructions.h b/ue3/mycpu/instructions.h
index 0e4d99c..a52b991 100644
--- a/ue3/mycpu/instructions.h
+++ b/ue3/mycpu/instructions.h
@@ -1,7 +1,7 @@
 /**
  * @module instructions
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
+ * @brief  Implementations of CInstruction
  * @date   10.05.2009
  */
 
@@ -14,7 +14,9 @@
 /**
  * @class CInstructionInc
  *
- * TODO
+ * Implementation of assembler command "inc"
+ * Syntax: inc R1
+ *   (R1++)
  */
 class CInstructionInc
  : public CInstruction
@@ -41,7 +43,9 @@ class CInstructionInc
 /**
  * @class CInstructionDec
  *
- * TODO
+ * Implementation of assembler command "dec"
+ * Syntax: dec R1
+ *   (R1--)
  */
 class CInstructionDec
  : public CInstruction
@@ -68,7 +72,9 @@ class CInstructionDec
 /**
  * @class CInstructionAdd
  *
- * TODO
+ * Implementation of assembler command "add"
+ * Syntax: add R1, R2, R3
+ *   (R1 = R2 + R3)
  */
 class CInstructionAdd
  : public CInstruction
@@ -97,7 +103,9 @@ class CInstructionAdd
 /**
  * @class CInstructionSub
  *
- * TODO
+ * Implementation of assembler command "sub"
+ * Syntax: sub R1, R2, R3
+ *   (R1 = R2 - R3)
  */
 class CInstructionSub
  : public CInstruction
@@ -126,7 +134,9 @@ class CInstructionSub
 /**
  * @class CInstructionMul
  *
- * TODO
+ * Implementation of assembler command "mul"
+ * Syntax: mul R1, R2, R3
+ *   (R1 = R2 * R3)
  */
 class CInstructionMul
  : public CInstruction
@@ -155,7 +165,9 @@ class CInstructionMul
 /**
  * @class CInstructionDiv
  *
- * TODO
+ * Implementation of assembler command "div"
+ * Syntax: div R1, R2, R3
+ *   (R1 = R2 / R3)
  */
 class CInstructionDiv
  : public CInstruction
@@ -184,7 +196,9 @@ class CInstructionDiv
 /**
  * @class CInstructionLoad
  *
- * TODO
+ * Implementation of assembler command "load"
+ * Syntax: load R1, R2
+ *   (R1 = memory[R2])
  */
 class CInstructionLoad
  : public CInstruction
@@ -212,7 +226,9 @@ class CInstructionLoad
 /**
  * @class CInstructionStore
  *
- * TODO
+ * Implementation of assembler command "store"
+ * Syntax: store R1, R2
+ *   (memory[R2] = R1)
  */
 class CInstructionStore
  : public CInstruction
@@ -240,7 +256,9 @@ class CInstructionStore
 /**
  * @class CInstructionTest
  *
- * TODO
+ * Implementation of assembler command "test"
+ * Syntax: test R1
+ *   (R1 == 0: zeroflag: true, R1 < 0: signflag: true)
  */
 class CInstructionTest
  : public CInstruction
@@ -267,7 +285,8 @@ class CInstructionTest
 /**
  * @class CInstructionLabel
  *
- * TODO
+ * Implementation of assembler command "label"
+ * Syntax: label name:
  */
 class CInstructionLabel
  : public CInstruction
@@ -294,7 +313,9 @@ class CInstructionLabel
 /**
  * @class CInstructionJumpA
  *
- * TODO
+ * Implementation of assembler command "jumpa"
+ * Syntax: jumpa labelname
+ *   (jump to labelname)
  */
 class CInstructionJumpA
  : public CInstruction
@@ -321,7 +342,9 @@ class CInstructionJumpA
 /**
  * @class CInstructionJumpZ
  *
- * TODO
+ * Implementation of assembler command "jumpz"
+ * Syntax: jumpz labelname
+ *   (jump to labelname if zeroflag)
  */
 class CInstructionJumpZ
  : public CInstruction
@@ -348,7 +371,9 @@ class CInstructionJumpZ
 /**
  * @class CInstructionJumpS
  *
- * TODO
+ * Implementation of assembler command "jumps"
+ * Syntax: jumps labelname
+ *   (jump to labelname if signflag)
  */
 class CInstructionJumpS
  : public CInstruction
@@ -375,7 +400,9 @@ class CInstructionJumpS
 /**
  * @class CInstructionWrite
  *
- * TODO
+ * Implementation of assembler command "write"
+ * Syntax: write DEV, R1
+ *   (write R1 to DEV, which is a name of a display)
  */
 class CInstructionWrite
  : public CInstruction
diff --git a/ue3/mycpu/mycpu.cpp b/ue3/mycpu/mycpu.cpp
index 08861a4..b25e721 100644
--- a/ue3/mycpu/mycpu.cpp
+++ b/ue3/mycpu/mycpu.cpp
@@ -1,10 +1,14 @@
 /**
  * @module mycpu
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  TODO
- * @date   11.05.2009
+ * @brief  mycpu executes a programfile (in simple assembler) by parsing the
+ *         programfile first. This creates a vector of instructions, which will
+ *         be executed in linear order (except jumps) afterwards. In order to
+ *         initialize the memory of the cpu before execution an optional
+ *         memoryfile can be passed as commandline option.
+ * @date   13.05.2009
  * @par Exercise
- *      3
+ *      4
  */
 
 #include <boost/program_options.hpp>
@@ -29,7 +33,11 @@ namespace po = boost::program_options;
  * @exception  none
  * @conditions none
  *
- * TODO
+ * parse commandline options, create and initialize memory,
+ * create cprogram instance, which parses the programfile and
+ * execute CCPU::run()
+ * On error print error message to stderr.
+ * Unknown commandline options will print a usage message.
  */
 int main(int argc, char* argv[])
 {
@@ -88,7 +96,7 @@ int main(int argc, char* argv[])
     }
 
 #if DEBUG
-    memory.dump(cout);
+    memory.dump(cerr);
 #endif
   }
 
@@ -116,7 +124,7 @@ int main(int argc, char* argv[])
   }
 
 #if DEBUG
-  program.dump(cout);
+  program.dump(cerr);
 #endif
 
 
@@ -128,7 +136,7 @@ int main(int argc, char* argv[])
     cpu.setProgram(&program);
     cpu.run();
 #if DEBUG
-    //cpu.dumpRegisters(cout);
+    //cpu.dumpRegisters(cerr);
 #endif
   }
   catch(runtime_error& ex)
@@ -136,8 +144,7 @@ int main(int argc, char* argv[])
     cerr << me << ": Error while executing program:" << endl
          << "  " << ex.what() << endl;
 #if DEBUG
-    memory.dump(cout);
-    //cpu.dumpRegisters(cout);
+    memory.dump(cerr);
 #endif
     return 1;
   }
diff --git a/ue3/mycpu/test/test.sh b/ue3/mycpu/test/test.sh
new file mode 100755
index 0000000..ad2ae4d
--- /dev/null
+++ b/ue3/mycpu/test/test.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+binary="./mycpu"
+tmpfile="test/tmpfile"
+inputs=( $(ls test/* | grep _program | sort -n) )
+
+for input in ${inputs[@]}
+do
+  echo "Testing $input ..."
+
+  programfile="$input"
+  args="-c $programfile"
+  memoryfile="${input/_program/_memory}"
+  reffile="${input/_program/_output}"
+  if [ -e "$memoryfile" ]
+  then
+    args+=" -m $memoryfile"
+  fi
+
+  if [ ! -e "$reffile" ]
+  then
+    echo "  ERROR: reference file $reffile doesn't exist"
+    exit 1
+  fi
+
+  rm -rf "$tmpfile"
+  echo "  Executing $binary $args ..."
+  $binary $args > $tmpfile
+
+  md5_1=$(md5sum < "$reffile")
+  md5_2=$(md5sum < "$tmpfile")
+  if [ "$md5_1" != "$md5_2" ]
+  then
+    echo "  ERROR: output and $reffile differ"
+    diff -Nau $reffile $tmpfile
+    exit 1
+  else
+    echo "  SUCCESS"
+  fi
+done
diff --git a/ue3/mycpu/test/test1_memory b/ue3/mycpu/test/test1_memory
new file mode 100644
index 0000000..209e3ef
--- /dev/null
+++ b/ue3/mycpu/test/test1_memory
@@ -0,0 +1 @@
+20
diff --git a/ue3/mycpu/test/test1_output b/ue3/mycpu/test/test1_output
new file mode 100644
index 0000000..ac30dc2
--- /dev/null
+++ b/ue3/mycpu/test/test1_output
@@ -0,0 +1,19 @@
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
diff --git a/ue3/mycpu/test/test1_program b/ue3/mycpu/test/test1_program
new file mode 100644
index 0000000..ae5e9d2
--- /dev/null
+++ b/ue3/mycpu/test/test1_program
@@ -0,0 +1,13 @@
+# set R2 = 10
+LOAD R2, R1
+
+# start of loop
+label Loop:
+inc R3
+sub R4, R3, R2
+test R4
+jumpz EndLoop
+write WDEZ, R3
+jumpa Loop
+
+label EndLoop:
-- 
cgit v1.2.3


From 67e99a217bd88a289d997b73f3e7cae6019bc22f Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Wed, 13 May 2009 17:01:15 +0200
Subject: fixing doxygen documentation

---
 ue3/mycpu/ccpu.h         |  2 +-
 ue3/mycpu/cdat.h         | 20 ++++++++++----------
 ue3/mycpu/cdisplay.h     |  1 +
 ue3/mycpu/cinstruction.h |  5 +++--
 ue3/mycpu/instructions.h | 24 ++++++++++++++++++++++++
 5 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/ue3/mycpu/ccpu.h b/ue3/mycpu/ccpu.h
index 05b5c03..6849623 100644
--- a/ue3/mycpu/ccpu.h
+++ b/ue3/mycpu/ccpu.h
@@ -106,7 +106,7 @@ class CCPU
     /**
      * @method setProgram
      * @brief  set program to execute
-     * @param  memory  pointer to program
+     * @param  program  pointer to program
      * @return -
      * @globalvars none
      * @exception  none
diff --git a/ue3/mycpu/cdat.h b/ue3/mycpu/cdat.h
index c656b99..a533fae 100644
--- a/ue3/mycpu/cdat.h
+++ b/ue3/mycpu/cdat.h
@@ -102,7 +102,7 @@ class CDatT
     /**
      * @method operator<
      * @brief  implementation of operator <
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return true if cdat is less than object x
      * @globalvars none
      * @exception  none
@@ -116,7 +116,7 @@ class CDatT
     /**
      * @method operator==
      * @brief  implementation of operator ==
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return true if cdat equals object x
      * @globalvars none
      * @exception  none
@@ -130,7 +130,7 @@ class CDatT
     /**
      * @method operator+=
      * @brief  implementation of operator +=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
@@ -145,7 +145,7 @@ class CDatT
     /**
      * @method operator-=
      * @brief  implementation of operator -=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
@@ -160,7 +160,7 @@ class CDatT
     /**
      * @method operator*=
      * @brief  implementation of operator *=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
@@ -175,7 +175,7 @@ class CDatT
     /**
      * @method operator/=
      * @brief  implementation of operator /=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
@@ -190,7 +190,7 @@ class CDatT
     /**
      * @method operator%=
      * @brief  implementation of operator %=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
@@ -205,7 +205,7 @@ class CDatT
     /**
      * @method operator|=
      * @brief  implementation of operator |=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
@@ -220,7 +220,7 @@ class CDatT
     /**
      * @method operator&=
      * @brief  implementation of operator &=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
@@ -235,7 +235,7 @@ class CDatT
     /**
      * @method operator^=
      * @brief  implementation of operator ^=
-     * @param  reference to CDatT
+     * @param  x  reference to CDatT
      * @return refecence to CDatT
      * @globalvars none
      * @exception  none
diff --git a/ue3/mycpu/cdisplay.h b/ue3/mycpu/cdisplay.h
index c2a84a6..0a0a723 100644
--- a/ue3/mycpu/cdisplay.h
+++ b/ue3/mycpu/cdisplay.h
@@ -68,6 +68,7 @@ class CDisplay
 
   protected:
     /* members */
+    /** name of display */
     std::string m_name;
 };
 
diff --git a/ue3/mycpu/cinstruction.h b/ue3/mycpu/cinstruction.h
index 942d8cf..4cc69de 100644
--- a/ue3/mycpu/cinstruction.h
+++ b/ue3/mycpu/cinstruction.h
@@ -50,7 +50,7 @@ class CInstruction
     /**
      * @method operator==
      * @brief  implementation of operator ==
-     * @param  reference to std::string
+     * @param  name reference to std::string
      * @return true if instructionname is name
      * @globalvars none
      * @exception  none
@@ -109,7 +109,7 @@ class CInstruction
      * @method operator<<
      * @brief  Shift/output operator for outputstream
      * @param  stream  reference to outputstream
-     * @param  cdat    object which will be printed to stream
+     * @param  instr   object which will be printed to stream
      * @return reference to outputstream
      * @globalvars none
      * @exception  none
@@ -180,6 +180,7 @@ class CInstruction
 
   protected:
     /* members */
+    /** name of instruction */
     std::string m_name;
 };
 
diff --git a/ue3/mycpu/instructions.h b/ue3/mycpu/instructions.h
index a52b991..4c36562 100644
--- a/ue3/mycpu/instructions.h
+++ b/ue3/mycpu/instructions.h
@@ -35,6 +35,7 @@ class CInstructionInc
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
 };
 
@@ -64,6 +65,7 @@ class CInstructionDec
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
 };
 
@@ -93,8 +95,11 @@ class CInstructionAdd
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
+    /** register number */
     unsigned m_regidx2;
+    /** register number */
     unsigned m_regidx3;
 };
 
@@ -124,8 +129,11 @@ class CInstructionSub
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
+    /** register number */
     unsigned m_regidx2;
+    /** register number */
     unsigned m_regidx3;
 };
 
@@ -155,8 +163,11 @@ class CInstructionMul
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
+    /** register number */
     unsigned m_regidx2;
+    /** register number */
     unsigned m_regidx3;
 };
 
@@ -186,8 +197,11 @@ class CInstructionDiv
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
+    /** register number */
     unsigned m_regidx2;
+    /** register number */
     unsigned m_regidx3;
 };
 
@@ -217,7 +231,9 @@ class CInstructionLoad
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
+    /** register number */
     unsigned m_regidx2;
 };
 
@@ -247,7 +263,9 @@ class CInstructionStore
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
+    /** register number */
     unsigned m_regidx2;
 };
 
@@ -277,6 +295,7 @@ class CInstructionTest
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
 };
 
@@ -334,6 +353,7 @@ class CInstructionJumpA
     void execute(CCPU *cpu);
 
   protected:
+    /** labelname */
     std::string m_addr;
 };
 
@@ -363,6 +383,7 @@ class CInstructionJumpZ
     void execute(CCPU *cpu);
 
   protected:
+    /** labelname */
     std::string m_addr;
 };
 
@@ -392,6 +413,7 @@ class CInstructionJumpS
     void execute(CCPU *cpu);
 
   protected:
+    /** labelname */
     std::string m_addr;
 };
 
@@ -421,7 +443,9 @@ class CInstructionWrite
     void execute(CCPU *cpu);
 
   protected:
+    /** register number */
     unsigned m_regidx1;
+    /** device name */
     std::string m_dev;
 };
 
-- 
cgit v1.2.3


From 9e7c204525a50f36ba7aa7563f1a9702d0bb6f44 Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Wed, 13 May 2009 17:11:40 +0200
Subject: adding tab as whitespace

---
 ue3/mycpu/cprogram.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ue3/mycpu/cprogram.cpp b/ue3/mycpu/cprogram.cpp
index 1a450f5..3fcf734 100644
--- a/ue3/mycpu/cprogram.cpp
+++ b/ue3/mycpu/cprogram.cpp
@@ -102,7 +102,7 @@ void CProgram::compile(std::istream& in)
     string params = (pos == string::npos) ? "" : line.substr(pos + 1);
     boost::trim(params);
     list<string> instrparams;
-    boost::split(instrparams, params, boost::is_any_of(", "), boost::token_compress_on);
+    boost::split(instrparams, params, boost::is_any_of(", \t"), boost::token_compress_on);
 
     /* let instruction parse the parameters. catch+throw exception */
     try
-- 
cgit v1.2.3


From ad6ca84f6e93f983de926ae71f31f42325986f61 Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Thu, 14 May 2009 18:15:28 +0200
Subject: * making cdisplay a template * adding some asserts * adding
 classdiagramm and protokoll * fixing protokoll.pdf in ue1

---
 ue1/protokoll.pdf           | Bin 283846 -> 283840 bytes
 ue3/mycpu/cdisplay.h        |  26 +++++---
 ue3/mycpu/cinstruction.cpp  |   2 +
 ue3/mycpu/instructions.cpp  |  34 +++++++++++
 ue3/mycpu/test/memory1      |   1 -
 ue3/mycpu/test/program1     |  13 ----
 ue3/mycpu/test/test.sh      |   4 +-
 ue3/protokoll.pdf           | Bin 0 -> 405263 bytes
 ue3/protokoll/mycpu.png     | Bin 0 -> 111899 bytes
 ue3/protokoll/mycpu.vpp     | Bin 0 -> 129025 bytes
 ue3/protokoll/protokoll.tex | 144 +++++++++++++++++++++++++++++++++++++++-----
 11 files changed, 185 insertions(+), 39 deletions(-)
 delete mode 100644 ue3/mycpu/test/memory1
 delete mode 100644 ue3/mycpu/test/program1
 create mode 100644 ue3/protokoll.pdf
 create mode 100644 ue3/protokoll/mycpu.png
 create mode 100644 ue3/protokoll/mycpu.vpp

diff --git a/ue1/protokoll.pdf b/ue1/protokoll.pdf
index d1a72ac..3682945 100644
Binary files a/ue1/protokoll.pdf and b/ue1/protokoll.pdf differ
diff --git a/ue3/mycpu/cdisplay.h b/ue3/mycpu/cdisplay.h
index 0a0a723..1523f68 100644
--- a/ue3/mycpu/cdisplay.h
+++ b/ue3/mycpu/cdisplay.h
@@ -1,7 +1,7 @@
 /**
  * @module cdisplay
  * @author Guenther Neuwirth (0626638), Manuel Mausz (0728348)
- * @brief  Abstract class for displays
+ * @brief  Abstract template class for displays
  * @date   10.05.2009
  */
 
@@ -9,15 +9,16 @@
 #define CDISPLAY_H 1
 
 /**
- * @class CDisplay
+ * @class CDisplayT
  *
- * Abstract class for displays
+ * Abstract template class for displays
  */
-class CDisplay
+template <class T>
+class CDisplayT
 {
   public:
     /**
-     * @method CDisplay
+     * @method CDisplayT
      * @brief  Default ctor
      * @param  name  name of display
      * @return -
@@ -25,12 +26,12 @@ class CDisplay
      * @exception  none
      * @conditions none
      */
-    CDisplay(std::string name)
+    CDisplayT(std::string name)
       : m_name(name)
     {}
 
     /**
-     * @method ~CDisplay
+     * @method ~CDisplayT
      * @brief  Default dtor
      * @param  -
      * @return -
@@ -38,7 +39,7 @@ class CDisplay
      * @exception  none
      * @conditions none
      */
-    virtual ~CDisplay()
+    virtual ~CDisplayT()
     {}
 
     /**
@@ -64,7 +65,7 @@ class CDisplay
      * @exception  none
      * @conditions none
      */
-    virtual void display(const CDat &value) = 0;
+    virtual void display(const T &value) = 0;
 
   protected:
     /* members */
@@ -72,6 +73,13 @@ class CDisplay
     std::string m_name;
 };
 
+/**
+ * @class CDisplay
+ *
+ * Memory definition for CCPU
+ */
+typedef CDisplayT<CDat> CDisplay;
+
 #endif
 
 /* vim: set et sw=2 ts=2: */
diff --git a/ue3/mycpu/cinstruction.cpp b/ue3/mycpu/cinstruction.cpp
index 5c1bd5c..a766015 100644
--- a/ue3/mycpu/cinstruction.cpp
+++ b/ue3/mycpu/cinstruction.cpp
@@ -8,6 +8,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <boost/lexical_cast.hpp>
+#include <assert.h>
 #include "cinstruction.h"
 #include "ccpu.h"
 
@@ -35,6 +36,7 @@ const unsigned CInstruction::parseRegister(const std::string& str)
 
 inline void CInstruction::checkRegister(CCPU *cpu, const unsigned regidx)
 {
+  assert(cpu != NULL);
   if (regidx >= cpu->getRegisterCount())
   {
     stringstream sstr;
diff --git a/ue3/mycpu/instructions.cpp b/ue3/mycpu/instructions.cpp
index c2ce096..ef9e944 100644
--- a/ue3/mycpu/instructions.cpp
+++ b/ue3/mycpu/instructions.cpp
@@ -6,6 +6,7 @@
  */
 
 #include <map>
+#include <assert.h>
 #include "instructions.h"
 
 using namespace std;
@@ -22,6 +23,8 @@ void CInstructionInc::compile(std::list<std::string>& params)
 
 void CInstructionInc::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
   checkRegister(cpu, m_regidx1);
   cpu->getRegisters()[ m_regidx1 ]++;
 }
@@ -40,6 +43,8 @@ void CInstructionDec::compile(std::list<std::string>& params)
 
 void CInstructionDec::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
   checkRegister(cpu, m_regidx1);
   cpu->getRegisters()[ m_regidx1 ]--;
 }
@@ -62,6 +67,8 @@ void CInstructionAdd::compile(std::list<std::string>& params)
 
 void CInstructionAdd::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
   checkRegister(cpu, m_regidx1);
   checkRegister(cpu, m_regidx2);
   checkRegister(cpu, m_regidx3);
@@ -87,6 +94,8 @@ void CInstructionSub::compile(std::list<std::string>& params)
 
 void CInstructionSub::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
   checkRegister(cpu, m_regidx1);
   checkRegister(cpu, m_regidx2);
   checkRegister(cpu, m_regidx3);
@@ -137,6 +146,8 @@ void CInstructionDiv::compile(std::list<std::string>& params)
 
 void CInstructionDiv::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
   checkRegister(cpu, m_regidx1);
   checkRegister(cpu, m_regidx2);
   checkRegister(cpu, m_regidx3);
@@ -160,6 +171,9 @@ void CInstructionLoad::compile(std::list<std::string>& params)
 
 void CInstructionLoad::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
+  assert(cpu->getMemory() != NULL);
   checkRegister(cpu, m_regidx1);
   checkRegister(cpu, m_regidx2);
   CDat val(cpu->getRegisters()[ m_regidx2 ]);
@@ -182,6 +196,9 @@ void CInstructionStore::compile(std::list<std::string>& params)
 
 void CInstructionStore::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
+  assert(cpu->getMemory() != NULL);
   checkRegister(cpu, m_regidx1);
   checkRegister(cpu, m_regidx2);
   CDat val(cpu->getRegisters()[ m_regidx2 ]);
@@ -202,6 +219,8 @@ void CInstructionTest::compile(std::list<std::string>& params)
 
 void CInstructionTest::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
   checkRegister(cpu, m_regidx1);
   if (cpu->getRegisters()[ m_regidx1 ] == CDat(0))
     cpu->setFlagZero(true);
@@ -223,6 +242,9 @@ void CInstructionJumpA::compile(std::list<std::string>& params)
 
 void CInstructionJumpA::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
+  assert(cpu->getProgram() != NULL);
   if (m_addr.empty())
     throw runtime_error("Empty address");
   cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
@@ -242,8 +264,13 @@ void CInstructionJumpZ::compile(std::list<std::string>& params)
 
 void CInstructionJumpZ::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
+  assert(cpu->getProgram() != NULL);
   if (!cpu->getFlagZero())
     return;
+  if (m_addr.empty())
+    throw runtime_error("Empty address");
   cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
 }
 
@@ -261,8 +288,13 @@ void CInstructionJumpS::compile(std::list<std::string>& params)
 
 void CInstructionJumpS::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
+  assert(cpu->getProgram() != NULL);
   if (!cpu->getFlagSign())
     return;
+  if (m_addr.empty())
+    throw runtime_error("Empty address");
   cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
 }
 
@@ -282,6 +314,8 @@ void CInstructionWrite::compile(std::list<std::string>& params)
 
 void CInstructionWrite::execute(CCPU *cpu)
 {
+  assert(cpu != NULL);
+  assert(cpu->getRegisters() != NULL);
   checkRegister(cpu, m_regidx1);
   if (m_dev.empty())
     throw runtime_error("Empty device");
diff --git a/ue3/mycpu/test/memory1 b/ue3/mycpu/test/memory1
deleted file mode 100644
index 209e3ef..0000000
--- a/ue3/mycpu/test/memory1
+++ /dev/null
@@ -1 +0,0 @@
-20
diff --git a/ue3/mycpu/test/program1 b/ue3/mycpu/test/program1
deleted file mode 100644
index ae5e9d2..0000000
--- a/ue3/mycpu/test/program1
+++ /dev/null
@@ -1,13 +0,0 @@
-# set R2 = 10
-LOAD R2, R1
-
-# start of loop
-label Loop:
-inc R3
-sub R4, R3, R2
-test R4
-jumpz EndLoop
-write WDEZ, R3
-jumpa Loop
-
-label EndLoop:
diff --git a/ue3/mycpu/test/test.sh b/ue3/mycpu/test/test.sh
index ad2ae4d..ff1076c 100755
--- a/ue3/mycpu/test/test.sh
+++ b/ue3/mycpu/test/test.sh
@@ -32,9 +32,11 @@ do
   if [ "$md5_1" != "$md5_2" ]
   then
     echo "  ERROR: output and $reffile differ"
-    diff -Nau $reffile $tmpfile
+    diff -Naur "$reffile" "$tmpfile"
+    rm -rf "$tmpfile"
     exit 1
   else
     echo "  SUCCESS"
   fi
+  rm -rf "$tmpfile"
 done
diff --git a/ue3/protokoll.pdf b/ue3/protokoll.pdf
new file mode 100644
index 0000000..3d8c5eb
Binary files /dev/null and b/ue3/protokoll.pdf differ
diff --git a/ue3/protokoll/mycpu.png b/ue3/protokoll/mycpu.png
new file mode 100644
index 0000000..570d50a
Binary files /dev/null and b/ue3/protokoll/mycpu.png differ
diff --git a/ue3/protokoll/mycpu.vpp b/ue3/protokoll/mycpu.vpp
new file mode 100644
index 0000000..1f4b264
Binary files /dev/null and b/ue3/protokoll/mycpu.vpp differ
diff --git a/ue3/protokoll/protokoll.tex b/ue3/protokoll/protokoll.tex
index 8b413e7..dd53735 100644
--- a/ue3/protokoll/protokoll.tex
+++ b/ue3/protokoll/protokoll.tex
@@ -38,44 +38,110 @@ Manuel Mausz, \matrnr 0728348\\
 
 Abbildung~\ref{fig:classdiagram1} zeigt das Klassendiagramm der Aufgabe.
 
-TODO
+Als Datentyp für Register und Hauptspeicher der CPU wurde ein allgemeines
+Template implementiert, welche andere Datentypen oder Klasse umhüllen kann.
+Zudem wurden die gängigsten Operatoren definiert, die man sich von einem
+Datentyp erwarten kann. Gemäß der Aufgabenstellung wurde der Datentyp CDat als
+umhüllter Integer-Wert definiert.
+
+Der Hauptspeicher der CPU wurde als abgeleitetes Template \mbox{CVectorMem} des
+Templates \mbox{std::vector<T, Allocator>} implementiert, damit dieses um die
+Methode \mbox{initialize} und \mbox{dump} erweitert werden konnten. Erstere
+dient zur Initialisierung des Hauptspeichers bzw. Füllung des Vectors,
+zweiteres zur Debugausgabe. Der Datentyp CMem wurde via typedef als
+\mbox{CVectorMem} mit dem Templateargument CDat definiert. Somit enthält der
+Hauptspeicher nur Elemente des Typs CDat.
+
+Die geforderten zwei Display-Klassen \mbox{CDisplayWDEZ} und 
+\mbox{CDisplayWHEX} wurden von der abstrakten Klasse CDisplay abgeleitet, welche
+selbst als Template CDisplayT mit dem Templateargument CDat definiert ist.
+
+Der Programmspeicher \mbox{CProgram} wurde vom Template
+\mbox{std::vector<CInstruction *>} abgeleitet. Somit ist diese Klasse, ähnlich
+wie CMem, selbst ein Vector. Zudem wurden weitere Methoden hinzugefügt. Die
+Methode \mbox{compile} dient zum Kompilieren bzw. Umwandeln des
+Syntax der Programmdatei in Instanzen der Klasse CInstruction, die später von
+der CPU ausgeführt werden. Zur Umwandlung werden bei der Instantiierung von
+\mbox{CProgram} sämtliche erlaubten Instruktionen (also Instanzen von
+\mbox{CInstruction}) in ein \mbox{std::set} eingefügt. Im Zuge der Methode
+\mbox{compile} wird durch Iterieren die jeweilige Instruktion gesucht und durch
+Anwendung des Designpattern \textit{Factory method pattern} die Instruktion
+dupliziert und in \mbox{CProgram} gespeichert. Labels werden zwecks Effizienz in
+einer \mbox{std::map} festgehalten.
+
+Die jeweiligen unterstützen Instruktionen wurden wie gefordert von der Klasse
+\mbox{CInstruction} abgeleitet. \mbox{CInstruction} fordert die
+Implementierung einer Methode \mbox{compile}, die während des parsens der
+Programmdatei von \mbox{CProgram} aufgerufen werden, als auch eine Methode
+\mbox{execute}, die im Zuge der Ausführung des Programms von CCPU
+aufgerufen werden.
+
+Die eigentliche CPU wird durch die Klasse \mbox{CCPU} implementiert. Diese
+dient hauptsächlich als Container für die einzelnen, notwendigen Teile
+(Hauptspeicher, Programmspeicher, Displays, ...) und besitzt daher entsprechend
+viele get- und set-Funktionen. Die Methode \mbox{run} dient zur Ausführung des
+Programms und ist eine Schleife, die über die Instruktionen iteriert und die
+Methode \mbox{execute} aufruft.
 
 %==================================================================
-\begin{figure}[htb]
-  \begin{center}
-    \epsfxsize=0.9\textwidth\epsfbox{mycpu.png}
-  \end{center}
-  \caption{Klassendiagramm 1}
-  \label{fig:classdiagram1}
-\end{figure}
+\begin{center}
+  \begin{figure}[htb]
+    \epsfxsize=1.6\textwidth\epsfbox{mycpu.png}
+    \caption{Klassendiagramm 1}
+    \label{fig:classdiagram1}
+  \end{figure}
+\end{center}
 %==================================================================
 
 \subsection{Verwaltung der Ressourcen}
 
-TODO
+Alle Objekte, die im Konstruktor alloziert werden, werden im Destruktor wieder
+freigegeben. Die Objekte, die über die \textit{Factory method pattern}
+alloziert werden, werden im Zuge des Destruktor des Vectors bzw.
+von \mbox{CProgram} wieder freigegeben.
 
 \subsection{Fehlerbehandlung}
 
-TODO
+Es wurden keine eigenen Exceptions eingeführt. Statt dessen werden Exceptions
+meist in Exceptions des Typs \mbox{std::runtime\_error} umgewandelt. Da die
+Hierarchie nicht sehr tief ist, fängt lediglich \mbox{CPropram::compile}
+Exceptions des Typs \mbox{std::runtime\_error}, um zusätzliche Information an
+den ursprünglichen Aufrufer der Methode weiterzugeben. Dies geschieht ebenfalls
+per Exception des Typs \mbox{std::runtime\_error}.
 
 \subsection{Implementierung}
 
-TODO
-
+Siehe Punkt~\ref{Design} und Abbildung~\ref{fig:classdiagram1} sowie
+Punkt~\ref{Listings}.\\
+Es wurde viel mit Templates gearbeitet.
 
 \section{Projektverlauf}
 
 \subsection{Probleme und Fallstricke}
 
-TODO
+Abgesehen von den mittlerweile üblichen Schwierigkeiten die Angabe bzw.
+die Gedanken dessen Verfassers verstehen zu wollen, arbeitete das erste Design
+noch vermehrt mit Text. Unter anderem hatte die Methode
+\mbox{CInstruction::execute} einen Parameter des Typs \mbox{std::string}, was
+zum dazu führte, das die Instruktion bei jeder Aufführung (zum Beispiel durch
+Jumps) erneut geparsed werden musste.
 
 \subsection{Arbeitsaufwand}
 
 \begin{tabular}{ll}
   \toprule
-  Entwicklungsschritt / Meilenstein & Arbeitsaufwand in Stunden\\
+  Entwicklungsschritt / Meilenstein & Arbeitsaufwand\\
+  \midrule
+  Erstes Design & 3 Stunden\\
+  \hline
+  Implementierung & 3 Tage\\
+  \hline
+  Anpassung des Designs und der Implementierung & 4 Stunden\\
+  \hline
+  Dokumentation (Doxygen) und Überprüfung aller\\
+  Anforderungen gemäß der Programmierrichtlinien & 4 Stunden\\
   \hline
-  TODO & TODO\\
+  Erstellung des Protokolls & 3 Stunden\\
   \bottomrule
 \end{tabular}
 
@@ -88,5 +154,53 @@ TODO
 \subsection{mycpu.cpp}
 \lstinputlisting{../mycpu/mycpu.cpp}
 
+\newpage
+\subsection{cdat.h}
+\lstinputlisting{../mycpu/cdat.h}
+
+\newpage
+\subsection{cmem.h}
+\lstinputlisting{../mycpu/cmem.h}
+
+\newpage
+\subsection{cinstruction.h}
+\lstinputlisting{../mycpu/cinstruction.h}
+
+\newpage
+\subsection{cinstruction.cpp}
+\lstinputlisting{../mycpu/cinstruction.cpp}
+
+\newpage
+\subsection{instructions.h}
+\lstinputlisting{../mycpu/instructions.h}
+
+\newpage
+\subsection{instructions.cpp}
+\lstinputlisting{../mycpu/instructions.cpp}
+
+\newpage
+\subsection{cdisplay.h}
+\lstinputlisting{../mycpu/cdisplay.h}
+
+\newpage
+\subsection{displays.h}
+\lstinputlisting{../mycpu/displays.h}
+
+\newpage
+\subsection{cprogram.h}
+\lstinputlisting{../mycpu/cprogram.h}
+
+\newpage
+\subsection{cprogram.cpp}
+\lstinputlisting{../mycpu/cprogram.cpp}
+
+\newpage
+\subsection{ccpu.h}
+\lstinputlisting{../mycpu/ccpu.h}
+
+\newpage
+\subsection{ccpu.cpp}
+\lstinputlisting{../mycpu/ccpu.cpp}
+
 \end{document}
 
-- 
cgit v1.2.3


From 3563c6dfd0f5f102cb748ecc6ad318601990515e Mon Sep 17 00:00:00 2001
From: manuel <manuel@nc8430.lan>
Date: Thu, 14 May 2009 18:21:15 +0200
Subject: adding doxygen docs

---
 ue3/doxygen/annotated.html                      |  54 ++
 ue3/doxygen/ccpu_8h-source.html                 | 114 +++
 ue3/doxygen/cdat_8h-source.html                 | 148 ++++
 ue3/doxygen/cdisplay_8h-source.html             |  52 ++
 ue3/doxygen/cinstruction_8h-source.html         |  85 +++
 ue3/doxygen/classCCPU-members.html              |  42 ++
 ue3/doxygen/classCCPU.html                      | 578 ++++++++++++++++
 ue3/doxygen/classCDat.html                      |  35 +
 ue3/doxygen/classCDatT-members.html             |  48 ++
 ue3/doxygen/classCDatT.html                     | 879 ++++++++++++++++++++++++
 ue3/doxygen/classCDisplay.html                  |  45 ++
 ue3/doxygen/classCDisplay.png                   | Bin 0 -> 514 bytes
 ue3/doxygen/classCDisplayT-members.html         |  33 +
 ue3/doxygen/classCDisplayT.html                 | 227 ++++++
 ue3/doxygen/classCDisplayWDEZ-members.html      |  30 +
 ue3/doxygen/classCDisplayWDEZ.html              |  87 +++
 ue3/doxygen/classCDisplayWDEZ.png               | Bin 0 -> 400 bytes
 ue3/doxygen/classCDisplayWHEX-members.html      |  30 +
 ue3/doxygen/classCDisplayWHEX.html              |  87 +++
 ue3/doxygen/classCDisplayWHEX.png               | Bin 0 -> 389 bytes
 ue3/doxygen/classCInstruction-members.html      |  41 ++
 ue3/doxygen/classCInstruction.html              | 575 ++++++++++++++++
 ue3/doxygen/classCInstruction.png               | Bin 0 -> 1882 bytes
 ue3/doxygen/classCInstructionAdd-members.html   |  45 ++
 ue3/doxygen/classCInstructionAdd.html           | 223 ++++++
 ue3/doxygen/classCInstructionAdd.png            | Bin 0 -> 389 bytes
 ue3/doxygen/classCInstructionDec-members.html   |  43 ++
 ue3/doxygen/classCInstructionDec.html           | 189 +++++
 ue3/doxygen/classCInstructionDec.png            | Bin 0 -> 393 bytes
 ue3/doxygen/classCInstructionDiv-members.html   |  45 ++
 ue3/doxygen/classCInstructionDiv.html           | 223 ++++++
 ue3/doxygen/classCInstructionDiv.png            | Bin 0 -> 382 bytes
 ue3/doxygen/classCInstructionInc-members.html   |  43 ++
 ue3/doxygen/classCInstructionInc.html           | 189 +++++
 ue3/doxygen/classCInstructionInc.png            | Bin 0 -> 373 bytes
 ue3/doxygen/classCInstructionJumpA-members.html |  43 ++
 ue3/doxygen/classCInstructionJumpA.html         | 189 +++++
 ue3/doxygen/classCInstructionJumpA.png          | Bin 0 -> 414 bytes
 ue3/doxygen/classCInstructionJumpS-members.html |  43 ++
 ue3/doxygen/classCInstructionJumpS.html         | 189 +++++
 ue3/doxygen/classCInstructionJumpS.png          | Bin 0 -> 416 bytes
 ue3/doxygen/classCInstructionJumpZ-members.html |  43 ++
 ue3/doxygen/classCInstructionJumpZ.html         | 189 +++++
 ue3/doxygen/classCInstructionJumpZ.png          | Bin 0 -> 416 bytes
 ue3/doxygen/classCInstructionLabel-members.html |  42 ++
 ue3/doxygen/classCInstructionLabel.html         | 170 +++++
 ue3/doxygen/classCInstructionLabel.png          | Bin 0 -> 400 bytes
 ue3/doxygen/classCInstructionLoad-members.html  |  44 ++
 ue3/doxygen/classCInstructionLoad.html          | 206 ++++++
 ue3/doxygen/classCInstructionLoad.png           | Bin 0 -> 395 bytes
 ue3/doxygen/classCInstructionMul-members.html   |  45 ++
 ue3/doxygen/classCInstructionMul.html           | 223 ++++++
 ue3/doxygen/classCInstructionMul.png            | Bin 0 -> 384 bytes
 ue3/doxygen/classCInstructionStore-members.html |  44 ++
 ue3/doxygen/classCInstructionStore.html         | 206 ++++++
 ue3/doxygen/classCInstructionStore.png          | Bin 0 -> 400 bytes
 ue3/doxygen/classCInstructionSub-members.html   |  45 ++
 ue3/doxygen/classCInstructionSub.html           | 223 ++++++
 ue3/doxygen/classCInstructionSub.png            | Bin 0 -> 388 bytes
 ue3/doxygen/classCInstructionTest-members.html  |  43 ++
 ue3/doxygen/classCInstructionTest.html          | 189 +++++
 ue3/doxygen/classCInstructionTest.png           | Bin 0 -> 392 bytes
 ue3/doxygen/classCInstructionWrite-members.html |  44 ++
 ue3/doxygen/classCInstructionWrite.html         | 206 ++++++
 ue3/doxygen/classCInstructionWrite.png          | Bin 0 -> 394 bytes
 ue3/doxygen/classCMem.html                      |  35 +
 ue3/doxygen/classCProgram-members.html          |  33 +
 ue3/doxygen/classCProgram.html                  | 234 +++++++
 ue3/doxygen/classCVectorMem-members.html        |  29 +
 ue3/doxygen/classCVectorMem.html                |  83 +++
 ue3/doxygen/cmem_8h-source.html                 |  95 +++
 ue3/doxygen/cprogram_8h-source.html             |  60 ++
 ue3/doxygen/displays_8h-source.html             |  60 ++
 ue3/doxygen/doxygen.css                         | 358 ++++++++++
 ue3/doxygen/doxygen.png                         | Bin 0 -> 1281 bytes
 ue3/doxygen/files.html                          |  30 +
 ue3/doxygen/functions.html                      | 259 +++++++
 ue3/doxygen/functions_func.html                 | 219 ++++++
 ue3/doxygen/functions_rela.html                 |  44 ++
 ue3/doxygen/functions_vars.html                 |  71 ++
 ue3/doxygen/hierarchy.html                      |  58 ++
 ue3/doxygen/index.html                          |  22 +
 ue3/doxygen/instructions_8h-source.html         | 347 ++++++++++
 ue3/doxygen/namespaces.html                     |  23 +
 ue3/doxygen/namespacestd.html                   |  32 +
 ue3/doxygen/tab_b.gif                           | Bin 0 -> 35 bytes
 ue3/doxygen/tab_l.gif                           | Bin 0 -> 706 bytes
 ue3/doxygen/tab_r.gif                           | Bin 0 -> 2585 bytes
 ue3/doxygen/tabs.css                            | 102 +++
 ue3/mycpu/cdisplay.h                            |   2 +-
 ue3/mycpu/displays.h                            |  18 +
 91 files changed, 8829 insertions(+), 1 deletion(-)
 create mode 100644 ue3/doxygen/annotated.html
 create mode 100644 ue3/doxygen/ccpu_8h-source.html
 create mode 100644 ue3/doxygen/cdat_8h-source.html
 create mode 100644 ue3/doxygen/cdisplay_8h-source.html
 create mode 100644 ue3/doxygen/cinstruction_8h-source.html
 create mode 100644 ue3/doxygen/classCCPU-members.html
 create mode 100644 ue3/doxygen/classCCPU.html
 create mode 100644 ue3/doxygen/classCDat.html
 create mode 100644 ue3/doxygen/classCDatT-members.html
 create mode 100644 ue3/doxygen/classCDatT.html
 create mode 100644 ue3/doxygen/classCDisplay.html
 create mode 100644 ue3/doxygen/classCDisplay.png
 create mode 100644 ue3/doxygen/classCDisplayT-members.html
 create mode 100644 ue3/doxygen/classCDisplayT.html
 create mode 100644 ue3/doxygen/classCDisplayWDEZ-members.html
 create mode 100644 ue3/doxygen/classCDisplayWDEZ.html
 create mode 100644 ue3/doxygen/classCDisplayWDEZ.png
 create mode 100644 ue3/doxygen/classCDisplayWHEX-members.html
 create mode 100644 ue3/doxygen/classCDisplayWHEX.html
 create mode 100644 ue3/doxygen/classCDisplayWHEX.png
 create mode 100644 ue3/doxygen/classCInstruction-members.html
 create mode 100644 ue3/doxygen/classCInstruction.html
 create mode 100644 ue3/doxygen/classCInstruction.png
 create mode 100644 ue3/doxygen/classCInstructionAdd-members.html
 create mode 100644 ue3/doxygen/classCInstructionAdd.html
 create mode 100644 ue3/doxygen/classCInstructionAdd.png
 create mode 100644 ue3/doxygen/classCInstructionDec-members.html
 create mode 100644 ue3/doxygen/classCInstructionDec.html
 create mode 100644 ue3/doxygen/classCInstructionDec.png
 create mode 100644 ue3/doxygen/classCInstructionDiv-members.html
 create mode 100644 ue3/doxygen/classCInstructionDiv.html
 create mode 100644 ue3/doxygen/classCInstructionDiv.png
 create mode 100644 ue3/doxygen/classCInstructionInc-members.html
 create mode 100644 ue3/doxygen/classCInstructionInc.html
 create mode 100644 ue3/doxygen/classCInstructionInc.png
 create mode 100644 ue3/doxygen/classCInstructionJumpA-members.html
 create mode 100644 ue3/doxygen/classCInstructionJumpA.html
 create mode 100644 ue3/doxygen/classCInstructionJumpA.png
 create mode 100644 ue3/doxygen/classCInstructionJumpS-members.html
 create mode 100644 ue3/doxygen/classCInstructionJumpS.html
 create mode 100644 ue3/doxygen/classCInstructionJumpS.png
 create mode 100644 ue3/doxygen/classCInstructionJumpZ-members.html
 create mode 100644 ue3/doxygen/classCInstructionJumpZ.html
 create mode 100644 ue3/doxygen/classCInstructionJumpZ.png
 create mode 100644 ue3/doxygen/classCInstructionLabel-members.html
 create mode 100644 ue3/doxygen/classCInstructionLabel.html
 create mode 100644 ue3/doxygen/classCInstructionLabel.png
 create mode 100644 ue3/doxygen/classCInstructionLoad-members.html
 create mode 100644 ue3/doxygen/classCInstructionLoad.html
 create mode 100644 ue3/doxygen/classCInstructionLoad.png
 create mode 100644 ue3/doxygen/classCInstructionMul-members.html
 create mode 100644 ue3/doxygen/classCInstructionMul.html
 create mode 100644 ue3/doxygen/classCInstructionMul.png
 create mode 100644 ue3/doxygen/classCInstructionStore-members.html
 create mode 100644 ue3/doxygen/classCInstructionStore.html
 create mode 100644 ue3/doxygen/classCInstructionStore.png
 create mode 100644 ue3/doxygen/classCInstructionSub-members.html
 create mode 100644 ue3/doxygen/classCInstructionSub.html
 create mode 100644 ue3/doxygen/classCInstructionSub.png
 create mode 100644 ue3/doxygen/classCInstructionTest-members.html
 create mode 100644 ue3/doxygen/classCInstructionTest.html
 create mode 100644 ue3/doxygen/classCInstructionTest.png
 create mode 100644 ue3/doxygen/classCInstructionWrite-members.html
 create mode 100644 ue3/doxygen/classCInstructionWrite.html
 create mode 100644 ue3/doxygen/classCInstructionWrite.png
 create mode 100644 ue3/doxygen/classCMem.html
 create mode 100644 ue3/doxygen/classCProgram-members.html
 create mode 100644 ue3/doxygen/classCProgram.html
 create mode 100644 ue3/doxygen/classCVectorMem-members.html
 create mode 100644 ue3/doxygen/classCVectorMem.html
 create mode 100644 ue3/doxygen/cmem_8h-source.html
 create mode 100644 ue3/doxygen/cprogram_8h-source.html
 create mode 100644 ue3/doxygen/displays_8h-source.html
 create mode 100644 ue3/doxygen/doxygen.css
 create mode 100644 ue3/doxygen/doxygen.png
 create mode 100644 ue3/doxygen/files.html
 create mode 100644 ue3/doxygen/functions.html
 create mode 100644 ue3/doxygen/functions_func.html
 create mode 100644 ue3/doxygen/functions_rela.html
 create mode 100644 ue3/doxygen/functions_vars.html
 create mode 100644 ue3/doxygen/hierarchy.html
 create mode 100644 ue3/doxygen/index.html
 create mode 100644 ue3/doxygen/instructions_8h-source.html
 create mode 100644 ue3/doxygen/namespaces.html
 create mode 100644 ue3/doxygen/namespacestd.html
 create mode 100644 ue3/doxygen/tab_b.gif
 create mode 100644 ue3/doxygen/tab_l.gif
 create mode 100644 ue3/doxygen/tab_r.gif
 create mode 100644 ue3/doxygen/tabs.css

diff --git a/ue3/doxygen/annotated.html b/ue3/doxygen/annotated.html
new file mode 100644
index 0000000..fb958c8
--- /dev/null
+++ b/ue3/doxygen/annotated.html
@@ -0,0 +1,54 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Class List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li class="current"><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>mycpu Class List</h1>Here are the classes, structs, unions and interfaces with brief descriptions:<table>
+  <tr><td class="indexkey"><a class="el" href="classCCPU.html">CCPU</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCDat.html">CDat</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCDisplay.html">CDisplay</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCDisplayWDEZ.html">CDisplayWDEZ</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCDisplayWHEX.html">CDisplayWHEX</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstruction.html">CInstruction</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionDec.html">CInstructionDec</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionInc.html">CInstructionInc</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionStore.html">CInstructionStore</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionTest.html">CInstructionTest</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCMem.html">CMem</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCProgram.html">CProgram</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classCVectorMem.html">CVectorMem&lt; T, Allocator &gt;</a></td><td class="indexvalue"></td></tr>
+</table>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/ccpu_8h-source.html b/ue3/doxygen/ccpu_8h-source.html
new file mode 100644
index 0000000..0081283
--- /dev/null
+++ b/ue3/doxygen/ccpu_8h-source.html
@@ -0,0 +1,114 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/ccpu.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/ccpu.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00009"></a>00009 <span class="preprocessor">#ifndef CCPU_H</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span><span class="preprocessor">#define CCPU_H 1</span>
+<a name="l00011"></a>00011 <span class="preprocessor"></span>
+<a name="l00012"></a>00012 <span class="preprocessor">#include &lt;iostream&gt;</span>
+<a name="l00013"></a>00013 <span class="preprocessor">#include &lt;set&gt;</span>
+<a name="l00014"></a>00014 <span class="preprocessor">#include "cdat.h"</span>
+<a name="l00015"></a>00015 <span class="preprocessor">#include "cmem.h"</span>
+<a name="l00016"></a>00016 <span class="preprocessor">#include "cprogram.h"</span>
+<a name="l00017"></a>00017 <span class="preprocessor">#include "cdisplay.h"</span>
+<a name="l00018"></a>00018 
+<a name="l00025"></a><a class="code" href="classCCPU.html">00025</a> <span class="keyword">class </span><a class="code" href="classCCPU.html">CCPU</a>
+<a name="l00026"></a>00026 {
+<a name="l00027"></a>00027   <span class="keyword">public</span>:
+<a name="l00037"></a>00037     <a class="code" href="classCCPU.html#12b0f403ddbfae0ff52cbf079b96395b" title="Default ctor.">CCPU</a>(<span class="keyword">const</span> <span class="keywordtype">unsigned</span> cnt);
+<a name="l00038"></a>00038 
+<a name="l00048"></a>00048     <a class="code" href="classCCPU.html#7523a3b0b832774c3df57bd019273a68" title="Default dtor.">~CCPU</a>();
+<a name="l00049"></a>00049 
+<a name="l00059"></a><a class="code" href="classCCPU.html#b25ee10ea09dfe12d9e77e5eb2126d32">00059</a>     <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <a class="code" href="classCCPU.html#b25ee10ea09dfe12d9e77e5eb2126d32" title="get number of registers">getRegisterCount</a>()<span class="keyword"> const</span>
+<a name="l00060"></a>00060 <span class="keyword">    </span>{
+<a name="l00061"></a>00061       <span class="keywordflow">return</span> m_regcnt;
+<a name="l00062"></a>00062     }
+<a name="l00063"></a>00063 
+<a name="l00073"></a><a class="code" href="classCCPU.html#efe3e22919627e5daf525d11b13d5c44">00073</a>     <a class="code" href="classCDat.html">CDat</a> *<a class="code" href="classCCPU.html#efe3e22919627e5daf525d11b13d5c44" title="get pointer to registers array">getRegisters</a>()<span class="keyword"> const</span>
+<a name="l00074"></a>00074 <span class="keyword">    </span>{
+<a name="l00075"></a>00075       <span class="keywordflow">return</span> m_registers;
+<a name="l00076"></a>00076     }
+<a name="l00077"></a>00077 
+<a name="l00087"></a><a class="code" href="classCCPU.html#bb2644a658cbfbcdd7c579a2840cee67">00087</a>     <span class="keywordtype">void</span> <a class="code" href="classCCPU.html#bb2644a658cbfbcdd7c579a2840cee67" title="set memory of cpu">setMemory</a>(<a class="code" href="classCMem.html">CMem</a> *memory)
+<a name="l00088"></a>00088     {
+<a name="l00089"></a>00089       m_memory = memory;
+<a name="l00090"></a>00090     }
+<a name="l00091"></a>00091 
+<a name="l00101"></a><a class="code" href="classCCPU.html#47e3302a8d9582b29a4d722735d8aa60">00101</a>     <a class="code" href="classCMem.html">CMem</a> *<a class="code" href="classCCPU.html#47e3302a8d9582b29a4d722735d8aa60" title="get pointer to memory">getMemory</a>()<span class="keyword"> const</span>
+<a name="l00102"></a>00102 <span class="keyword">    </span>{
+<a name="l00103"></a>00103       <span class="keywordflow">return</span> m_memory;
+<a name="l00104"></a>00104     }
+<a name="l00105"></a>00105 
+<a name="l00115"></a><a class="code" href="classCCPU.html#3790f6567091892f8867329424d03f71">00115</a>     <span class="keywordtype">void</span> <a class="code" href="classCCPU.html#3790f6567091892f8867329424d03f71" title="set program to execute">setProgram</a>(<span class="keyword">const</span> <a class="code" href="classCProgram.html">CProgram</a> *program)
+<a name="l00116"></a>00116     {
+<a name="l00117"></a>00117       m_program = program;
+<a name="l00118"></a>00118     }
+<a name="l00119"></a>00119 
+<a name="l00129"></a><a class="code" href="classCCPU.html#f7c34c0ba7230ecc980a5ff7730cdbae">00129</a>     <span class="keyword">const</span> <a class="code" href="classCProgram.html">CProgram</a> *<a class="code" href="classCCPU.html#f7c34c0ba7230ecc980a5ff7730cdbae" title="get pointer to program">getProgram</a>()
+<a name="l00130"></a>00130     {
+<a name="l00131"></a>00131       <span class="keywordflow">return</span> m_program;
+<a name="l00132"></a>00132     }
+<a name="l00133"></a>00133 
+<a name="l00143"></a><a class="code" href="classCCPU.html#aab308415ce3083eaa66b9aa1dcbb0c6">00143</a>     <span class="keyword">const</span> std::set&lt;CDisplay *&gt;&amp; <a class="code" href="classCCPU.html#aab308415ce3083eaa66b9aa1dcbb0c6" title="get set of pointers to displays">getDisplays</a>()
+<a name="l00144"></a>00144     {
+<a name="l00145"></a>00145       <span class="keywordflow">return</span> m_displays;
+<a name="l00146"></a>00146     }
+<a name="l00147"></a>00147 
+<a name="l00157"></a><a class="code" href="classCCPU.html#33c8a01cbafddb40cf9283109b3a0b08">00157</a>     <span class="keywordtype">void</span> <a class="code" href="classCCPU.html#33c8a01cbafddb40cf9283109b3a0b08" title="set zero flag">setFlagZero</a>(<span class="keyword">const</span> <span class="keywordtype">bool</span> value)
+<a name="l00158"></a>00158     {
+<a name="l00159"></a>00159       m_flagzero = value;
+<a name="l00160"></a>00160     }
+<a name="l00161"></a>00161 
+<a name="l00171"></a><a class="code" href="classCCPU.html#9398f58c5a715653c3502040029501a1">00171</a>     <span class="keyword">const</span> <span class="keywordtype">bool</span> <a class="code" href="classCCPU.html#9398f58c5a715653c3502040029501a1" title="get value of zero flag">getFlagZero</a>()
+<a name="l00172"></a>00172     {
+<a name="l00173"></a>00173       <span class="keywordflow">return</span> m_flagzero;
+<a name="l00174"></a>00174     }
+<a name="l00175"></a>00175 
+<a name="l00185"></a><a class="code" href="classCCPU.html#d8226c190477e2fbce0ddf7d814a272e">00185</a>     <span class="keywordtype">void</span> <a class="code" href="classCCPU.html#d8226c190477e2fbce0ddf7d814a272e" title="set sign flag">setFlagSign</a>(<span class="keyword">const</span> <span class="keywordtype">bool</span> value)
+<a name="l00186"></a>00186     {
+<a name="l00187"></a>00187       m_flagsign = value;
+<a name="l00188"></a>00188     }
+<a name="l00189"></a>00189 
+<a name="l00199"></a><a class="code" href="classCCPU.html#c3d7d2bf5f93aa2d7b6f5959b8448ea2">00199</a>     <span class="keyword">const</span> <span class="keywordtype">bool</span> <a class="code" href="classCCPU.html#c3d7d2bf5f93aa2d7b6f5959b8448ea2" title="get value of sign flag">getFlagSign</a>()
+<a name="l00200"></a>00200     {
+<a name="l00201"></a>00201       <span class="keywordflow">return</span> m_flagsign;
+<a name="l00202"></a>00202     }
+<a name="l00203"></a>00203 
+<a name="l00213"></a>00213     <span class="keywordtype">void</span> <a class="code" href="classCCPU.html#045df5c772702bdc1454fb90d512fb68" title="execute current program">run</a>();
+<a name="l00214"></a>00214 
+<a name="l00215"></a>00215 <span class="preprocessor">#if DEBUG</span>
+<a name="l00216"></a>00216 <span class="preprocessor"></span>
+<a name="l00225"></a>00225     <span class="keywordtype">void</span> dumpRegisters(std::ostream&amp; out);
+<a name="l00226"></a>00226 <span class="preprocessor">#endif</span>
+<a name="l00227"></a>00227 <span class="preprocessor"></span>
+<a name="l00228"></a>00228   <span class="keyword">private</span>:
+<a name="l00229"></a>00229     <span class="comment">/* members */</span>
+<a name="l00230"></a>00230     <a class="code" href="classCDat.html">CDat</a> *m_registers;
+<a name="l00231"></a>00231     <span class="keywordtype">unsigned</span> m_regcnt;
+<a name="l00232"></a>00232     <a class="code" href="classCMem.html">CMem</a> *m_memory;
+<a name="l00233"></a>00233     <span class="keyword">const</span> <a class="code" href="classCProgram.html">CProgram</a> *m_program;
+<a name="l00234"></a>00234     std::set&lt;CDisplay *&gt; m_displays;
+<a name="l00235"></a>00235     <span class="keywordtype">bool</span> m_flagzero;
+<a name="l00236"></a>00236     <span class="keywordtype">bool</span> m_flagsign;
+<a name="l00237"></a>00237 };
+<a name="l00238"></a>00238 
+<a name="l00239"></a>00239 <span class="preprocessor">#endif</span>
+<a name="l00240"></a>00240 <span class="preprocessor"></span>
+<a name="l00241"></a>00241 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/cdat_8h-source.html b/ue3/doxygen/cdat_8h-source.html
new file mode 100644
index 0000000..5c40e9d
--- /dev/null
+++ b/ue3/doxygen/cdat_8h-source.html
@@ -0,0 +1,148 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/cdat.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/cdat.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00008"></a>00008 <span class="preprocessor">#ifndef CDAT_H</span>
+<a name="l00009"></a>00009 <span class="preprocessor"></span><span class="preprocessor">#define CDAT_H 1</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span>
+<a name="l00011"></a>00011 <span class="preprocessor">#include &lt;boost/operators.hpp&gt;</span>
+<a name="l00012"></a>00012 <span class="preprocessor">#include &lt;iostream&gt;</span>
+<a name="l00013"></a>00013 
+<a name="l00019"></a>00019 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
+<a name="l00020"></a><a class="code" href="classCDatT.html">00020</a> <span class="keyword">class </span><a class="code" href="classCDatT.html">CDatT</a>
+<a name="l00021"></a>00021   : boost::operators&lt;CDatT&lt;T&gt; &gt;
+<a name="l00022"></a>00022 {
+<a name="l00023"></a>00023   <span class="keyword">public</span>:
+<a name="l00033"></a><a class="code" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4">00033</a>     <a class="code" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4" title="Default ctor.">CDatT</a>()
+<a name="l00034"></a>00034     {}
+<a name="l00035"></a>00035 
+<a name="l00045"></a><a class="code" href="classCDatT.html#8ddaa1aaef85fea9e7c3613ccdc5a891">00045</a>     <a class="code" href="classCDatT.html#8ddaa1aaef85fea9e7c3613ccdc5a891" title="Default dtor.">~CDatT</a>()
+<a name="l00046"></a>00046     {}
+<a name="l00047"></a>00047 
+<a name="l00057"></a><a class="code" href="classCDatT.html#e3b0f226b03d2aec0f5bc4f970eb7f3f">00057</a>     <a class="code" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4" title="Default ctor.">CDatT</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; other)
+<a name="l00058"></a>00058       : m_value(other.m_value)
+<a name="l00059"></a>00059     {}
+<a name="l00060"></a>00060 
+<a name="l00070"></a><a class="code" href="classCDatT.html#acdea447eebaf3c22a4d378328181f45">00070</a>     <a class="code" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4" title="Default ctor.">CDatT</a>(T newval)
+<a name="l00071"></a>00071       : m_value(newval)
+<a name="l00072"></a>00072     {}
+<a name="l00073"></a>00073 
+<a name="l00083"></a><a class="code" href="classCDatT.html#8c226fb0b0974a0cbb7897d94f75e4e0">00083</a>     T <a class="code" href="classCDatT.html#8c226fb0b0974a0cbb7897d94f75e4e0" title="returns value of CDatT">getValue</a>()<span class="keyword"> const</span>
+<a name="l00084"></a>00084 <span class="keyword">    </span>{
+<a name="l00085"></a>00085       <span class="keywordflow">return</span> m_value;
+<a name="l00086"></a>00086     }
+<a name="l00087"></a>00087 
+<a name="l00097"></a><a class="code" href="classCDatT.html#5915d4f7de6dceea7d0d7253ce8ff5c9">00097</a>     <a class="code" href="classCDatT.html#5915d4f7de6dceea7d0d7253ce8ff5c9" title="convert to T">operator T</a>()
+<a name="l00098"></a>00098     {
+<a name="l00099"></a>00099       <span class="keywordflow">return</span> m_value;
+<a name="l00100"></a>00100     }
+<a name="l00101"></a>00101 
+<a name="l00111"></a><a class="code" href="classCDatT.html#acd2ef7a53a0c4b128485147171d0cbd">00111</a>     <span class="keywordtype">bool</span> <a class="code" href="classCDatT.html#acd2ef7a53a0c4b128485147171d0cbd" title="implementation of operator &amp;lt;">operator&lt;</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)<span class="keyword"> const</span>
+<a name="l00112"></a>00112 <span class="keyword">    </span>{
+<a name="l00113"></a>00113       <span class="keywordflow">return</span> m_value &lt; x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00114"></a>00114     }
+<a name="l00115"></a>00115 
+<a name="l00125"></a><a class="code" href="classCDatT.html#884afb7b0c4e972c25f12f6eff15177d">00125</a>     <span class="keywordtype">bool</span> <a class="code" href="classCDatT.html#884afb7b0c4e972c25f12f6eff15177d" title="implementation of operator ==">operator==</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)<span class="keyword"> const</span>
+<a name="l00126"></a>00126 <span class="keyword">    </span>{
+<a name="l00127"></a>00127       <span class="keywordflow">return</span> m_value == x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00128"></a>00128     }
+<a name="l00129"></a>00129 
+<a name="l00139"></a><a class="code" href="classCDatT.html#f4f1e37bd94b17229dd0e181fcf41860">00139</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#f4f1e37bd94b17229dd0e181fcf41860" title="implementation of operator +=">operator+=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00140"></a>00140     {
+<a name="l00141"></a>00141       m_value += x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00142"></a>00142       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00143"></a>00143     }
+<a name="l00144"></a>00144 
+<a name="l00154"></a><a class="code" href="classCDatT.html#24cf91d1ac4e0277547ec158ed35544a">00154</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#24cf91d1ac4e0277547ec158ed35544a" title="implementation of operator -=">operator-=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00155"></a>00155     {
+<a name="l00156"></a>00156       m_value -= x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00157"></a>00157       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00158"></a>00158     }
+<a name="l00159"></a>00159 
+<a name="l00169"></a><a class="code" href="classCDatT.html#707446768fff0c8e9a56c4af874d0224">00169</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#707446768fff0c8e9a56c4af874d0224" title="implementation of operator *=">operator*=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00170"></a>00170     {
+<a name="l00171"></a>00171       m_value *= x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00172"></a>00172       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00173"></a>00173     }
+<a name="l00174"></a>00174 
+<a name="l00184"></a><a class="code" href="classCDatT.html#c68e6cd45ae94ef7485650e72f07c49d">00184</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#c68e6cd45ae94ef7485650e72f07c49d" title="implementation of operator /=">operator/=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00185"></a>00185     {
+<a name="l00186"></a>00186       m_value /= x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00187"></a>00187       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00188"></a>00188     }
+<a name="l00189"></a>00189 
+<a name="l00199"></a><a class="code" href="classCDatT.html#403d947a670fcc25dc0ae4e00293cc33">00199</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#403d947a670fcc25dc0ae4e00293cc33" title="implementation of operator %=">operator%=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00200"></a>00200     {
+<a name="l00201"></a>00201       m_value %= x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00202"></a>00202       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00203"></a>00203     }
+<a name="l00204"></a>00204 
+<a name="l00214"></a><a class="code" href="classCDatT.html#f98140b24016e58307bf92b556157a13">00214</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#f98140b24016e58307bf92b556157a13" title="implementation of operator |=">operator|=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00215"></a>00215     {
+<a name="l00216"></a>00216       m_value |= x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00217"></a>00217       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00218"></a>00218     }
+<a name="l00219"></a>00219 
+<a name="l00229"></a><a class="code" href="classCDatT.html#3ec7b2fac8d93e51cd87acda04d7f41e">00229</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#3ec7b2fac8d93e51cd87acda04d7f41e" title="implementation of operator &amp;amp;=">operator&amp;=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00230"></a>00230     {
+<a name="l00231"></a>00231       m_value &amp;= x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00232"></a>00232       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00233"></a>00233     }
+<a name="l00234"></a>00234 
+<a name="l00244"></a><a class="code" href="classCDatT.html#03cf22edd6b2489e63be6cc846de789f">00244</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#03cf22edd6b2489e63be6cc846de789f" title="implementation of operator ^=">operator^=</a>(<span class="keyword">const</span> <a class="code" href="classCDatT.html">CDatT</a>&amp; x)
+<a name="l00245"></a>00245     {
+<a name="l00246"></a>00246       m_value ^= x.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00247"></a>00247       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00248"></a>00248     }
+<a name="l00249"></a>00249 
+<a name="l00259"></a><a class="code" href="classCDatT.html#9a17a5e35049ad6a150ec800ddb81e64">00259</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#9a17a5e35049ad6a150ec800ddb81e64" title="implementation of operator ++">operator++</a>()
+<a name="l00260"></a>00260     {
+<a name="l00261"></a>00261       m_value++;
+<a name="l00262"></a>00262       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00263"></a>00263     }
+<a name="l00264"></a>00264 
+<a name="l00274"></a><a class="code" href="classCDatT.html#ec2be360ce61195c92db1ba4d2db0d8b">00274</a>     <a class="code" href="classCDatT.html">CDatT</a>&amp; <a class="code" href="classCDatT.html#ec2be360ce61195c92db1ba4d2db0d8b" title="implementation of operator --">operator--</a>()
+<a name="l00275"></a>00275     {
+<a name="l00276"></a>00276       m_value--;
+<a name="l00277"></a>00277       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00278"></a>00278     }
+<a name="l00279"></a>00279 
+<a name="l00290"></a><a class="code" href="classCDatT.html#81465346cb4f31cf76336d46c512d0f6">00290</a>     <span class="keyword">friend</span> std::ostream&amp; <a class="code" href="classCDatT.html#81465346cb4f31cf76336d46c512d0f6" title="Shift/output operator for outputstream.">operator&lt;&lt;</a>(std::ostream&amp; stream, <a class="code" href="classCDatT.html">CDatT</a> cdat)
+<a name="l00291"></a>00291     {
+<a name="l00292"></a>00292       stream &lt;&lt; cdat.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00293"></a>00293       <span class="keywordflow">return</span> stream;
+<a name="l00294"></a>00294     }
+<a name="l00295"></a>00295 
+<a name="l00306"></a><a class="code" href="classCDatT.html#16f0666a0b7c3383eb965daf48134fab">00306</a>     <span class="keyword">friend</span> std::istream&amp; <a class="code" href="classCDatT.html#16f0666a0b7c3383eb965daf48134fab" title="Shift/read operator for inputstream.">operator&gt;&gt;</a>(std::istream &amp; stream, <a class="code" href="classCDatT.html">CDatT</a>&amp; cdat)
+<a name="l00307"></a>00307     {
+<a name="l00308"></a>00308       stream &gt;&gt; cdat.<a class="code" href="classCDatT.html#2d1af5bc14c1bc56a49c9dcee59e2eff">m_value</a>;
+<a name="l00309"></a>00309       <span class="keywordflow">return</span> stream;
+<a name="l00310"></a>00310     }
+<a name="l00311"></a>00311 
+<a name="l00312"></a>00312   <span class="keyword">private</span>:
+<a name="l00313"></a>00313     <span class="comment">/* members */</span>
+<a name="l00314"></a>00314     T m_value;
+<a name="l00315"></a>00315 };
+<a name="l00316"></a>00316 
+<a name="l00322"></a>00322 <span class="keyword">typedef</span> <a class="code" href="classCDatT.html">CDatT&lt;int&gt;</a> <a class="code" href="classCDat.html">CDat</a>;
+<a name="l00323"></a>00323 
+<a name="l00324"></a>00324 <span class="preprocessor">#endif</span>
+<a name="l00325"></a>00325 <span class="preprocessor"></span>
+<a name="l00326"></a>00326 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/cdisplay_8h-source.html b/ue3/doxygen/cdisplay_8h-source.html
new file mode 100644
index 0000000..b8c4ef3
--- /dev/null
+++ b/ue3/doxygen/cdisplay_8h-source.html
@@ -0,0 +1,52 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/cdisplay.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/cdisplay.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00008"></a>00008 <span class="preprocessor">#ifndef CDISPLAY_H</span>
+<a name="l00009"></a>00009 <span class="preprocessor"></span><span class="preprocessor">#define CDISPLAY_H 1</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span>
+<a name="l00016"></a>00016 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt;
+<a name="l00017"></a><a class="code" href="classCDisplayT.html">00017</a> <span class="keyword">class </span><a class="code" href="classCDisplayT.html">CDisplayT</a>
+<a name="l00018"></a>00018 {
+<a name="l00019"></a>00019   <span class="keyword">public</span>:
+<a name="l00029"></a><a class="code" href="classCDisplayT.html#d65d27ce8533285525788f3cc534ff14">00029</a>     <a class="code" href="classCDisplayT.html#d65d27ce8533285525788f3cc534ff14" title="Default ctor.">CDisplayT</a>(std::string name)
+<a name="l00030"></a>00030       : <a class="code" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">m_name</a>(name)
+<a name="l00031"></a>00031     {}
+<a name="l00032"></a>00032 
+<a name="l00042"></a><a class="code" href="classCDisplayT.html#edeeab4320b2c3a5b482d216e73e5999">00042</a>     <span class="keyword">virtual</span> <a class="code" href="classCDisplayT.html#edeeab4320b2c3a5b482d216e73e5999" title="Default dtor.">~CDisplayT</a>()
+<a name="l00043"></a>00043     {}
+<a name="l00044"></a>00044 
+<a name="l00054"></a><a class="code" href="classCDisplayT.html#32897b9abaec6e9a0e73ae746ab5cec0">00054</a>     <span class="keyword">virtual</span> <span class="keyword">const</span> std::string&amp; <a class="code" href="classCDisplayT.html#32897b9abaec6e9a0e73ae746ab5cec0" title="returns name of display">getName</a>()
+<a name="l00055"></a>00055     {
+<a name="l00056"></a>00056       <span class="keywordflow">return</span> <a class="code" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">m_name</a>;
+<a name="l00057"></a>00057     }
+<a name="l00058"></a>00058 
+<a name="l00068"></a>00068     <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classCDisplayT.html#5a15f96d3d76bdbb2b172c52036859c2" title="prints value to display">display</a>(<span class="keyword">const</span> T &amp;value) = 0;
+<a name="l00069"></a>00069 
+<a name="l00070"></a>00070   <span class="keyword">protected</span>:
+<a name="l00071"></a>00071     <span class="comment">/* members */</span>
+<a name="l00073"></a><a class="code" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">00073</a>     std::string <a class="code" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">m_name</a>;
+<a name="l00074"></a>00074 };
+<a name="l00075"></a>00075 
+<a name="l00081"></a>00081 <span class="keyword">typedef</span> <a class="code" href="classCDisplayT.html">CDisplayT&lt;CDat&gt;</a> <a class="code" href="classCDisplay.html">CDisplay</a>;
+<a name="l00082"></a>00082 
+<a name="l00083"></a>00083 <span class="preprocessor">#endif</span>
+<a name="l00084"></a>00084 <span class="preprocessor"></span>
+<a name="l00085"></a>00085 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/cinstruction_8h-source.html b/ue3/doxygen/cinstruction_8h-source.html
new file mode 100644
index 0000000..3055c9c
--- /dev/null
+++ b/ue3/doxygen/cinstruction_8h-source.html
@@ -0,0 +1,85 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/cinstruction.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/cinstruction.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00008"></a>00008 <span class="preprocessor">#ifndef CINSTRUCTION_H</span>
+<a name="l00009"></a>00009 <span class="preprocessor"></span><span class="preprocessor">#define CINSTRUCTION_H 1</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span>
+<a name="l00011"></a>00011 <span class="preprocessor">#include &lt;iostream&gt;</span>
+<a name="l00012"></a>00012 <span class="preprocessor">#include &lt;list&gt;</span>
+<a name="l00013"></a>00013 
+<a name="l00014"></a>00014 <span class="comment">/* forward declare CCPU */</span>
+<a name="l00015"></a>00015 <span class="keyword">class </span><a class="code" href="classCCPU.html">CCPU</a>;
+<a name="l00016"></a>00016 
+<a name="l00022"></a><a class="code" href="classCInstruction.html">00022</a> <span class="keyword">class </span><a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00023"></a>00023 {
+<a name="l00024"></a>00024   <span class="keyword">public</span>:
+<a name="l00034"></a><a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">00034</a>     <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(std::string name)
+<a name="l00035"></a>00035       : <a class="code" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a>(name)
+<a name="l00036"></a>00036     {}
+<a name="l00037"></a>00037 
+<a name="l00047"></a><a class="code" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">00047</a>     <span class="keyword">virtual</span> <a class="code" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612" title="Default dtor.">~CInstruction</a>()
+<a name="l00048"></a>00048     {}
+<a name="l00049"></a>00049 
+<a name="l00059"></a><a class="code" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">00059</a>     <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a" title="implementation of operator ==">operator==</a>(std::string&amp; name)
+<a name="l00060"></a>00060     {
+<a name="l00061"></a>00061       <span class="keywordflow">return</span> name == <a class="code" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a>;
+<a name="l00062"></a>00062     }
+<a name="l00063"></a>00063 
+<a name="l00073"></a><a class="code" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">00073</a>     <span class="keyword">virtual</span> <a class="code" href="classCInstruction.html">CInstruction</a>&amp; <a class="code" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43" title="implementation of operator (CCPU)">operator()</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu)
+<a name="l00074"></a>00074     {
+<a name="l00075"></a>00075       <a class="code" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1" title="executes the instruction">execute</a>(cpu);
+<a name="l00076"></a>00076       <span class="keywordflow">return</span> *<span class="keyword">this</span>;
+<a name="l00077"></a>00077     }
+<a name="l00078"></a>00078 
+<a name="l00088"></a><a class="code" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">00088</a>     <span class="keyword">virtual</span> <span class="keyword">const</span> std::string&amp; <a class="code" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44" title="returns instruction name">getName</a>()
+<a name="l00089"></a>00089     {
+<a name="l00090"></a>00090       <span class="keywordflow">return</span> <a class="code" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a>;
+<a name="l00091"></a>00091     }
+<a name="l00092"></a>00092 
+<a name="l00102"></a><a class="code" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">00102</a>     <span class="keyword">virtual</span> std::ostream&amp; <a class="code" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35" title="dumps information about instruction to outputstream">dump</a>(std::ostream&amp; stream)
+<a name="l00103"></a>00103     {
+<a name="l00104"></a>00104       stream &lt;&lt; <a class="code" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a>;
+<a name="l00105"></a>00105       <span class="keywordflow">return</span> stream;
+<a name="l00106"></a>00106     }
+<a name="l00107"></a>00107 
+<a name="l00118"></a><a class="code" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">00118</a>     <span class="keyword">friend</span> std::ostream&amp; <a class="code" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d" title="Shift/output operator for outputstream.">operator&lt;&lt;</a>(std::ostream&amp; stream, <a class="code" href="classCInstruction.html">CInstruction</a>&amp; instr)
+<a name="l00119"></a>00119     {
+<a name="l00120"></a>00120       <span class="keywordflow">return</span> instr.<a class="code" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35" title="dumps information about instruction to outputstream">dump</a>(stream);
+<a name="l00121"></a>00121     }
+<a name="l00122"></a>00122 
+<a name="l00132"></a>00132     <span class="keyword">virtual</span> <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <a class="code" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8" title="parses register syntax Rx (e.g. &amp;quot;R1&amp;quot;)">parseRegister</a>(<span class="keyword">const</span> std::string&amp; str);
+<a name="l00133"></a>00133 
+<a name="l00145"></a>00145     <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c" title="performs a register boundary check does the register exist in cpu?">checkRegister</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu, <span class="keyword">const</span> <span class="keywordtype">unsigned</span> regidx);
+<a name="l00146"></a>00146 
+<a name="l00156"></a>00156     <span class="keyword">virtual</span> <a class="code" href="classCInstruction.html">CInstruction</a> *<a class="code" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc" title="creates a new instance of this instruction">factory</a>() = 0;
+<a name="l00157"></a>00157 
+<a name="l00168"></a>00168     <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params) = 0;
+<a name="l00169"></a>00169 
+<a name="l00179"></a>00179     <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu) = 0;
+<a name="l00180"></a>00180 
+<a name="l00181"></a>00181   <span class="keyword">protected</span>:
+<a name="l00182"></a>00182     <span class="comment">/* members */</span>
+<a name="l00184"></a><a class="code" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">00184</a>     std::string <a class="code" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a>;
+<a name="l00185"></a>00185 };
+<a name="l00186"></a>00186 
+<a name="l00187"></a>00187 <span class="preprocessor">#endif</span>
+<a name="l00188"></a>00188 <span class="preprocessor"></span>
+<a name="l00189"></a>00189 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCCPU-members.html b/ue3/doxygen/classCCPU-members.html
new file mode 100644
index 0000000..921d0e7
--- /dev/null
+++ b/ue3/doxygen/classCCPU-members.html
@@ -0,0 +1,42 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CCPU Member List</h1>This is the complete list of members for <a class="el" href="classCCPU.html">CCPU</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#12b0f403ddbfae0ff52cbf079b96395b">CCPU</a>(const unsigned cnt)</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#aab308415ce3083eaa66b9aa1dcbb0c6">getDisplays</a>()</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#c3d7d2bf5f93aa2d7b6f5959b8448ea2">getFlagSign</a>()</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#9398f58c5a715653c3502040029501a1">getFlagZero</a>()</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#47e3302a8d9582b29a4d722735d8aa60">getMemory</a>() const </td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#f7c34c0ba7230ecc980a5ff7730cdbae">getProgram</a>()</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#b25ee10ea09dfe12d9e77e5eb2126d32">getRegisterCount</a>() const </td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#efe3e22919627e5daf525d11b13d5c44">getRegisters</a>() const </td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#045df5c772702bdc1454fb90d512fb68">run</a>()</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#d8226c190477e2fbce0ddf7d814a272e">setFlagSign</a>(const bool value)</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#33c8a01cbafddb40cf9283109b3a0b08">setFlagZero</a>(const bool value)</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#bb2644a658cbfbcdd7c579a2840cee67">setMemory</a>(CMem *memory)</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#3790f6567091892f8867329424d03f71">setProgram</a>(const CProgram *program)</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCCPU.html#7523a3b0b832774c3df57bd019273a68">~CCPU</a>()</td><td><a class="el" href="classCCPU.html">CCPU</a></td><td></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCCPU.html b/ue3/doxygen/classCCPU.html
new file mode 100644
index 0000000..c888360
--- /dev/null
+++ b/ue3/doxygen/classCCPU.html
@@ -0,0 +1,578 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CCPU Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CCPU Class Reference</h1><!-- doxytag: class="CCPU" --><code>#include &lt;<a class="el" href="ccpu_8h-source.html">ccpu.h</a>&gt;</code>
+<p>
+
+<p>
+<a href="classCCPU-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#12b0f403ddbfae0ff52cbf079b96395b">CCPU</a> (const unsigned cnt)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default ctor.  <a href="#12b0f403ddbfae0ff52cbf079b96395b"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#7523a3b0b832774c3df57bd019273a68">~CCPU</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default dtor.  <a href="#7523a3b0b832774c3df57bd019273a68"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">const unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#b25ee10ea09dfe12d9e77e5eb2126d32">getRegisterCount</a> () const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get number of registers  <a href="#b25ee10ea09dfe12d9e77e5eb2126d32"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDat.html">CDat</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#efe3e22919627e5daf525d11b13d5c44">getRegisters</a> () const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get pointer to registers array  <a href="#efe3e22919627e5daf525d11b13d5c44"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#bb2644a658cbfbcdd7c579a2840cee67">setMemory</a> (<a class="el" href="classCMem.html">CMem</a> *memory)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">set memory of cpu  <a href="#bb2644a658cbfbcdd7c579a2840cee67"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCMem.html">CMem</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#47e3302a8d9582b29a4d722735d8aa60">getMemory</a> () const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get pointer to memory  <a href="#47e3302a8d9582b29a4d722735d8aa60"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#3790f6567091892f8867329424d03f71">setProgram</a> (const <a class="el" href="classCProgram.html">CProgram</a> *program)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">set program to execute  <a href="#3790f6567091892f8867329424d03f71"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">const <a class="el" href="classCProgram.html">CProgram</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#f7c34c0ba7230ecc980a5ff7730cdbae">getProgram</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get pointer to program  <a href="#f7c34c0ba7230ecc980a5ff7730cdbae"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">const std::set<br>
+&lt; <a class="el" href="classCDisplay.html">CDisplay</a> * &gt; &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#aab308415ce3083eaa66b9aa1dcbb0c6">getDisplays</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get set of pointers to displays  <a href="#aab308415ce3083eaa66b9aa1dcbb0c6"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#33c8a01cbafddb40cf9283109b3a0b08">setFlagZero</a> (const bool value)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">set zero flag  <a href="#33c8a01cbafddb40cf9283109b3a0b08"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">const bool&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#9398f58c5a715653c3502040029501a1">getFlagZero</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get value of zero flag  <a href="#9398f58c5a715653c3502040029501a1"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#d8226c190477e2fbce0ddf7d814a272e">setFlagSign</a> (const bool value)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">set sign flag  <a href="#d8226c190477e2fbce0ddf7d814a272e"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">const bool&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#c3d7d2bf5f93aa2d7b6f5959b8448ea2">getFlagSign</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get value of sign flag  <a href="#c3d7d2bf5f93aa2d7b6f5959b8448ea2"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCCPU.html#045df5c772702bdc1454fb90d512fb68">run</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">execute current program  <a href="#045df5c772702bdc1454fb90d512fb68"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+CPU implementation. Used as a container for memory and instructions. Implements a run method to execute the program (= the instructions). <hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a class="anchor" name="12b0f403ddbfae0ff52cbf079b96395b"></a><!-- doxytag: member="CCPU::CCPU" ref="12b0f403ddbfae0ff52cbf079b96395b" args="(const unsigned cnt)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">CCPU::CCPU           </td>
+          <td>(</td>
+          <td class="paramtype">const unsigned&nbsp;</td>
+          <td class="paramname"> <em>cnt</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default ctor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd><a class="el" href="classCCPU.html">CCPU</a> </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cnt</em>&nbsp;</td><td>number of registers to allocate for this cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="7523a3b0b832774c3df57bd019273a68"></a><!-- doxytag: member="CCPU::~CCPU" ref="7523a3b0b832774c3df57bd019273a68" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">CCPU::~CCPU           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default dtor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>~CCPU </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="b25ee10ea09dfe12d9e77e5eb2126d32"></a><!-- doxytag: member="CCPU::getRegisterCount" ref="b25ee10ea09dfe12d9e77e5eb2126d32" args="() const " -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const unsigned CCPU::getRegisterCount           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const<code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get number of registers 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getRegisterCount </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>number of registers </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="efe3e22919627e5daf525d11b13d5c44"></a><!-- doxytag: member="CCPU::getRegisters" ref="efe3e22919627e5daf525d11b13d5c44" args="() const " -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDat.html">CDat</a>* CCPU::getRegisters           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const<code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get pointer to registers array 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getRegisters </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>pointer to registers array </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="bb2644a658cbfbcdd7c579a2840cee67"></a><!-- doxytag: member="CCPU::setMemory" ref="bb2644a658cbfbcdd7c579a2840cee67" args="(CMem *memory)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CCPU::setMemory           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCMem.html">CMem</a> *&nbsp;</td>
+          <td class="paramname"> <em>memory</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+set memory of cpu 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>setMemory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>memory</em>&nbsp;</td><td>pointer to memory </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="47e3302a8d9582b29a4d722735d8aa60"></a><!-- doxytag: member="CCPU::getMemory" ref="47e3302a8d9582b29a4d722735d8aa60" args="() const " -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCMem.html">CMem</a>* CCPU::getMemory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const<code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get pointer to memory 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getMemory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>pointer to memory </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="3790f6567091892f8867329424d03f71"></a><!-- doxytag: member="CCPU::setProgram" ref="3790f6567091892f8867329424d03f71" args="(const CProgram *program)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CCPU::setProgram           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCProgram.html">CProgram</a> *&nbsp;</td>
+          <td class="paramname"> <em>program</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+set program to execute 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>setProgram </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>program</em>&nbsp;</td><td>pointer to program </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="f7c34c0ba7230ecc980a5ff7730cdbae"></a><!-- doxytag: member="CCPU::getProgram" ref="f7c34c0ba7230ecc980a5ff7730cdbae" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const <a class="el" href="classCProgram.html">CProgram</a>* CCPU::getProgram           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get pointer to program 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getProgram </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>pointer to program </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="aab308415ce3083eaa66b9aa1dcbb0c6"></a><!-- doxytag: member="CCPU::getDisplays" ref="aab308415ce3083eaa66b9aa1dcbb0c6" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const std::set&lt;<a class="el" href="classCDisplay.html">CDisplay</a> *&gt;&amp; CCPU::getDisplays           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get set of pointers to displays 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getDisplays </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>reference to set of pointers to displays </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="33c8a01cbafddb40cf9283109b3a0b08"></a><!-- doxytag: member="CCPU::setFlagZero" ref="33c8a01cbafddb40cf9283109b3a0b08" args="(const bool value)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CCPU::setFlagZero           </td>
+          <td>(</td>
+          <td class="paramtype">const bool&nbsp;</td>
+          <td class="paramname"> <em>value</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+set zero flag 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>setFlagZero </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>value</em>&nbsp;</td><td>new value of zero flag </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="9398f58c5a715653c3502040029501a1"></a><!-- doxytag: member="CCPU::getFlagZero" ref="9398f58c5a715653c3502040029501a1" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const bool CCPU::getFlagZero           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get value of zero flag 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getFlagZero </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>value of zero flag </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="d8226c190477e2fbce0ddf7d814a272e"></a><!-- doxytag: member="CCPU::setFlagSign" ref="d8226c190477e2fbce0ddf7d814a272e" args="(const bool value)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CCPU::setFlagSign           </td>
+          <td>(</td>
+          <td class="paramtype">const bool&nbsp;</td>
+          <td class="paramname"> <em>value</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+set sign flag 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>setFlagSign </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>value</em>&nbsp;</td><td>new value of sign flag </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="c3d7d2bf5f93aa2d7b6f5959b8448ea2"></a><!-- doxytag: member="CCPU::getFlagSign" ref="c3d7d2bf5f93aa2d7b6f5959b8448ea2" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const bool CCPU::getFlagSign           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get value of sign flag 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getFlagSign </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>value of sign flag </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="045df5c772702bdc1454fb90d512fb68"></a><!-- doxytag: member="CCPU::run" ref="045df5c772702bdc1454fb90d512fb68" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CCPU::run           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+execute current program 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>run </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="ccpu_8h-source.html">ccpu.h</a><li>mycpu/ccpu.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDat.html b/ue3/doxygen/classCDat.html
new file mode 100644
index 0000000..198ebc0
--- /dev/null
+++ b/ue3/doxygen/classCDat.html
@@ -0,0 +1,35 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CDat Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDat Class Reference</h1><!-- doxytag: class="CDat" --><code>#include &lt;<a class="el" href="cdat_8h-source.html">cdat.h</a>&gt;</code>
+<p>
+<table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Datatype for <a class="el" href="classCCPU.html">CCPU</a> and <a class="el" href="classCMem.html">CMem</a> <hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="cdat_8h-source.html">cdat.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDatT-members.html b/ue3/doxygen/classCDatT-members.html
new file mode 100644
index 0000000..a10a4d1
--- /dev/null
+++ b/ue3/doxygen/classCDatT-members.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDatT&lt; T &gt; Member List</h1>This is the complete list of members for <a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4">CDatT</a>()</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#e3b0f226b03d2aec0f5bc4f970eb7f3f">CDatT</a>(const CDatT &amp;other)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#acdea447eebaf3c22a4d378328181f45">CDatT</a>(T newval)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#8c226fb0b0974a0cbb7897d94f75e4e0">getValue</a>() const </td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#3ec7b2fac8d93e51cd87acda04d7f41e">operator &amp;=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#707446768fff0c8e9a56c4af874d0224">operator *=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#5915d4f7de6dceea7d0d7253ce8ff5c9">operator T</a>()</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#403d947a670fcc25dc0ae4e00293cc33">operator%=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#9a17a5e35049ad6a150ec800ddb81e64">operator++</a>()</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#f4f1e37bd94b17229dd0e181fcf41860">operator+=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#ec2be360ce61195c92db1ba4d2db0d8b">operator--</a>()</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#24cf91d1ac4e0277547ec158ed35544a">operator-=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#c68e6cd45ae94ef7485650e72f07c49d">operator/=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#acd2ef7a53a0c4b128485147171d0cbd">operator&lt;</a>(const CDatT &amp;x) const </td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#81465346cb4f31cf76336d46c512d0f6">operator&lt;&lt;</a>(std::ostream &amp;stream, CDatT cdat)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#884afb7b0c4e972c25f12f6eff15177d">operator==</a>(const CDatT &amp;x) const </td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#16f0666a0b7c3383eb965daf48134fab">operator&gt;&gt;</a>(std::istream &amp;stream, CDatT &amp;cdat)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#03cf22edd6b2489e63be6cc846de789f">operator^=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#f98140b24016e58307bf92b556157a13">operator|=</a>(const CDatT &amp;x)</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDatT.html#8ddaa1aaef85fea9e7c3613ccdc5a891">~CDatT</a>()</td><td><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDatT.html b/ue3/doxygen/classCDatT.html
new file mode 100644
index 0000000..017eda0
--- /dev/null
+++ b/ue3/doxygen/classCDatT.html
@@ -0,0 +1,879 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CDatT&lt; T &gt; Class Template Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDatT&lt; T &gt; Class Template Reference</h1><!-- doxytag: class="CDatT" --><code>#include &lt;<a class="el" href="cdat_8h-source.html">cdat.h</a>&gt;</code>
+<p>
+
+<p>
+<a href="classCDatT-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4">CDatT</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default ctor.  <a href="#afb8aa2eb6000ad2f54f31d6d5df57a4"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#8ddaa1aaef85fea9e7c3613ccdc5a891">~CDatT</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default dtor.  <a href="#8ddaa1aaef85fea9e7c3613ccdc5a891"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#e3b0f226b03d2aec0f5bc4f970eb7f3f">CDatT</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;other)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Copy constructor for <a class="el" href="classCDatT.html">CDatT</a>.  <a href="#e3b0f226b03d2aec0f5bc4f970eb7f3f"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#acdea447eebaf3c22a4d378328181f45">CDatT</a> (T newval)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Copy constructor for int.  <a href="#acdea447eebaf3c22a4d378328181f45"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">T&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#8c226fb0b0974a0cbb7897d94f75e4e0">getValue</a> () const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">returns value of <a class="el" href="classCDatT.html">CDatT</a>  <a href="#8c226fb0b0974a0cbb7897d94f75e4e0"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#5915d4f7de6dceea7d0d7253ce8ff5c9">operator T</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">convert to T  <a href="#5915d4f7de6dceea7d0d7253ce8ff5c9"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">bool&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#acd2ef7a53a0c4b128485147171d0cbd">operator&lt;</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x) const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator &lt;  <a href="#acd2ef7a53a0c4b128485147171d0cbd"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">bool&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#884afb7b0c4e972c25f12f6eff15177d">operator==</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x) const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator ==  <a href="#884afb7b0c4e972c25f12f6eff15177d"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#f4f1e37bd94b17229dd0e181fcf41860">operator+=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator +=  <a href="#f4f1e37bd94b17229dd0e181fcf41860"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#24cf91d1ac4e0277547ec158ed35544a">operator-=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator -=  <a href="#24cf91d1ac4e0277547ec158ed35544a"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#707446768fff0c8e9a56c4af874d0224">operator *=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator *=  <a href="#707446768fff0c8e9a56c4af874d0224"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#c68e6cd45ae94ef7485650e72f07c49d">operator/=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator /=  <a href="#c68e6cd45ae94ef7485650e72f07c49d"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#403d947a670fcc25dc0ae4e00293cc33">operator%=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator %=  <a href="#403d947a670fcc25dc0ae4e00293cc33"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#f98140b24016e58307bf92b556157a13">operator|=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator |=  <a href="#f98140b24016e58307bf92b556157a13"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#3ec7b2fac8d93e51cd87acda04d7f41e">operator &amp;=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator &amp;=  <a href="#3ec7b2fac8d93e51cd87acda04d7f41e"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#03cf22edd6b2489e63be6cc846de789f">operator^=</a> (const <a class="el" href="classCDatT.html">CDatT</a> &amp;x)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator ^=  <a href="#03cf22edd6b2489e63be6cc846de789f"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#9a17a5e35049ad6a150ec800ddb81e64">operator++</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator ++  <a href="#9a17a5e35049ad6a150ec800ddb81e64"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCDatT.html">CDatT</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#ec2be360ce61195c92db1ba4d2db0d8b">operator--</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator --  <a href="#ec2be360ce61195c92db1ba4d2db0d8b"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Friends</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::ostream &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#81465346cb4f31cf76336d46c512d0f6">operator&lt;&lt;</a> (std::ostream &amp;stream, <a class="el" href="classCDatT.html">CDatT</a> cdat)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Shift/output operator for outputstream.  <a href="#81465346cb4f31cf76336d46c512d0f6"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::istream &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDatT.html#16f0666a0b7c3383eb965daf48134fab">operator&gt;&gt;</a> (std::istream &amp;stream, <a class="el" href="classCDatT.html">CDatT</a> &amp;cdat)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Shift/read operator for inputstream.  <a href="#16f0666a0b7c3383eb965daf48134fab"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+<h3>template&lt;class T&gt;<br>
+ class CDatT&lt; T &gt;</h3>
+
+Datatype template for <a class="el" href="classCCPU.html">CCPU</a> and <a class="el" href="classCMem.html">CMem</a>. <hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a class="anchor" name="afb8aa2eb6000ad2f54f31d6d5df57a4"></a><!-- doxytag: member="CDatT::CDatT" ref="afb8aa2eb6000ad2f54f31d6d5df57a4" args="()" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::<a class="el" href="classCDatT.html">CDatT</a>           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default ctor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd><a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>bad_alloc</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="8ddaa1aaef85fea9e7c3613ccdc5a891"></a><!-- doxytag: member="CDatT::~CDatT" ref="8ddaa1aaef85fea9e7c3613ccdc5a891" args="()" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::~<a class="el" href="classCDatT.html">CDatT</a>           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default dtor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>~CDatT </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="e3b0f226b03d2aec0f5bc4f970eb7f3f"></a><!-- doxytag: member="CDatT::CDatT" ref="e3b0f226b03d2aec0f5bc4f970eb7f3f" args="(const CDatT &amp;other)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::<a class="el" href="classCDatT.html">CDatT</a>           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>other</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Copy constructor for <a class="el" href="classCDatT.html">CDatT</a>. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd><a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>other</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> which will be copied </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="acdea447eebaf3c22a4d378328181f45"></a><!-- doxytag: member="CDatT::CDatT" ref="acdea447eebaf3c22a4d378328181f45" args="(T newval)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::<a class="el" href="classCDatT.html">CDatT</a>           </td>
+          <td>(</td>
+          <td class="paramtype">T&nbsp;</td>
+          <td class="paramname"> <em>newval</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Copy constructor for int. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd><a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>newval</em>&nbsp;</td><td>new value for <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="8c226fb0b0974a0cbb7897d94f75e4e0"></a><!-- doxytag: member="CDatT::getValue" ref="8c226fb0b0974a0cbb7897d94f75e4e0" args="() const " -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">T <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::getValue           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const<code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+returns value of <a class="el" href="classCDatT.html">CDatT</a> 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getValue </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>value of <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="5915d4f7de6dceea7d0d7253ce8ff5c9"></a><!-- doxytag: member="CDatT::operator T" ref="5915d4f7de6dceea7d0d7253ce8ff5c9" args="()" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator T           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+convert to T 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator T </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>T </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="acd2ef7a53a0c4b128485147171d0cbd"></a><!-- doxytag: member="CDatT::operator&lt;" ref="acd2ef7a53a0c4b128485147171d0cbd" args="(const CDatT &amp;x) const " -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">bool <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator&lt;           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const<code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator &lt; 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator&lt; </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>true if cdat is less than object x </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="884afb7b0c4e972c25f12f6eff15177d"></a><!-- doxytag: member="CDatT::operator==" ref="884afb7b0c4e972c25f12f6eff15177d" args="(const CDatT &amp;x) const " -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">bool <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator==           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const<code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator == 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator== </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>true if cdat equals object x </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="f4f1e37bd94b17229dd0e181fcf41860"></a><!-- doxytag: member="CDatT::operator+=" ref="f4f1e37bd94b17229dd0e181fcf41860" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator+=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator += 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator+= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="24cf91d1ac4e0277547ec158ed35544a"></a><!-- doxytag: member="CDatT::operator-=" ref="24cf91d1ac4e0277547ec158ed35544a" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator-=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator -= 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator-= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="707446768fff0c8e9a56c4af874d0224"></a><!-- doxytag: member="CDatT::operator *=" ref="707446768fff0c8e9a56c4af874d0224" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator *=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator *= 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator*= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="c68e6cd45ae94ef7485650e72f07c49d"></a><!-- doxytag: member="CDatT::operator/=" ref="c68e6cd45ae94ef7485650e72f07c49d" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator/=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator /= 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator/= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="403d947a670fcc25dc0ae4e00293cc33"></a><!-- doxytag: member="CDatT::operator%=" ref="403d947a670fcc25dc0ae4e00293cc33" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator%=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator %= 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator%= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="f98140b24016e58307bf92b556157a13"></a><!-- doxytag: member="CDatT::operator|=" ref="f98140b24016e58307bf92b556157a13" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator|=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator |= 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator|= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="3ec7b2fac8d93e51cd87acda04d7f41e"></a><!-- doxytag: member="CDatT::operator &amp;=" ref="3ec7b2fac8d93e51cd87acda04d7f41e" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator &amp;=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator &amp;= 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator&amp;= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="03cf22edd6b2489e63be6cc846de789f"></a><!-- doxytag: member="CDatT::operator^=" ref="03cf22edd6b2489e63be6cc846de789f" args="(const CDatT &amp;x)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator^=           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>x</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator ^= 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator^= </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>x</em>&nbsp;</td><td>reference to <a class="el" href="classCDatT.html">CDatT</a> </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="9a17a5e35049ad6a150ec800ddb81e64"></a><!-- doxytag: member="CDatT::operator++" ref="9a17a5e35049ad6a150ec800ddb81e64" args="()" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator++           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator ++ 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator++ </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="ec2be360ce61195c92db1ba4d2db0d8b"></a><!-- doxytag: member="CDatT::operator--" ref="ec2be360ce61195c92db1ba4d2db0d8b" args="()" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDatT.html">CDatT</a>&amp; <a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;::operator--           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator -- 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator-- </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>refecence to <a class="el" href="classCDatT.html">CDatT</a> </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Friends And Related Function Documentation</h2>
+<a class="anchor" name="81465346cb4f31cf76336d46c512d0f6"></a><!-- doxytag: member="CDatT::operator&lt;&lt;" ref="81465346cb4f31cf76336d46c512d0f6" args="(std::ostream &amp;stream, CDatT cdat)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">std::ostream&amp; operator&lt;&lt;           </td>
+          <td>(</td>
+          <td class="paramtype">std::ostream &amp;&nbsp;</td>
+          <td class="paramname"> <em>stream</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype"><a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt;&nbsp;</td>
+          <td class="paramname"> <em>cdat</em></td><td>&nbsp;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td><td width="100%"><code> [friend]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Shift/output operator for outputstream. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator&lt;&lt; </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>stream</em>&nbsp;</td><td>reference to outputstream </td></tr>
+    <tr><td valign="top"></td><td valign="top"><em>cdat</em>&nbsp;</td><td>object which will be printed to stream </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>reference to outputstream </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="16f0666a0b7c3383eb965daf48134fab"></a><!-- doxytag: member="CDatT::operator&gt;&gt;" ref="16f0666a0b7c3383eb965daf48134fab" args="(std::istream &amp;stream, CDatT &amp;cdat)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">std::istream&amp; operator&gt;&gt;           </td>
+          <td>(</td>
+          <td class="paramtype">std::istream &amp;&nbsp;</td>
+          <td class="paramname"> <em>stream</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype"><a class="el" href="classCDatT.html">CDatT</a>&lt; T &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>cdat</em></td><td>&nbsp;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td><td width="100%"><code> [friend]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Shift/read operator for inputstream. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator&gt;&gt; </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>stream</em>&nbsp;</td><td>reference to inputstream </td></tr>
+    <tr><td valign="top"></td><td valign="top"><em>cdat</em>&nbsp;</td><td>reference to object which will be read from stream </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>reference to inputstream </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="cdat_8h-source.html">cdat.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplay.html b/ue3/doxygen/classCDisplay.html
new file mode 100644
index 0000000..90ab9c9
--- /dev/null
+++ b/ue3/doxygen/classCDisplay.html
@@ -0,0 +1,45 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CDisplay Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDisplay Class Reference</h1><!-- doxytag: class="CDisplay" --><code>#include &lt;<a class="el" href="cdisplay_8h-source.html">cdisplay.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CDisplay:</div>
+<div class="dynsection">
+
+<p><center><img src="classCDisplay.png" usemap="#CDisplay_map" border="0" alt=""></center>
+<map name="CDisplay_map">
+<area href="classCDisplayWDEZ.html" alt="CDisplayWDEZ" shape="rect" coords="0,56,100,80">
+<area href="classCDisplayWHEX.html" alt="CDisplayWHEX" shape="rect" coords="110,56,210,80">
+</map>
+</div>
+<table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Memory definition for <a class="el" href="classCCPU.html">CCPU</a> <hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="cdisplay_8h-source.html">cdisplay.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplay.png b/ue3/doxygen/classCDisplay.png
new file mode 100644
index 0000000..6aee098
Binary files /dev/null and b/ue3/doxygen/classCDisplay.png differ
diff --git a/ue3/doxygen/classCDisplayT-members.html b/ue3/doxygen/classCDisplayT-members.html
new file mode 100644
index 0000000..248f8bd
--- /dev/null
+++ b/ue3/doxygen/classCDisplayT-members.html
@@ -0,0 +1,33 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDisplayT&lt; T &gt; Member List</h1>This is the complete list of members for <a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCDisplayT.html#d65d27ce8533285525788f3cc534ff14">CDisplayT</a>(std::string name)</td><td><a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDisplayT.html#5a15f96d3d76bdbb2b172c52036859c2">display</a>(const T &amp;value)=0</td><td><a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a></td><td><code> [pure virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDisplayT.html#32897b9abaec6e9a0e73ae746ab5cec0">getName</a>()</td><td><a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">m_name</a></td><td><a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDisplayT.html#edeeab4320b2c3a5b482d216e73e5999">~CDisplayT</a>()</td><td><a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplayT.html b/ue3/doxygen/classCDisplayT.html
new file mode 100644
index 0000000..e837e43
--- /dev/null
+++ b/ue3/doxygen/classCDisplayT.html
@@ -0,0 +1,227 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CDisplayT&lt; T &gt; Class Template Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDisplayT&lt; T &gt; Class Template Reference</h1><!-- doxytag: class="CDisplayT" --><code>#include &lt;<a class="el" href="cdisplay_8h-source.html">cdisplay.h</a>&gt;</code>
+<p>
+
+<p>
+<a href="classCDisplayT-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDisplayT.html#d65d27ce8533285525788f3cc534ff14">CDisplayT</a> (std::string name)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default ctor.  <a href="#d65d27ce8533285525788f3cc534ff14"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDisplayT.html#edeeab4320b2c3a5b482d216e73e5999">~CDisplayT</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default dtor.  <a href="#edeeab4320b2c3a5b482d216e73e5999"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual const <br>
+std::string &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDisplayT.html#32897b9abaec6e9a0e73ae746ab5cec0">getName</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">returns name of display  <a href="#32897b9abaec6e9a0e73ae746ab5cec0"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDisplayT.html#5a15f96d3d76bdbb2b172c52036859c2">display</a> (const T &amp;value)=0</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">prints value to display  <a href="#5a15f96d3d76bdbb2b172c52036859c2"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::string&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">m_name</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+<h3>template&lt;class T&gt;<br>
+ class CDisplayT&lt; T &gt;</h3>
+
+Abstract template class for displays <hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a class="anchor" name="d65d27ce8533285525788f3cc534ff14"></a><!-- doxytag: member="CDisplayT::CDisplayT" ref="d65d27ce8533285525788f3cc534ff14" args="(std::string name)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCDisplayT.html">CDisplayT</a>&lt; T &gt;::<a class="el" href="classCDisplayT.html">CDisplayT</a>           </td>
+          <td>(</td>
+          <td class="paramtype">std::string&nbsp;</td>
+          <td class="paramname"> <em>name</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default ctor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd><a class="el" href="classCDisplayT.html">CDisplayT</a> </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>name</em>&nbsp;</td><td>name of display </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="edeeab4320b2c3a5b482d216e73e5999"></a><!-- doxytag: member="CDisplayT::~CDisplayT" ref="edeeab4320b2c3a5b482d216e73e5999" args="()" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual <a class="el" href="classCDisplayT.html">CDisplayT</a>&lt; T &gt;::~<a class="el" href="classCDisplayT.html">CDisplayT</a>           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default dtor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>~CDisplayT </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="32897b9abaec6e9a0e73ae746ab5cec0"></a><!-- doxytag: member="CDisplayT::getName" ref="32897b9abaec6e9a0e73ae746ab5cec0" args="()" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual const std::string&amp; <a class="el" href="classCDisplayT.html">CDisplayT</a>&lt; T &gt;::getName           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+returns name of display 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getName </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>name of display </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="5a15f96d3d76bdbb2b172c52036859c2"></a><!-- doxytag: member="CDisplayT::display" ref="5a15f96d3d76bdbb2b172c52036859c2" args="(const T &amp;value)=0" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual void <a class="el" href="classCDisplayT.html">CDisplayT</a>&lt; T &gt;::display           </td>
+          <td>(</td>
+          <td class="paramtype">const T &amp;&nbsp;</td>
+          <td class="paramname"> <em>value</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [pure virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+prints value to display 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>display </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>value</em>&nbsp;</td><td>value to display </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="ba8ab4d4abe2426b266660134efb370f"></a><!-- doxytag: member="CDisplayT::m_name" ref="ba8ab4d4abe2426b266660134efb370f" args="" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">std::string <a class="el" href="classCDisplayT.html">CDisplayT</a>&lt; T &gt;::<a class="el" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">m_name</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+name of display 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="cdisplay_8h-source.html">cdisplay.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplayWDEZ-members.html b/ue3/doxygen/classCDisplayWDEZ-members.html
new file mode 100644
index 0000000..eadb3c0
--- /dev/null
+++ b/ue3/doxygen/classCDisplayWDEZ-members.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDisplayWDEZ Member List</h1>This is the complete list of members for <a class="el" href="classCDisplayWDEZ.html">CDisplayWDEZ</a>, including all inherited members.<p><table>
+  <tr bgcolor="#f0f0f0"><td><b>CDisplayWDEZ</b>() (defined in <a class="el" href="classCDisplayWDEZ.html">CDisplayWDEZ</a>)</td><td><a class="el" href="classCDisplayWDEZ.html">CDisplayWDEZ</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDisplayWDEZ.html#91798e80f37ec86e3aa7d0f899e3a8dc">display</a>(const CDat &amp;value)</td><td><a class="el" href="classCDisplayWDEZ.html">CDisplayWDEZ</a></td><td><code> [inline]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplayWDEZ.html b/ue3/doxygen/classCDisplayWDEZ.html
new file mode 100644
index 0000000..dfc9ae9
--- /dev/null
+++ b/ue3/doxygen/classCDisplayWDEZ.html
@@ -0,0 +1,87 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CDisplayWDEZ Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDisplayWDEZ Class Reference</h1><!-- doxytag: class="CDisplayWDEZ" --><!-- doxytag: inherits="CDisplay" --><code>#include &lt;<a class="el" href="displays_8h-source.html">displays.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CDisplayWDEZ:</div>
+<div class="dynsection">
+
+<p><center><img src="classCDisplayWDEZ.png" usemap="#CDisplayWDEZ_map" border="0" alt=""></center>
+<map name="CDisplayWDEZ_map">
+<area href="classCDisplay.html" alt="CDisplay" shape="rect" coords="0,0,100,24">
+</map>
+</div>
+
+<p>
+<a href="classCDisplayWDEZ-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDisplayWDEZ.html#91798e80f37ec86e3aa7d0f899e3a8dc">display</a> (const <a class="el" href="classCDat.html">CDat</a> &amp;value)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">prints value to display  <a href="#91798e80f37ec86e3aa7d0f899e3a8dc"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of <a class="el" href="classCDisplay.html">CDisplay</a> Prints <a class="el" href="classCDat.html">CDat</a> to stdout as decimal <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="91798e80f37ec86e3aa7d0f899e3a8dc"></a><!-- doxytag: member="CDisplayWDEZ::display" ref="91798e80f37ec86e3aa7d0f899e3a8dc" args="(const CDat &amp;value)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CDisplayWDEZ::display           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDat.html">CDat</a> &amp;&nbsp;</td>
+          <td class="paramname"> <em>value</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+prints value to display 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>display </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>value</em>&nbsp;</td><td>value to display </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="displays_8h-source.html">displays.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplayWDEZ.png b/ue3/doxygen/classCDisplayWDEZ.png
new file mode 100644
index 0000000..10fe751
Binary files /dev/null and b/ue3/doxygen/classCDisplayWDEZ.png differ
diff --git a/ue3/doxygen/classCDisplayWHEX-members.html b/ue3/doxygen/classCDisplayWHEX-members.html
new file mode 100644
index 0000000..d00d3bc
--- /dev/null
+++ b/ue3/doxygen/classCDisplayWHEX-members.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDisplayWHEX Member List</h1>This is the complete list of members for <a class="el" href="classCDisplayWHEX.html">CDisplayWHEX</a>, including all inherited members.<p><table>
+  <tr bgcolor="#f0f0f0"><td><b>CDisplayWHEX</b>() (defined in <a class="el" href="classCDisplayWHEX.html">CDisplayWHEX</a>)</td><td><a class="el" href="classCDisplayWHEX.html">CDisplayWHEX</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCDisplayWHEX.html#6adaa6532cd684060029e31457d83752">display</a>(const CDat &amp;value)</td><td><a class="el" href="classCDisplayWHEX.html">CDisplayWHEX</a></td><td><code> [inline]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplayWHEX.html b/ue3/doxygen/classCDisplayWHEX.html
new file mode 100644
index 0000000..bc2d8f1
--- /dev/null
+++ b/ue3/doxygen/classCDisplayWHEX.html
@@ -0,0 +1,87 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CDisplayWHEX Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CDisplayWHEX Class Reference</h1><!-- doxytag: class="CDisplayWHEX" --><!-- doxytag: inherits="CDisplay" --><code>#include &lt;<a class="el" href="displays_8h-source.html">displays.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CDisplayWHEX:</div>
+<div class="dynsection">
+
+<p><center><img src="classCDisplayWHEX.png" usemap="#CDisplayWHEX_map" border="0" alt=""></center>
+<map name="CDisplayWHEX_map">
+<area href="classCDisplay.html" alt="CDisplay" shape="rect" coords="0,0,100,24">
+</map>
+</div>
+
+<p>
+<a href="classCDisplayWHEX-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCDisplayWHEX.html#6adaa6532cd684060029e31457d83752">display</a> (const <a class="el" href="classCDat.html">CDat</a> &amp;value)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">prints value to display  <a href="#6adaa6532cd684060029e31457d83752"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of <a class="el" href="classCDisplay.html">CDisplay</a> Prints <a class="el" href="classCDat.html">CDat</a> to stdout as decimal <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="6adaa6532cd684060029e31457d83752"></a><!-- doxytag: member="CDisplayWHEX::display" ref="6adaa6532cd684060029e31457d83752" args="(const CDat &amp;value)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CDisplayWHEX::display           </td>
+          <td>(</td>
+          <td class="paramtype">const <a class="el" href="classCDat.html">CDat</a> &amp;&nbsp;</td>
+          <td class="paramname"> <em>value</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+prints value to display 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>display </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>value</em>&nbsp;</td><td>value to display </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="displays_8h-source.html">displays.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCDisplayWHEX.png b/ue3/doxygen/classCDisplayWHEX.png
new file mode 100644
index 0000000..67b90b6
Binary files /dev/null and b/ue3/doxygen/classCDisplayWHEX.png differ
diff --git a/ue3/doxygen/classCInstruction-members.html b/ue3/doxygen/classCInstruction-members.html
new file mode 100644
index 0000000..e22ff7f
--- /dev/null
+++ b/ue3/doxygen/classCInstruction-members.html
@@ -0,0 +1,41 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstruction Member List</h1>This is the complete list of members for <a class="el" href="classCInstruction.html">CInstruction</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">compile</a>(std::list&lt; std::string &gt; &amp;params)=0</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [pure virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">execute</a>(CCPU *cpu)=0</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [pure virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">factory</a>()=0</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [pure virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstruction.html b/ue3/doxygen/classCInstruction.html
new file mode 100644
index 0000000..052da01
--- /dev/null
+++ b/ue3/doxygen/classCInstruction.html
@@ -0,0 +1,575 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstruction Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstruction Class Reference</h1><!-- doxytag: class="CInstruction" --><code>#include &lt;<a class="el" href="cinstruction_8h-source.html">cinstruction.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstruction:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstruction.png" usemap="#CInstruction_map" border="0" alt=""></center>
+<map name="CInstruction_map">
+<area href="classCInstructionAdd.html" alt="CInstructionAdd" shape="rect" coords="128,56,246,80">
+<area href="classCInstructionDec.html" alt="CInstructionDec" shape="rect" coords="128,112,246,136">
+<area href="classCInstructionDiv.html" alt="CInstructionDiv" shape="rect" coords="128,168,246,192">
+<area href="classCInstructionInc.html" alt="CInstructionInc" shape="rect" coords="128,224,246,248">
+<area href="classCInstructionJumpA.html" alt="CInstructionJumpA" shape="rect" coords="128,280,246,304">
+<area href="classCInstructionJumpS.html" alt="CInstructionJumpS" shape="rect" coords="128,336,246,360">
+<area href="classCInstructionJumpZ.html" alt="CInstructionJumpZ" shape="rect" coords="128,392,246,416">
+<area href="classCInstructionLabel.html" alt="CInstructionLabel" shape="rect" coords="128,448,246,472">
+<area href="classCInstructionLoad.html" alt="CInstructionLoad" shape="rect" coords="128,504,246,528">
+<area href="classCInstructionMul.html" alt="CInstructionMul" shape="rect" coords="128,560,246,584">
+<area href="classCInstructionStore.html" alt="CInstructionStore" shape="rect" coords="128,616,246,640">
+<area href="classCInstructionSub.html" alt="CInstructionSub" shape="rect" coords="128,672,246,696">
+<area href="classCInstructionTest.html" alt="CInstructionTest" shape="rect" coords="128,728,246,752">
+<area href="classCInstructionWrite.html" alt="CInstructionWrite" shape="rect" coords="128,784,246,808">
+</map>
+</div>
+
+<p>
+<a href="classCInstruction-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a> (std::string name)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default ctor.  <a href="#263195c9e1f109bf44f7040727dcfa78"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default dtor.  <a href="#d2ded1d8675749bc39a085a8c50a6612"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a> (std::string &amp;name)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator ==  <a href="#395c9bde315efbc0eefd0bbb1586950a"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual <a class="el" href="classCInstruction.html">CInstruction</a> &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">implementation of operator (<a class="el" href="classCCPU.html">CCPU</a>)  <a href="#b5b2364b0cccc6db2f5c3aaccee8aa43"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual const <br>
+std::string &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">returns instruction name  <a href="#e8187580097fd2ced5a8bc6e6e09fe44"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual std::ostream &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a> (std::ostream &amp;stream)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">dumps information about instruction to outputstream  <a href="#040a2394e2161a65f37ef31d16bb6a35"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual const unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a> (const std::string &amp;str)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses register syntax Rx (e.g. "R1")  <a href="#2723f8875ff0cc4e48d840db1ae5b4a8"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu, const unsigned regidx)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">performs a register boundary check does the register exist in cpu?  <a href="#8e938360a34f1cd3bf799f21e2ce6f6c"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual <a class="el" href="classCInstruction.html">CInstruction</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">factory</a> ()=0</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#fae8dc231b375db91f874df0d085b7dc"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">compile</a> (std::list&lt; std::string &gt; &amp;params)=0</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#15e2ce88b04fcf208ba43c43f7dd57aa"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)=0</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#127fd09a772e9f584550cd342af770d1"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::string&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td></tr>
+
+<tr><td colspan="2"><br><h2>Friends</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::ostream &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a> (std::ostream &amp;stream, <a class="el" href="classCInstruction.html">CInstruction</a> &amp;instr)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Shift/output operator for outputstream.  <a href="#7651b4c147411bca34a0393adf03507d"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Abstract class for displays <hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a class="anchor" name="263195c9e1f109bf44f7040727dcfa78"></a><!-- doxytag: member="CInstruction::CInstruction" ref="263195c9e1f109bf44f7040727dcfa78" args="(std::string name)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">CInstruction::CInstruction           </td>
+          <td>(</td>
+          <td class="paramtype">std::string&nbsp;</td>
+          <td class="paramname"> <em>name</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default ctor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd><a class="el" href="classCInstruction.html">CInstruction</a> </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>name</em>&nbsp;</td><td>name of instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="d2ded1d8675749bc39a085a8c50a6612"></a><!-- doxytag: member="CInstruction::~CInstruction" ref="d2ded1d8675749bc39a085a8c50a6612" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual CInstruction::~CInstruction           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default dtor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>~CInstruction </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="395c9bde315efbc0eefd0bbb1586950a"></a><!-- doxytag: member="CInstruction::operator==" ref="395c9bde315efbc0eefd0bbb1586950a" args="(std::string &amp;name)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual bool CInstruction::operator==           </td>
+          <td>(</td>
+          <td class="paramtype">std::string &amp;&nbsp;</td>
+          <td class="paramname"> <em>name</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator == 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator== </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>name</em>&nbsp;</td><td>reference to std::string </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>true if instructionname is name </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="b5b2364b0cccc6db2f5c3aaccee8aa43"></a><!-- doxytag: member="CInstruction::operator()" ref="b5b2364b0cccc6db2f5c3aaccee8aa43" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual <a class="el" href="classCInstruction.html">CInstruction</a>&amp; CInstruction::operator()           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+implementation of operator (<a class="el" href="classCCPU.html">CCPU</a>) 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator() </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="e8187580097fd2ced5a8bc6e6e09fe44"></a><!-- doxytag: member="CInstruction::getName" ref="e8187580097fd2ced5a8bc6e6e09fe44" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual const std::string&amp; CInstruction::getName           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+returns instruction name 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getName </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>name of instruction </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="040a2394e2161a65f37ef31d16bb6a35"></a><!-- doxytag: member="CInstruction::dump" ref="040a2394e2161a65f37ef31d16bb6a35" args="(std::ostream &amp;stream)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual std::ostream&amp; CInstruction::dump           </td>
+          <td>(</td>
+          <td class="paramtype">std::ostream &amp;&nbsp;</td>
+          <td class="paramname"> <em>stream</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+dumps information about instruction to outputstream 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>dump </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>stream</em>&nbsp;</td><td>outputstream </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>reference to outputstream </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="2723f8875ff0cc4e48d840db1ae5b4a8"></a><!-- doxytag: member="CInstruction::parseRegister" ref="2723f8875ff0cc4e48d840db1ae5b4a8" args="(const std::string &amp;str)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const unsigned CInstruction::parseRegister           </td>
+          <td>(</td>
+          <td class="paramtype">const std::string &amp;&nbsp;</td>
+          <td class="paramname"> <em>str</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses register syntax Rx (e.g. "R1") 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>parseRegister </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>str</em>&nbsp;</td><td>register in assembler syntax </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>registernumber </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="8e938360a34f1cd3bf799f21e2ce6f6c"></a><!-- doxytag: member="CInstruction::checkRegister" ref="8e938360a34f1cd3bf799f21e2ce6f6c" args="(CCPU *cpu, const unsigned regidx)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstruction::checkRegister           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned&nbsp;</td>
+          <td class="paramname"> <em>regidx</em></td><td>&nbsp;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td><td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+performs a register boundary check does the register exist in cpu? 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>checkRegister </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+    <tr><td valign="top"></td><td valign="top"><em>regidx</em>&nbsp;</td><td>registernumber </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="fae8dc231b375db91f874df0d085b7dc"></a><!-- doxytag: member="CInstruction::factory" ref="fae8dc231b375db91f874df0d085b7dc" args="()=0" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual <a class="el" href="classCInstruction.html">CInstruction</a>* CInstruction::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [pure virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implemented in <a class="el" href="classCInstructionInc.html#d55c35cbbd5c88fd29a392051e79f5f1">CInstructionInc</a>, <a class="el" href="classCInstructionDec.html#5aa3bcd55f05765e25758f45f4f55059">CInstructionDec</a>, <a class="el" href="classCInstructionAdd.html#6fa9bae98f84f5ae34946641fb03ff32">CInstructionAdd</a>, <a class="el" href="classCInstructionSub.html#71c77a5113f96ac25e79bc4d28072541">CInstructionSub</a>, <a class="el" href="classCInstructionMul.html#1e8f23073a29a0d50fa9d651b986e821">CInstructionMul</a>, <a class="el" href="classCInstructionDiv.html#3445767e66ab734ec88b6084a10c4446">CInstructionDiv</a>, <a class="el" href="classCInstructionLoad.html#35c051515ccd6a12dbb39ab4b2e33ded">CInstructionLoad</a>, <a class="el" href="classCInstructionStore.html#cab0d4c9bf2cc0d6b1b450ef9aeebcc0">CInstructionStore</a>, <a class="el" href="classCInstructionTest.html#9e4e1ac29b5173a70dc1172bbb096671">CInstructionTest</a>, <a class="el" href="classCInstructionLabel.html#66ba5bd6facecd45f3616fc94eb2845f">CInstructionLabel</a>, <a class="el" href="classCInstructionJumpA.html#d7679ea0d70ab9725f84dcce76adc057">CInstructionJumpA</a>, <a class="el" href="classCInstructionJumpZ.html#e0750f1ce4a5746be3317024f4ef92eb">CInstructionJumpZ</a>, <a class="el" href="classCInstructionJumpS.html#4b25703a62dafb568700dcad217f7ba6">CInstructionJumpS</a>, and <a class="el" href="classCInstructionWrite.html#a33ddc8fb13dfaa253704eb0952f3cea">CInstructionWrite</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="15e2ce88b04fcf208ba43c43f7dd57aa"></a><!-- doxytag: member="CInstruction::compile" ref="15e2ce88b04fcf208ba43c43f7dd57aa" args="(std::list&lt; std::string &gt; &amp;params)=0" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual void CInstruction::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [pure virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implemented in <a class="el" href="classCInstructionInc.html#ae36e952ec66b1c5cc2fb7e7c80064cc">CInstructionInc</a>, <a class="el" href="classCInstructionDec.html#84347e9b3a373bafc5c1ae79a557f4c3">CInstructionDec</a>, <a class="el" href="classCInstructionAdd.html#1da9f4b4016d27f2866add0b91e3b0fc">CInstructionAdd</a>, <a class="el" href="classCInstructionSub.html#9fe6d8f0f805313c98f8806a4739cbe9">CInstructionSub</a>, <a class="el" href="classCInstructionMul.html#188024d90dd19fcea0687d32e98c67a7">CInstructionMul</a>, <a class="el" href="classCInstructionDiv.html#349324231c5516886d99caf07ecb8c0c">CInstructionDiv</a>, <a class="el" href="classCInstructionLoad.html#4aa70fe481286e0bcc27f7a9ce896d3d">CInstructionLoad</a>, <a class="el" href="classCInstructionStore.html#9848bf36bd3ec75ae481d8ef1f36c6ee">CInstructionStore</a>, <a class="el" href="classCInstructionTest.html#b09f0e02ab71b01af6eda0152d1fc975">CInstructionTest</a>, <a class="el" href="classCInstructionLabel.html#321fd849ae169d900964431b4100321f">CInstructionLabel</a>, <a class="el" href="classCInstructionJumpA.html#f772a57214b192263594d2ff46f03a1e">CInstructionJumpA</a>, <a class="el" href="classCInstructionJumpZ.html#e4c05192b829d2bcc1e838de195ef3d9">CInstructionJumpZ</a>, <a class="el" href="classCInstructionJumpS.html#671d749a6e93f26851879c4ceac09f4c">CInstructionJumpS</a>, and <a class="el" href="classCInstructionWrite.html#23f5bb8e4b8a74f7a8703d593323b991">CInstructionWrite</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="127fd09a772e9f584550cd342af770d1"></a><!-- doxytag: member="CInstruction::execute" ref="127fd09a772e9f584550cd342af770d1" args="(CCPU *cpu)=0" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">virtual void CInstruction::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [pure virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implemented in <a class="el" href="classCInstructionInc.html#2830b4c1aa89410e309821119ecf4d6f">CInstructionInc</a>, <a class="el" href="classCInstructionDec.html#b0a51da3b41aaa4e3e51baaa4151ebca">CInstructionDec</a>, <a class="el" href="classCInstructionAdd.html#3c6844fd425de436ba3e7fbc98fd69e8">CInstructionAdd</a>, <a class="el" href="classCInstructionSub.html#03e098595198d4cc2f45d906e45e7f28">CInstructionSub</a>, <a class="el" href="classCInstructionMul.html#0675f51cbfb5d0d76e605f64b0b2555c">CInstructionMul</a>, <a class="el" href="classCInstructionDiv.html#7fee4e02bc6904c9d6039aa467aed1f4">CInstructionDiv</a>, <a class="el" href="classCInstructionLoad.html#fdda1d554401f9bfd32a6300f5ad2bb6">CInstructionLoad</a>, <a class="el" href="classCInstructionStore.html#fd5ee6692540613ee8cc9a2bf8ff920a">CInstructionStore</a>, <a class="el" href="classCInstructionTest.html#955cf58c41c9e305059baea28b65cf3a">CInstructionTest</a>, <a class="el" href="classCInstructionLabel.html#665f2fc395ffed3bd968659f67868f53">CInstructionLabel</a>, <a class="el" href="classCInstructionJumpA.html#76daeedb9c7cb3be0173580be9390887">CInstructionJumpA</a>, <a class="el" href="classCInstructionJumpZ.html#92f15deda156ebd20e8af47589753783">CInstructionJumpZ</a>, <a class="el" href="classCInstructionJumpS.html#8c2e8e077463e64ca64204bb6ed20f71">CInstructionJumpS</a>, and <a class="el" href="classCInstructionWrite.html#1852e50c21b758a4db205a6cd20e208d">CInstructionWrite</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Friends And Related Function Documentation</h2>
+<a class="anchor" name="7651b4c147411bca34a0393adf03507d"></a><!-- doxytag: member="CInstruction::operator&lt;&lt;" ref="7651b4c147411bca34a0393adf03507d" args="(std::ostream &amp;stream, CInstruction &amp;instr)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">std::ostream&amp; operator&lt;&lt;           </td>
+          <td>(</td>
+          <td class="paramtype">std::ostream &amp;&nbsp;</td>
+          <td class="paramname"> <em>stream</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype"><a class="el" href="classCInstruction.html">CInstruction</a> &amp;&nbsp;</td>
+          <td class="paramname"> <em>instr</em></td><td>&nbsp;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td><td width="100%"><code> [friend]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Shift/output operator for outputstream. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>operator&lt;&lt; </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>stream</em>&nbsp;</td><td>reference to outputstream </td></tr>
+    <tr><td valign="top"></td><td valign="top"><em>instr</em>&nbsp;</td><td>object which will be printed to stream </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>reference to outputstream </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="0c3b94ae1323d6201d2afd20c8686194"></a><!-- doxytag: member="CInstruction::m_name" ref="0c3b94ae1323d6201d2afd20c8686194" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">std::string <a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">CInstruction::m_name</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+name of instruction 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="cinstruction_8h-source.html">cinstruction.h</a><li>mycpu/cinstruction.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstruction.png b/ue3/doxygen/classCInstruction.png
new file mode 100644
index 0000000..e04bf41
Binary files /dev/null and b/ue3/doxygen/classCInstruction.png differ
diff --git a/ue3/doxygen/classCInstructionAdd-members.html b/ue3/doxygen/classCInstructionAdd-members.html
new file mode 100644
index 0000000..c53ae2e
--- /dev/null
+++ b/ue3/doxygen/classCInstructionAdd-members.html
@@ -0,0 +1,45 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionAdd Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionAdd.html">CInstructionAdd</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionAdd</b>() (defined in <a class="el" href="classCInstructionAdd.html">CInstructionAdd</a>)</td><td><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionAdd.html#1da9f4b4016d27f2866add0b91e3b0fc">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionAdd.html#3c6844fd425de436ba3e7fbc98fd69e8">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionAdd.html#6fa9bae98f84f5ae34946641fb03ff32">factory</a>()</td><td><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionAdd.html#2808878fbfbee48f1c300bdd976446f4">m_regidx1</a></td><td><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionAdd.html#98e9005e15d5eb69ce561a91348a3a91">m_regidx2</a></td><td><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionAdd.html#1c5979587fea23262a9bc593b9dc61a3">m_regidx3</a></td><td><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionAdd.html b/ue3/doxygen/classCInstructionAdd.html
new file mode 100644
index 0000000..a659978
--- /dev/null
+++ b/ue3/doxygen/classCInstructionAdd.html
@@ -0,0 +1,223 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionAdd Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionAdd Class Reference</h1><!-- doxytag: class="CInstructionAdd" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionAdd:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionAdd.png" usemap="#CInstructionAdd_map" border="0" alt=""></center>
+<map name="CInstructionAdd_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,102,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionAdd-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionAdd.html#6fa9bae98f84f5ae34946641fb03ff32">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#6fa9bae98f84f5ae34946641fb03ff32"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionAdd.html#1da9f4b4016d27f2866add0b91e3b0fc">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#1da9f4b4016d27f2866add0b91e3b0fc"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionAdd.html#3c6844fd425de436ba3e7fbc98fd69e8">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#3c6844fd425de436ba3e7fbc98fd69e8"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionAdd.html#2808878fbfbee48f1c300bdd976446f4">m_regidx1</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionAdd.html#98e9005e15d5eb69ce561a91348a3a91">m_regidx2</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionAdd.html#1c5979587fea23262a9bc593b9dc61a3">m_regidx3</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "add" Syntax: add R1, R2, R3 (R1 = R2 + R3) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="6fa9bae98f84f5ae34946641fb03ff32"></a><!-- doxytag: member="CInstructionAdd::factory" ref="6fa9bae98f84f5ae34946641fb03ff32" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a>* CInstructionAdd::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="1da9f4b4016d27f2866add0b91e3b0fc"></a><!-- doxytag: member="CInstructionAdd::compile" ref="1da9f4b4016d27f2866add0b91e3b0fc" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionAdd::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="3c6844fd425de436ba3e7fbc98fd69e8"></a><!-- doxytag: member="CInstructionAdd::execute" ref="3c6844fd425de436ba3e7fbc98fd69e8" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionAdd::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="2808878fbfbee48f1c300bdd976446f4"></a><!-- doxytag: member="CInstructionAdd::m_regidx1" ref="2808878fbfbee48f1c300bdd976446f4" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionAdd.html#2808878fbfbee48f1c300bdd976446f4">CInstructionAdd::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="98e9005e15d5eb69ce561a91348a3a91"></a><!-- doxytag: member="CInstructionAdd::m_regidx2" ref="98e9005e15d5eb69ce561a91348a3a91" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionAdd.html#98e9005e15d5eb69ce561a91348a3a91">CInstructionAdd::m_regidx2</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="1c5979587fea23262a9bc593b9dc61a3"></a><!-- doxytag: member="CInstructionAdd::m_regidx3" ref="1c5979587fea23262a9bc593b9dc61a3" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionAdd.html#1c5979587fea23262a9bc593b9dc61a3">CInstructionAdd::m_regidx3</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionAdd.png b/ue3/doxygen/classCInstructionAdd.png
new file mode 100644
index 0000000..02a7e9c
Binary files /dev/null and b/ue3/doxygen/classCInstructionAdd.png differ
diff --git a/ue3/doxygen/classCInstructionDec-members.html b/ue3/doxygen/classCInstructionDec-members.html
new file mode 100644
index 0000000..f177e69
--- /dev/null
+++ b/ue3/doxygen/classCInstructionDec-members.html
@@ -0,0 +1,43 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionDec Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionDec.html">CInstructionDec</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionDec</b>() (defined in <a class="el" href="classCInstructionDec.html">CInstructionDec</a>)</td><td><a class="el" href="classCInstructionDec.html">CInstructionDec</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDec.html#84347e9b3a373bafc5c1ae79a557f4c3">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionDec.html">CInstructionDec</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDec.html#b0a51da3b41aaa4e3e51baaa4151ebca">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionDec.html">CInstructionDec</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDec.html#5aa3bcd55f05765e25758f45f4f55059">factory</a>()</td><td><a class="el" href="classCInstructionDec.html">CInstructionDec</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDec.html#4ea09ae25025e93c2790d5dc1536f41c">m_regidx1</a></td><td><a class="el" href="classCInstructionDec.html">CInstructionDec</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionDec.html b/ue3/doxygen/classCInstructionDec.html
new file mode 100644
index 0000000..b32ffa7
--- /dev/null
+++ b/ue3/doxygen/classCInstructionDec.html
@@ -0,0 +1,189 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionDec Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionDec Class Reference</h1><!-- doxytag: class="CInstructionDec" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionDec:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionDec.png" usemap="#CInstructionDec_map" border="0" alt=""></center>
+<map name="CInstructionDec_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,102,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionDec-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionDec.html">CInstructionDec</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDec.html#5aa3bcd55f05765e25758f45f4f55059">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#5aa3bcd55f05765e25758f45f4f55059"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDec.html#84347e9b3a373bafc5c1ae79a557f4c3">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#84347e9b3a373bafc5c1ae79a557f4c3"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDec.html#b0a51da3b41aaa4e3e51baaa4151ebca">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#b0a51da3b41aaa4e3e51baaa4151ebca"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDec.html#4ea09ae25025e93c2790d5dc1536f41c">m_regidx1</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "dec" Syntax: dec R1 (R1--) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="5aa3bcd55f05765e25758f45f4f55059"></a><!-- doxytag: member="CInstructionDec::factory" ref="5aa3bcd55f05765e25758f45f4f55059" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionDec.html">CInstructionDec</a>* CInstructionDec::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="84347e9b3a373bafc5c1ae79a557f4c3"></a><!-- doxytag: member="CInstructionDec::compile" ref="84347e9b3a373bafc5c1ae79a557f4c3" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionDec::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="b0a51da3b41aaa4e3e51baaa4151ebca"></a><!-- doxytag: member="CInstructionDec::execute" ref="b0a51da3b41aaa4e3e51baaa4151ebca" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionDec::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="4ea09ae25025e93c2790d5dc1536f41c"></a><!-- doxytag: member="CInstructionDec::m_regidx1" ref="4ea09ae25025e93c2790d5dc1536f41c" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionDec.html#4ea09ae25025e93c2790d5dc1536f41c">CInstructionDec::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionDec.png b/ue3/doxygen/classCInstructionDec.png
new file mode 100644
index 0000000..9cf686c
Binary files /dev/null and b/ue3/doxygen/classCInstructionDec.png differ
diff --git a/ue3/doxygen/classCInstructionDiv-members.html b/ue3/doxygen/classCInstructionDiv-members.html
new file mode 100644
index 0000000..57ac77e
--- /dev/null
+++ b/ue3/doxygen/classCInstructionDiv-members.html
@@ -0,0 +1,45 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionDiv Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionDiv.html">CInstructionDiv</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionDiv</b>() (defined in <a class="el" href="classCInstructionDiv.html">CInstructionDiv</a>)</td><td><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDiv.html#349324231c5516886d99caf07ecb8c0c">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDiv.html#7fee4e02bc6904c9d6039aa467aed1f4">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDiv.html#3445767e66ab734ec88b6084a10c4446">factory</a>()</td><td><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDiv.html#356508c5c90a345bdd0055385227852f">m_regidx1</a></td><td><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDiv.html#5a9c4be1386df1fa866927336abe3054">m_regidx2</a></td><td><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionDiv.html#3e7033bb26ef68b051b0da8a8279df85">m_regidx3</a></td><td><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionDiv.html b/ue3/doxygen/classCInstructionDiv.html
new file mode 100644
index 0000000..2bc0023
--- /dev/null
+++ b/ue3/doxygen/classCInstructionDiv.html
@@ -0,0 +1,223 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionDiv Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionDiv Class Reference</h1><!-- doxytag: class="CInstructionDiv" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionDiv:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionDiv.png" usemap="#CInstructionDiv_map" border="0" alt=""></center>
+<map name="CInstructionDiv_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,98,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionDiv-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDiv.html#3445767e66ab734ec88b6084a10c4446">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#3445767e66ab734ec88b6084a10c4446"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDiv.html#349324231c5516886d99caf07ecb8c0c">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#349324231c5516886d99caf07ecb8c0c"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDiv.html#7fee4e02bc6904c9d6039aa467aed1f4">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#7fee4e02bc6904c9d6039aa467aed1f4"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDiv.html#356508c5c90a345bdd0055385227852f">m_regidx1</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDiv.html#5a9c4be1386df1fa866927336abe3054">m_regidx2</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionDiv.html#3e7033bb26ef68b051b0da8a8279df85">m_regidx3</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "div" Syntax: div R1, R2, R3 (R1 = R2 / R3) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="3445767e66ab734ec88b6084a10c4446"></a><!-- doxytag: member="CInstructionDiv::factory" ref="3445767e66ab734ec88b6084a10c4446" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a>* CInstructionDiv::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="349324231c5516886d99caf07ecb8c0c"></a><!-- doxytag: member="CInstructionDiv::compile" ref="349324231c5516886d99caf07ecb8c0c" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionDiv::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="7fee4e02bc6904c9d6039aa467aed1f4"></a><!-- doxytag: member="CInstructionDiv::execute" ref="7fee4e02bc6904c9d6039aa467aed1f4" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionDiv::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="356508c5c90a345bdd0055385227852f"></a><!-- doxytag: member="CInstructionDiv::m_regidx1" ref="356508c5c90a345bdd0055385227852f" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionDiv.html#356508c5c90a345bdd0055385227852f">CInstructionDiv::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="5a9c4be1386df1fa866927336abe3054"></a><!-- doxytag: member="CInstructionDiv::m_regidx2" ref="5a9c4be1386df1fa866927336abe3054" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionDiv.html#5a9c4be1386df1fa866927336abe3054">CInstructionDiv::m_regidx2</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="3e7033bb26ef68b051b0da8a8279df85"></a><!-- doxytag: member="CInstructionDiv::m_regidx3" ref="3e7033bb26ef68b051b0da8a8279df85" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionDiv.html#3e7033bb26ef68b051b0da8a8279df85">CInstructionDiv::m_regidx3</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionDiv.png b/ue3/doxygen/classCInstructionDiv.png
new file mode 100644
index 0000000..11ede71
Binary files /dev/null and b/ue3/doxygen/classCInstructionDiv.png differ
diff --git a/ue3/doxygen/classCInstructionInc-members.html b/ue3/doxygen/classCInstructionInc-members.html
new file mode 100644
index 0000000..5d66408
--- /dev/null
+++ b/ue3/doxygen/classCInstructionInc-members.html
@@ -0,0 +1,43 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionInc Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionInc.html">CInstructionInc</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionInc</b>() (defined in <a class="el" href="classCInstructionInc.html">CInstructionInc</a>)</td><td><a class="el" href="classCInstructionInc.html">CInstructionInc</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionInc.html#ae36e952ec66b1c5cc2fb7e7c80064cc">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionInc.html">CInstructionInc</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionInc.html#2830b4c1aa89410e309821119ecf4d6f">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionInc.html">CInstructionInc</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionInc.html#d55c35cbbd5c88fd29a392051e79f5f1">factory</a>()</td><td><a class="el" href="classCInstructionInc.html">CInstructionInc</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionInc.html#b910df5b37f4d1352736913ee0cb7fb0">m_regidx1</a></td><td><a class="el" href="classCInstructionInc.html">CInstructionInc</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionInc.html b/ue3/doxygen/classCInstructionInc.html
new file mode 100644
index 0000000..4756c23
--- /dev/null
+++ b/ue3/doxygen/classCInstructionInc.html
@@ -0,0 +1,189 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionInc Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionInc Class Reference</h1><!-- doxytag: class="CInstructionInc" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionInc:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionInc.png" usemap="#CInstructionInc_map" border="0" alt=""></center>
+<map name="CInstructionInc_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,96,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionInc-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionInc.html">CInstructionInc</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionInc.html#d55c35cbbd5c88fd29a392051e79f5f1">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#d55c35cbbd5c88fd29a392051e79f5f1"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionInc.html#ae36e952ec66b1c5cc2fb7e7c80064cc">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#ae36e952ec66b1c5cc2fb7e7c80064cc"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionInc.html#2830b4c1aa89410e309821119ecf4d6f">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#2830b4c1aa89410e309821119ecf4d6f"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionInc.html#b910df5b37f4d1352736913ee0cb7fb0">m_regidx1</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "inc" Syntax: inc R1 (R1++) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="d55c35cbbd5c88fd29a392051e79f5f1"></a><!-- doxytag: member="CInstructionInc::factory" ref="d55c35cbbd5c88fd29a392051e79f5f1" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionInc.html">CInstructionInc</a>* CInstructionInc::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="ae36e952ec66b1c5cc2fb7e7c80064cc"></a><!-- doxytag: member="CInstructionInc::compile" ref="ae36e952ec66b1c5cc2fb7e7c80064cc" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionInc::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="2830b4c1aa89410e309821119ecf4d6f"></a><!-- doxytag: member="CInstructionInc::execute" ref="2830b4c1aa89410e309821119ecf4d6f" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionInc::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="b910df5b37f4d1352736913ee0cb7fb0"></a><!-- doxytag: member="CInstructionInc::m_regidx1" ref="b910df5b37f4d1352736913ee0cb7fb0" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionInc.html#b910df5b37f4d1352736913ee0cb7fb0">CInstructionInc::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionInc.png b/ue3/doxygen/classCInstructionInc.png
new file mode 100644
index 0000000..8954718
Binary files /dev/null and b/ue3/doxygen/classCInstructionInc.png differ
diff --git a/ue3/doxygen/classCInstructionJumpA-members.html b/ue3/doxygen/classCInstructionJumpA-members.html
new file mode 100644
index 0000000..023a9a7
--- /dev/null
+++ b/ue3/doxygen/classCInstructionJumpA-members.html
@@ -0,0 +1,43 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionJumpA Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionJumpA</b>() (defined in <a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a>)</td><td><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpA.html#f772a57214b192263594d2ff46f03a1e">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpA.html#76daeedb9c7cb3be0173580be9390887">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpA.html#d7679ea0d70ab9725f84dcce76adc057">factory</a>()</td><td><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">m_addr</a></td><td><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionJumpA.html b/ue3/doxygen/classCInstructionJumpA.html
new file mode 100644
index 0000000..edd2e4b
--- /dev/null
+++ b/ue3/doxygen/classCInstructionJumpA.html
@@ -0,0 +1,189 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionJumpA Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionJumpA Class Reference</h1><!-- doxytag: class="CInstructionJumpA" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionJumpA:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionJumpA.png" usemap="#CInstructionJumpA_map" border="0" alt=""></center>
+<map name="CInstructionJumpA_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,118,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionJumpA-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpA.html#d7679ea0d70ab9725f84dcce76adc057">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#d7679ea0d70ab9725f84dcce76adc057"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpA.html#f772a57214b192263594d2ff46f03a1e">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#f772a57214b192263594d2ff46f03a1e"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpA.html#76daeedb9c7cb3be0173580be9390887">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#76daeedb9c7cb3be0173580be9390887"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::string&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">m_addr</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "jumpa" Syntax: jumpa labelname (jump to labelname) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="d7679ea0d70ab9725f84dcce76adc057"></a><!-- doxytag: member="CInstructionJumpA::factory" ref="d7679ea0d70ab9725f84dcce76adc057" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a>* CInstructionJumpA::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="f772a57214b192263594d2ff46f03a1e"></a><!-- doxytag: member="CInstructionJumpA::compile" ref="f772a57214b192263594d2ff46f03a1e" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionJumpA::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="76daeedb9c7cb3be0173580be9390887"></a><!-- doxytag: member="CInstructionJumpA::execute" ref="76daeedb9c7cb3be0173580be9390887" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionJumpA::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="ee10410094e2b3781da3cb53c390fb9e"></a><!-- doxytag: member="CInstructionJumpA::m_addr" ref="ee10410094e2b3781da3cb53c390fb9e" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">std::string <a class="el" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">CInstructionJumpA::m_addr</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+labelname 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionJumpA.png b/ue3/doxygen/classCInstructionJumpA.png
new file mode 100644
index 0000000..48998d1
Binary files /dev/null and b/ue3/doxygen/classCInstructionJumpA.png differ
diff --git a/ue3/doxygen/classCInstructionJumpS-members.html b/ue3/doxygen/classCInstructionJumpS-members.html
new file mode 100644
index 0000000..4ccefd9
--- /dev/null
+++ b/ue3/doxygen/classCInstructionJumpS-members.html
@@ -0,0 +1,43 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionJumpS Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionJumpS</b>() (defined in <a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a>)</td><td><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpS.html#671d749a6e93f26851879c4ceac09f4c">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpS.html#8c2e8e077463e64ca64204bb6ed20f71">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpS.html#4b25703a62dafb568700dcad217f7ba6">factory</a>()</td><td><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">m_addr</a></td><td><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionJumpS.html b/ue3/doxygen/classCInstructionJumpS.html
new file mode 100644
index 0000000..1a5b7a0
--- /dev/null
+++ b/ue3/doxygen/classCInstructionJumpS.html
@@ -0,0 +1,189 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionJumpS Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionJumpS Class Reference</h1><!-- doxytag: class="CInstructionJumpS" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionJumpS:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionJumpS.png" usemap="#CInstructionJumpS_map" border="0" alt=""></center>
+<map name="CInstructionJumpS_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,117,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionJumpS-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpS.html#4b25703a62dafb568700dcad217f7ba6">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#4b25703a62dafb568700dcad217f7ba6"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpS.html#671d749a6e93f26851879c4ceac09f4c">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#671d749a6e93f26851879c4ceac09f4c"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpS.html#8c2e8e077463e64ca64204bb6ed20f71">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#8c2e8e077463e64ca64204bb6ed20f71"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::string&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">m_addr</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "jumps" Syntax: jumps labelname (jump to labelname if signflag) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="4b25703a62dafb568700dcad217f7ba6"></a><!-- doxytag: member="CInstructionJumpS::factory" ref="4b25703a62dafb568700dcad217f7ba6" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a>* CInstructionJumpS::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="671d749a6e93f26851879c4ceac09f4c"></a><!-- doxytag: member="CInstructionJumpS::compile" ref="671d749a6e93f26851879c4ceac09f4c" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionJumpS::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="8c2e8e077463e64ca64204bb6ed20f71"></a><!-- doxytag: member="CInstructionJumpS::execute" ref="8c2e8e077463e64ca64204bb6ed20f71" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionJumpS::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="f610b22fcf027db2ad2152c52c006eda"></a><!-- doxytag: member="CInstructionJumpS::m_addr" ref="f610b22fcf027db2ad2152c52c006eda" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">std::string <a class="el" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">CInstructionJumpS::m_addr</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+labelname 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionJumpS.png b/ue3/doxygen/classCInstructionJumpS.png
new file mode 100644
index 0000000..635cddb
Binary files /dev/null and b/ue3/doxygen/classCInstructionJumpS.png differ
diff --git a/ue3/doxygen/classCInstructionJumpZ-members.html b/ue3/doxygen/classCInstructionJumpZ-members.html
new file mode 100644
index 0000000..168bc98
--- /dev/null
+++ b/ue3/doxygen/classCInstructionJumpZ-members.html
@@ -0,0 +1,43 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionJumpZ Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionJumpZ</b>() (defined in <a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a>)</td><td><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpZ.html#e4c05192b829d2bcc1e838de195ef3d9">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpZ.html#92f15deda156ebd20e8af47589753783">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpZ.html#e0750f1ce4a5746be3317024f4ef92eb">factory</a>()</td><td><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">m_addr</a></td><td><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionJumpZ.html b/ue3/doxygen/classCInstructionJumpZ.html
new file mode 100644
index 0000000..a8bb339
--- /dev/null
+++ b/ue3/doxygen/classCInstructionJumpZ.html
@@ -0,0 +1,189 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionJumpZ Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionJumpZ Class Reference</h1><!-- doxytag: class="CInstructionJumpZ" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionJumpZ:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionJumpZ.png" usemap="#CInstructionJumpZ_map" border="0" alt=""></center>
+<map name="CInstructionJumpZ_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,118,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionJumpZ-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpZ.html#e0750f1ce4a5746be3317024f4ef92eb">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#e0750f1ce4a5746be3317024f4ef92eb"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpZ.html#e4c05192b829d2bcc1e838de195ef3d9">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#e4c05192b829d2bcc1e838de195ef3d9"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpZ.html#92f15deda156ebd20e8af47589753783">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#92f15deda156ebd20e8af47589753783"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::string&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">m_addr</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "jumpz" Syntax: jumpz labelname (jump to labelname if zeroflag) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="e0750f1ce4a5746be3317024f4ef92eb"></a><!-- doxytag: member="CInstructionJumpZ::factory" ref="e0750f1ce4a5746be3317024f4ef92eb" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a>* CInstructionJumpZ::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="e4c05192b829d2bcc1e838de195ef3d9"></a><!-- doxytag: member="CInstructionJumpZ::compile" ref="e4c05192b829d2bcc1e838de195ef3d9" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionJumpZ::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="92f15deda156ebd20e8af47589753783"></a><!-- doxytag: member="CInstructionJumpZ::execute" ref="92f15deda156ebd20e8af47589753783" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionJumpZ::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="4f0147cd62010e0d178c9259737e8c10"></a><!-- doxytag: member="CInstructionJumpZ::m_addr" ref="4f0147cd62010e0d178c9259737e8c10" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">std::string <a class="el" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">CInstructionJumpZ::m_addr</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+labelname 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionJumpZ.png b/ue3/doxygen/classCInstructionJumpZ.png
new file mode 100644
index 0000000..4840f60
Binary files /dev/null and b/ue3/doxygen/classCInstructionJumpZ.png differ
diff --git a/ue3/doxygen/classCInstructionLabel-members.html b/ue3/doxygen/classCInstructionLabel-members.html
new file mode 100644
index 0000000..3933096
--- /dev/null
+++ b/ue3/doxygen/classCInstructionLabel-members.html
@@ -0,0 +1,42 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionLabel Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionLabel.html">CInstructionLabel</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionLabel</b>() (defined in <a class="el" href="classCInstructionLabel.html">CInstructionLabel</a>)</td><td><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLabel.html#321fd849ae169d900964431b4100321f">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLabel.html#665f2fc395ffed3bd968659f67868f53">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLabel.html#66ba5bd6facecd45f3616fc94eb2845f">factory</a>()</td><td><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionLabel.html b/ue3/doxygen/classCInstructionLabel.html
new file mode 100644
index 0000000..e6994be
--- /dev/null
+++ b/ue3/doxygen/classCInstructionLabel.html
@@ -0,0 +1,170 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionLabel Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionLabel Class Reference</h1><!-- doxytag: class="CInstructionLabel" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionLabel:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionLabel.png" usemap="#CInstructionLabel_map" border="0" alt=""></center>
+<map name="CInstructionLabel_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,110,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionLabel-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLabel.html#66ba5bd6facecd45f3616fc94eb2845f">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#66ba5bd6facecd45f3616fc94eb2845f"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLabel.html#321fd849ae169d900964431b4100321f">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#321fd849ae169d900964431b4100321f"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLabel.html#665f2fc395ffed3bd968659f67868f53">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#665f2fc395ffed3bd968659f67868f53"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "label" Syntax: label name: <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="66ba5bd6facecd45f3616fc94eb2845f"></a><!-- doxytag: member="CInstructionLabel::factory" ref="66ba5bd6facecd45f3616fc94eb2845f" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a>* CInstructionLabel::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="321fd849ae169d900964431b4100321f"></a><!-- doxytag: member="CInstructionLabel::compile" ref="321fd849ae169d900964431b4100321f" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionLabel::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="665f2fc395ffed3bd968659f67868f53"></a><!-- doxytag: member="CInstructionLabel::execute" ref="665f2fc395ffed3bd968659f67868f53" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionLabel::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionLabel.png b/ue3/doxygen/classCInstructionLabel.png
new file mode 100644
index 0000000..2725289
Binary files /dev/null and b/ue3/doxygen/classCInstructionLabel.png differ
diff --git a/ue3/doxygen/classCInstructionLoad-members.html b/ue3/doxygen/classCInstructionLoad-members.html
new file mode 100644
index 0000000..8786246
--- /dev/null
+++ b/ue3/doxygen/classCInstructionLoad-members.html
@@ -0,0 +1,44 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionLoad Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionLoad.html">CInstructionLoad</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionLoad</b>() (defined in <a class="el" href="classCInstructionLoad.html">CInstructionLoad</a>)</td><td><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLoad.html#4aa70fe481286e0bcc27f7a9ce896d3d">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLoad.html#fdda1d554401f9bfd32a6300f5ad2bb6">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLoad.html#35c051515ccd6a12dbb39ab4b2e33ded">factory</a>()</td><td><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLoad.html#91139a066176d4be83258eba0b412cb6">m_regidx1</a></td><td><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionLoad.html#dbb1c5a56e063ce77d3b8d26355e2a49">m_regidx2</a></td><td><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionLoad.html b/ue3/doxygen/classCInstructionLoad.html
new file mode 100644
index 0000000..83bbcc2
--- /dev/null
+++ b/ue3/doxygen/classCInstructionLoad.html
@@ -0,0 +1,206 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionLoad Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionLoad Class Reference</h1><!-- doxytag: class="CInstructionLoad" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionLoad:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionLoad.png" usemap="#CInstructionLoad_map" border="0" alt=""></center>
+<map name="CInstructionLoad_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,107,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionLoad-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLoad.html#35c051515ccd6a12dbb39ab4b2e33ded">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#35c051515ccd6a12dbb39ab4b2e33ded"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLoad.html#4aa70fe481286e0bcc27f7a9ce896d3d">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#4aa70fe481286e0bcc27f7a9ce896d3d"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLoad.html#fdda1d554401f9bfd32a6300f5ad2bb6">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#fdda1d554401f9bfd32a6300f5ad2bb6"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLoad.html#91139a066176d4be83258eba0b412cb6">m_regidx1</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionLoad.html#dbb1c5a56e063ce77d3b8d26355e2a49">m_regidx2</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "load" Syntax: load R1, R2 (R1 = memory[R2]) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="35c051515ccd6a12dbb39ab4b2e33ded"></a><!-- doxytag: member="CInstructionLoad::factory" ref="35c051515ccd6a12dbb39ab4b2e33ded" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a>* CInstructionLoad::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="4aa70fe481286e0bcc27f7a9ce896d3d"></a><!-- doxytag: member="CInstructionLoad::compile" ref="4aa70fe481286e0bcc27f7a9ce896d3d" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionLoad::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="fdda1d554401f9bfd32a6300f5ad2bb6"></a><!-- doxytag: member="CInstructionLoad::execute" ref="fdda1d554401f9bfd32a6300f5ad2bb6" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionLoad::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="91139a066176d4be83258eba0b412cb6"></a><!-- doxytag: member="CInstructionLoad::m_regidx1" ref="91139a066176d4be83258eba0b412cb6" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionLoad.html#91139a066176d4be83258eba0b412cb6">CInstructionLoad::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="dbb1c5a56e063ce77d3b8d26355e2a49"></a><!-- doxytag: member="CInstructionLoad::m_regidx2" ref="dbb1c5a56e063ce77d3b8d26355e2a49" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionLoad.html#dbb1c5a56e063ce77d3b8d26355e2a49">CInstructionLoad::m_regidx2</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionLoad.png b/ue3/doxygen/classCInstructionLoad.png
new file mode 100644
index 0000000..45fe9bf
Binary files /dev/null and b/ue3/doxygen/classCInstructionLoad.png differ
diff --git a/ue3/doxygen/classCInstructionMul-members.html b/ue3/doxygen/classCInstructionMul-members.html
new file mode 100644
index 0000000..cb1ade9
--- /dev/null
+++ b/ue3/doxygen/classCInstructionMul-members.html
@@ -0,0 +1,45 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionMul Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionMul.html">CInstructionMul</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionMul</b>() (defined in <a class="el" href="classCInstructionMul.html">CInstructionMul</a>)</td><td><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionMul.html#188024d90dd19fcea0687d32e98c67a7">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionMul.html#0675f51cbfb5d0d76e605f64b0b2555c">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionMul.html#1e8f23073a29a0d50fa9d651b986e821">factory</a>()</td><td><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionMul.html#c5c3b5b125973a0396c3ad7e0233b79f">m_regidx1</a></td><td><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionMul.html#eaaaff76fe29741fce14b322d4da8a54">m_regidx2</a></td><td><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionMul.html#171d8573f80224249ac14e4c8fec0c7b">m_regidx3</a></td><td><a class="el" href="classCInstructionMul.html">CInstructionMul</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionMul.html b/ue3/doxygen/classCInstructionMul.html
new file mode 100644
index 0000000..7f7bdd9
--- /dev/null
+++ b/ue3/doxygen/classCInstructionMul.html
@@ -0,0 +1,223 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionMul Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionMul Class Reference</h1><!-- doxytag: class="CInstructionMul" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionMul:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionMul.png" usemap="#CInstructionMul_map" border="0" alt=""></center>
+<map name="CInstructionMul_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,100,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionMul-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionMul.html">CInstructionMul</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionMul.html#1e8f23073a29a0d50fa9d651b986e821">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#1e8f23073a29a0d50fa9d651b986e821"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionMul.html#188024d90dd19fcea0687d32e98c67a7">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#188024d90dd19fcea0687d32e98c67a7"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionMul.html#0675f51cbfb5d0d76e605f64b0b2555c">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#0675f51cbfb5d0d76e605f64b0b2555c"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionMul.html#c5c3b5b125973a0396c3ad7e0233b79f">m_regidx1</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionMul.html#eaaaff76fe29741fce14b322d4da8a54">m_regidx2</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionMul.html#171d8573f80224249ac14e4c8fec0c7b">m_regidx3</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "mul" Syntax: mul R1, R2, R3 (R1 = R2 * R3) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="1e8f23073a29a0d50fa9d651b986e821"></a><!-- doxytag: member="CInstructionMul::factory" ref="1e8f23073a29a0d50fa9d651b986e821" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionMul.html">CInstructionMul</a>* CInstructionMul::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="188024d90dd19fcea0687d32e98c67a7"></a><!-- doxytag: member="CInstructionMul::compile" ref="188024d90dd19fcea0687d32e98c67a7" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionMul::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="0675f51cbfb5d0d76e605f64b0b2555c"></a><!-- doxytag: member="CInstructionMul::execute" ref="0675f51cbfb5d0d76e605f64b0b2555c" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionMul::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="c5c3b5b125973a0396c3ad7e0233b79f"></a><!-- doxytag: member="CInstructionMul::m_regidx1" ref="c5c3b5b125973a0396c3ad7e0233b79f" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionMul.html#c5c3b5b125973a0396c3ad7e0233b79f">CInstructionMul::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="eaaaff76fe29741fce14b322d4da8a54"></a><!-- doxytag: member="CInstructionMul::m_regidx2" ref="eaaaff76fe29741fce14b322d4da8a54" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionMul.html#eaaaff76fe29741fce14b322d4da8a54">CInstructionMul::m_regidx2</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="171d8573f80224249ac14e4c8fec0c7b"></a><!-- doxytag: member="CInstructionMul::m_regidx3" ref="171d8573f80224249ac14e4c8fec0c7b" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionMul.html#171d8573f80224249ac14e4c8fec0c7b">CInstructionMul::m_regidx3</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionMul.png b/ue3/doxygen/classCInstructionMul.png
new file mode 100644
index 0000000..f300a09
Binary files /dev/null and b/ue3/doxygen/classCInstructionMul.png differ
diff --git a/ue3/doxygen/classCInstructionStore-members.html b/ue3/doxygen/classCInstructionStore-members.html
new file mode 100644
index 0000000..d06efb9
--- /dev/null
+++ b/ue3/doxygen/classCInstructionStore-members.html
@@ -0,0 +1,44 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionStore Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionStore.html">CInstructionStore</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionStore</b>() (defined in <a class="el" href="classCInstructionStore.html">CInstructionStore</a>)</td><td><a class="el" href="classCInstructionStore.html">CInstructionStore</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionStore.html#9848bf36bd3ec75ae481d8ef1f36c6ee">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionStore.html">CInstructionStore</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionStore.html#fd5ee6692540613ee8cc9a2bf8ff920a">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionStore.html">CInstructionStore</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionStore.html#cab0d4c9bf2cc0d6b1b450ef9aeebcc0">factory</a>()</td><td><a class="el" href="classCInstructionStore.html">CInstructionStore</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionStore.html#5e57d0d27d70f13a590355f5c1782cc9">m_regidx1</a></td><td><a class="el" href="classCInstructionStore.html">CInstructionStore</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionStore.html#d960c6b85e7022704b4d7d059e1766d1">m_regidx2</a></td><td><a class="el" href="classCInstructionStore.html">CInstructionStore</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionStore.html b/ue3/doxygen/classCInstructionStore.html
new file mode 100644
index 0000000..f2d0133
--- /dev/null
+++ b/ue3/doxygen/classCInstructionStore.html
@@ -0,0 +1,206 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionStore Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionStore Class Reference</h1><!-- doxytag: class="CInstructionStore" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionStore:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionStore.png" usemap="#CInstructionStore_map" border="0" alt=""></center>
+<map name="CInstructionStore_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,109,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionStore-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionStore.html">CInstructionStore</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionStore.html#cab0d4c9bf2cc0d6b1b450ef9aeebcc0">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#cab0d4c9bf2cc0d6b1b450ef9aeebcc0"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionStore.html#9848bf36bd3ec75ae481d8ef1f36c6ee">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#9848bf36bd3ec75ae481d8ef1f36c6ee"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionStore.html#fd5ee6692540613ee8cc9a2bf8ff920a">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#fd5ee6692540613ee8cc9a2bf8ff920a"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionStore.html#5e57d0d27d70f13a590355f5c1782cc9">m_regidx1</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionStore.html#d960c6b85e7022704b4d7d059e1766d1">m_regidx2</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "store" Syntax: store R1, R2 (memory[R2] = R1) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="cab0d4c9bf2cc0d6b1b450ef9aeebcc0"></a><!-- doxytag: member="CInstructionStore::factory" ref="cab0d4c9bf2cc0d6b1b450ef9aeebcc0" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionStore.html">CInstructionStore</a>* CInstructionStore::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="9848bf36bd3ec75ae481d8ef1f36c6ee"></a><!-- doxytag: member="CInstructionStore::compile" ref="9848bf36bd3ec75ae481d8ef1f36c6ee" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionStore::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="fd5ee6692540613ee8cc9a2bf8ff920a"></a><!-- doxytag: member="CInstructionStore::execute" ref="fd5ee6692540613ee8cc9a2bf8ff920a" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionStore::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="5e57d0d27d70f13a590355f5c1782cc9"></a><!-- doxytag: member="CInstructionStore::m_regidx1" ref="5e57d0d27d70f13a590355f5c1782cc9" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionStore.html#5e57d0d27d70f13a590355f5c1782cc9">CInstructionStore::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="d960c6b85e7022704b4d7d059e1766d1"></a><!-- doxytag: member="CInstructionStore::m_regidx2" ref="d960c6b85e7022704b4d7d059e1766d1" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionStore.html#d960c6b85e7022704b4d7d059e1766d1">CInstructionStore::m_regidx2</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionStore.png b/ue3/doxygen/classCInstructionStore.png
new file mode 100644
index 0000000..b368340
Binary files /dev/null and b/ue3/doxygen/classCInstructionStore.png differ
diff --git a/ue3/doxygen/classCInstructionSub-members.html b/ue3/doxygen/classCInstructionSub-members.html
new file mode 100644
index 0000000..4908357
--- /dev/null
+++ b/ue3/doxygen/classCInstructionSub-members.html
@@ -0,0 +1,45 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionSub Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionSub.html">CInstructionSub</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionSub</b>() (defined in <a class="el" href="classCInstructionSub.html">CInstructionSub</a>)</td><td><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionSub.html#9fe6d8f0f805313c98f8806a4739cbe9">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionSub.html#03e098595198d4cc2f45d906e45e7f28">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionSub.html#71c77a5113f96ac25e79bc4d28072541">factory</a>()</td><td><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionSub.html#f9884524cd60c34f3d9a5142e1e586fb">m_regidx1</a></td><td><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionSub.html#67030fafc6429936130bbe26874c337c">m_regidx2</a></td><td><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionSub.html#a059bfa11944c55216619bb4328ed44e">m_regidx3</a></td><td><a class="el" href="classCInstructionSub.html">CInstructionSub</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionSub.html b/ue3/doxygen/classCInstructionSub.html
new file mode 100644
index 0000000..669d6bb
--- /dev/null
+++ b/ue3/doxygen/classCInstructionSub.html
@@ -0,0 +1,223 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionSub Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionSub Class Reference</h1><!-- doxytag: class="CInstructionSub" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionSub:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionSub.png" usemap="#CInstructionSub_map" border="0" alt=""></center>
+<map name="CInstructionSub_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,101,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionSub-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionSub.html">CInstructionSub</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionSub.html#71c77a5113f96ac25e79bc4d28072541">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#71c77a5113f96ac25e79bc4d28072541"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionSub.html#9fe6d8f0f805313c98f8806a4739cbe9">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#9fe6d8f0f805313c98f8806a4739cbe9"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionSub.html#03e098595198d4cc2f45d906e45e7f28">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#03e098595198d4cc2f45d906e45e7f28"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionSub.html#f9884524cd60c34f3d9a5142e1e586fb">m_regidx1</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionSub.html#67030fafc6429936130bbe26874c337c">m_regidx2</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionSub.html#a059bfa11944c55216619bb4328ed44e">m_regidx3</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "sub" Syntax: sub R1, R2, R3 (R1 = R2 - R3) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="71c77a5113f96ac25e79bc4d28072541"></a><!-- doxytag: member="CInstructionSub::factory" ref="71c77a5113f96ac25e79bc4d28072541" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionSub.html">CInstructionSub</a>* CInstructionSub::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="9fe6d8f0f805313c98f8806a4739cbe9"></a><!-- doxytag: member="CInstructionSub::compile" ref="9fe6d8f0f805313c98f8806a4739cbe9" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionSub::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="03e098595198d4cc2f45d906e45e7f28"></a><!-- doxytag: member="CInstructionSub::execute" ref="03e098595198d4cc2f45d906e45e7f28" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionSub::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="f9884524cd60c34f3d9a5142e1e586fb"></a><!-- doxytag: member="CInstructionSub::m_regidx1" ref="f9884524cd60c34f3d9a5142e1e586fb" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionSub.html#f9884524cd60c34f3d9a5142e1e586fb">CInstructionSub::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="67030fafc6429936130bbe26874c337c"></a><!-- doxytag: member="CInstructionSub::m_regidx2" ref="67030fafc6429936130bbe26874c337c" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionSub.html#67030fafc6429936130bbe26874c337c">CInstructionSub::m_regidx2</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="a059bfa11944c55216619bb4328ed44e"></a><!-- doxytag: member="CInstructionSub::m_regidx3" ref="a059bfa11944c55216619bb4328ed44e" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionSub.html#a059bfa11944c55216619bb4328ed44e">CInstructionSub::m_regidx3</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionSub.png b/ue3/doxygen/classCInstructionSub.png
new file mode 100644
index 0000000..a618537
Binary files /dev/null and b/ue3/doxygen/classCInstructionSub.png differ
diff --git a/ue3/doxygen/classCInstructionTest-members.html b/ue3/doxygen/classCInstructionTest-members.html
new file mode 100644
index 0000000..8da9434
--- /dev/null
+++ b/ue3/doxygen/classCInstructionTest-members.html
@@ -0,0 +1,43 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionTest Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionTest.html">CInstructionTest</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionTest</b>() (defined in <a class="el" href="classCInstructionTest.html">CInstructionTest</a>)</td><td><a class="el" href="classCInstructionTest.html">CInstructionTest</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionTest.html#b09f0e02ab71b01af6eda0152d1fc975">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionTest.html">CInstructionTest</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionTest.html#955cf58c41c9e305059baea28b65cf3a">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionTest.html">CInstructionTest</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionTest.html#9e4e1ac29b5173a70dc1172bbb096671">factory</a>()</td><td><a class="el" href="classCInstructionTest.html">CInstructionTest</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionTest.html#26744f0f306f4a181936fc6e389eb9e3">m_regidx1</a></td><td><a class="el" href="classCInstructionTest.html">CInstructionTest</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionTest.html b/ue3/doxygen/classCInstructionTest.html
new file mode 100644
index 0000000..fdb87d8
--- /dev/null
+++ b/ue3/doxygen/classCInstructionTest.html
@@ -0,0 +1,189 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionTest Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionTest Class Reference</h1><!-- doxytag: class="CInstructionTest" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionTest:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionTest.png" usemap="#CInstructionTest_map" border="0" alt=""></center>
+<map name="CInstructionTest_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,102,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionTest-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionTest.html">CInstructionTest</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionTest.html#9e4e1ac29b5173a70dc1172bbb096671">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#9e4e1ac29b5173a70dc1172bbb096671"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionTest.html#b09f0e02ab71b01af6eda0152d1fc975">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#b09f0e02ab71b01af6eda0152d1fc975"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionTest.html#955cf58c41c9e305059baea28b65cf3a">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#955cf58c41c9e305059baea28b65cf3a"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionTest.html#26744f0f306f4a181936fc6e389eb9e3">m_regidx1</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "test" Syntax: test R1 (R1 == 0: zeroflag: true, R1 &lt; 0: signflag: true) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="9e4e1ac29b5173a70dc1172bbb096671"></a><!-- doxytag: member="CInstructionTest::factory" ref="9e4e1ac29b5173a70dc1172bbb096671" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionTest.html">CInstructionTest</a>* CInstructionTest::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="b09f0e02ab71b01af6eda0152d1fc975"></a><!-- doxytag: member="CInstructionTest::compile" ref="b09f0e02ab71b01af6eda0152d1fc975" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionTest::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="955cf58c41c9e305059baea28b65cf3a"></a><!-- doxytag: member="CInstructionTest::execute" ref="955cf58c41c9e305059baea28b65cf3a" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionTest::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="26744f0f306f4a181936fc6e389eb9e3"></a><!-- doxytag: member="CInstructionTest::m_regidx1" ref="26744f0f306f4a181936fc6e389eb9e3" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionTest.html#26744f0f306f4a181936fc6e389eb9e3">CInstructionTest::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionTest.png b/ue3/doxygen/classCInstructionTest.png
new file mode 100644
index 0000000..c91fec4
Binary files /dev/null and b/ue3/doxygen/classCInstructionTest.png differ
diff --git a/ue3/doxygen/classCInstructionWrite-members.html b/ue3/doxygen/classCInstructionWrite-members.html
new file mode 100644
index 0000000..63a0154
--- /dev/null
+++ b/ue3/doxygen/classCInstructionWrite-members.html
@@ -0,0 +1,44 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionWrite Member List</h1>This is the complete list of members for <a class="el" href="classCInstructionWrite.html">CInstructionWrite</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">checkRegister</a>(CCPU *cpu, const unsigned regidx)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>(std::string name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><b>CInstructionWrite</b>() (defined in <a class="el" href="classCInstructionWrite.html">CInstructionWrite</a>)</td><td><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionWrite.html#23f5bb8e4b8a74f7a8703d593323b991">compile</a>(std::list&lt; std::string &gt; &amp;params)</td><td><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">dump</a>(std::ostream &amp;stream)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionWrite.html#1852e50c21b758a4db205a6cd20e208d">execute</a>(CCPU *cpu)</td><td><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionWrite.html#a33ddc8fb13dfaa253704eb0952f3cea">factory</a>()</td><td><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">getName</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">m_dev</a></td><td><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">m_name</a></td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstructionWrite.html#7af118a6f35320bbbee55051188311d6">m_regidx1</a></td><td><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a></td><td><code> [protected]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">operator()</a>(CCPU *cpu)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">operator&lt;&lt;</a>(std::ostream &amp;stream, CInstruction &amp;instr)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [friend]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">operator==</a>(std::string &amp;name)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">parseRegister</a>(const std::string &amp;str)</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [virtual]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">~CInstruction</a>()</td><td><a class="el" href="classCInstruction.html">CInstruction</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionWrite.html b/ue3/doxygen/classCInstructionWrite.html
new file mode 100644
index 0000000..074667d
--- /dev/null
+++ b/ue3/doxygen/classCInstructionWrite.html
@@ -0,0 +1,206 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CInstructionWrite Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CInstructionWrite Class Reference</h1><!-- doxytag: class="CInstructionWrite" --><!-- doxytag: inherits="CInstruction" --><code>#include &lt;<a class="el" href="instructions_8h-source.html">instructions.h</a>&gt;</code>
+<p>
+<div class="dynheader">
+Inheritance diagram for CInstructionWrite:</div>
+<div class="dynsection">
+
+<p><center><img src="classCInstructionWrite.png" usemap="#CInstructionWrite_map" border="0" alt=""></center>
+<map name="CInstructionWrite_map">
+<area href="classCInstruction.html" alt="CInstruction" shape="rect" coords="0,0,108,24">
+</map>
+</div>
+
+<p>
+<a href="classCInstructionWrite-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a> *&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionWrite.html#a33ddc8fb13dfaa253704eb0952f3cea">factory</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">creates a new instance of this instruction  <a href="#a33ddc8fb13dfaa253704eb0952f3cea"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionWrite.html#23f5bb8e4b8a74f7a8703d593323b991">compile</a> (std::list&lt; std::string &gt; &amp;params)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">parses instruction parameters and prepares the instruction for executing  <a href="#23f5bb8e4b8a74f7a8703d593323b991"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionWrite.html#1852e50c21b758a4db205a6cd20e208d">execute</a> (<a class="el" href="classCCPU.html">CCPU</a> *cpu)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">executes the instruction  <a href="#1852e50c21b758a4db205a6cd20e208d"></a><br></td></tr>
+<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionWrite.html#7af118a6f35320bbbee55051188311d6">m_regidx1</a></td></tr>
+
+<tr><td class="memItemLeft" nowrap align="right" valign="top">std::string&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">m_dev</a></td></tr>
+
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Implementation of assembler command "write" Syntax: write DEV, R1 (write R1 to DEV, which is a name of a display) <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="a33ddc8fb13dfaa253704eb0952f3cea"></a><!-- doxytag: member="CInstructionWrite::factory" ref="a33ddc8fb13dfaa253704eb0952f3cea" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a>* CInstructionWrite::factory           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline, virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+creates a new instance of this instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>factory </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>new instruction instance </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="23f5bb8e4b8a74f7a8703d593323b991"></a><!-- doxytag: member="CInstructionWrite::compile" ref="23f5bb8e4b8a74f7a8703d593323b991" args="(std::list&lt; std::string &gt; &amp;params)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionWrite::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::list&lt; std::string &gt; &amp;&nbsp;</td>
+          <td class="paramname"> <em>params</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+parses instruction parameters and prepares the instruction for executing 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>params</em>&nbsp;</td><td>list of parameters of this instruction </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<a class="anchor" name="1852e50c21b758a4db205a6cd20e208d"></a><!-- doxytag: member="CInstructionWrite::execute" ref="1852e50c21b758a4db205a6cd20e208d" args="(CCPU *cpu)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CInstructionWrite::execute           </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="classCCPU.html">CCPU</a> *&nbsp;</td>
+          <td class="paramname"> <em>cpu</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [virtual]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+executes the instruction 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>execute </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>cpu</em>&nbsp;</td><td>pointer to cpu </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+<p>Implements <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>.</p>
+
+</div>
+</div><p>
+<hr><h2>Member Data Documentation</h2>
+<a class="anchor" name="7af118a6f35320bbbee55051188311d6"></a><!-- doxytag: member="CInstructionWrite::m_regidx1" ref="7af118a6f35320bbbee55051188311d6" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned <a class="el" href="classCInstructionWrite.html#7af118a6f35320bbbee55051188311d6">CInstructionWrite::m_regidx1</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+register number 
+</div>
+</div><p>
+<a class="anchor" name="a8ac6c36d3fbbfedfa2311f15c0608cc"></a><!-- doxytag: member="CInstructionWrite::m_dev" ref="a8ac6c36d3fbbfedfa2311f15c0608cc" args="" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">std::string <a class="el" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">CInstructionWrite::m_dev</a><code> [protected]</code>          </td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+device name 
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="instructions_8h-source.html">instructions.h</a><li>mycpu/instructions.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCInstructionWrite.png b/ue3/doxygen/classCInstructionWrite.png
new file mode 100644
index 0000000..23bf880
Binary files /dev/null and b/ue3/doxygen/classCInstructionWrite.png differ
diff --git a/ue3/doxygen/classCMem.html b/ue3/doxygen/classCMem.html
new file mode 100644
index 0000000..6cc1e67
--- /dev/null
+++ b/ue3/doxygen/classCMem.html
@@ -0,0 +1,35 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CMem Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CMem Class Reference</h1><!-- doxytag: class="CMem" --><code>#include &lt;<a class="el" href="cmem_8h-source.html">cmem.h</a>&gt;</code>
+<p>
+<table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Memory definition for <a class="el" href="classCCPU.html">CCPU</a> <hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="cmem_8h-source.html">cmem.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCProgram-members.html b/ue3/doxygen/classCProgram-members.html
new file mode 100644
index 0000000..014f9cf
--- /dev/null
+++ b/ue3/doxygen/classCProgram-members.html
@@ -0,0 +1,33 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CProgram Member List</h1>This is the complete list of members for <a class="el" href="classCProgram.html">CProgram</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCProgram.html#e75e8a7709afcebc7f1537db247f9671">compile</a>(std::istream &amp;in)</td><td><a class="el" href="classCProgram.html">CProgram</a></td><td></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCProgram.html#74d3ca01d5e8b892f37684254ae546ed">CProgram</a>()</td><td><a class="el" href="classCProgram.html">CProgram</a></td><td></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCProgram.html#4c29c5c7932174242c50fd9d1c5bc1ec">findLabel</a>(const std::string &amp;label) const </td><td><a class="el" href="classCProgram.html">CProgram</a></td><td></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCProgram.html#8d5dc184872d4616d327c87ffa665804">getLabels</a>() const </td><td><a class="el" href="classCProgram.html">CProgram</a></td><td><code> [inline]</code></td></tr>
+  <tr class="memlist"><td><a class="el" href="classCProgram.html#7dfeb30706e7af06114fdf18262d7926">~CProgram</a>()</td><td><a class="el" href="classCProgram.html">CProgram</a></td><td></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCProgram.html b/ue3/doxygen/classCProgram.html
new file mode 100644
index 0000000..a756aaa
--- /dev/null
+++ b/ue3/doxygen/classCProgram.html
@@ -0,0 +1,234 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CProgram Class Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CProgram Class Reference</h1><!-- doxytag: class="CProgram" --><code>#include &lt;<a class="el" href="cprogram_8h-source.html">cprogram.h</a>&gt;</code>
+<p>
+
+<p>
+<a href="classCProgram-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCProgram.html#74d3ca01d5e8b892f37684254ae546ed">CProgram</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default ctor.  <a href="#74d3ca01d5e8b892f37684254ae546ed"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCProgram.html#7dfeb30706e7af06114fdf18262d7926">~CProgram</a> ()</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">Default dtor.  <a href="#7dfeb30706e7af06114fdf18262d7926"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">const std::map<br>
+&lt; std::string,<br>
+ unsigned &gt; &amp;&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCProgram.html#8d5dc184872d4616d327c87ffa665804">getLabels</a> () const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">get reference to labels map  <a href="#8d5dc184872d4616d327c87ffa665804"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCProgram.html#4c29c5c7932174242c50fd9d1c5bc1ec">findLabel</a> (const std::string &amp;label) const </td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">search for label  <a href="#4c29c5c7932174242c50fd9d1c5bc1ec"></a><br></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCProgram.html#e75e8a7709afcebc7f1537db247f9671">compile</a> (std::istream &amp;in)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">create instructions from parsing stream  <a href="#e75e8a7709afcebc7f1537db247f9671"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+<a class="el" href="classCProgram.html">CProgram</a> extends std::vector and adds a method for parsing programfile. This adds instances of <a class="el" href="classCInstruction.html">CInstruction</a> to <a class="el" href="classCProgram.html">CProgram</a> itself. <hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a class="anchor" name="74d3ca01d5e8b892f37684254ae546ed"></a><!-- doxytag: member="CProgram::CProgram" ref="74d3ca01d5e8b892f37684254ae546ed" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">CProgram::CProgram           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default ctor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd><a class="el" href="classCProgram.html">CProgram</a> </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="7dfeb30706e7af06114fdf18262d7926"></a><!-- doxytag: member="CProgram::~CProgram" ref="7dfeb30706e7af06114fdf18262d7926" args="()" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">CProgram::~CProgram           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+Default dtor. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>~CProgram </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>- </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="8d5dc184872d4616d327c87ffa665804"></a><!-- doxytag: member="CProgram::getLabels" ref="8d5dc184872d4616d327c87ffa665804" args="() const " -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const std::map&lt;std::string, unsigned&gt;&amp; CProgram::getLabels           </td>
+          <td>(</td>
+          <td class="paramname">          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const<code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+get reference to labels map 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>getLabels </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>-</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>reference to labels map </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>none</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="4c29c5c7932174242c50fd9d1c5bc1ec"></a><!-- doxytag: member="CProgram::findLabel" ref="4c29c5c7932174242c50fd9d1c5bc1ec" args="(const std::string &amp;label) const " -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned CProgram::findLabel           </td>
+          <td>(</td>
+          <td class="paramtype">const std::string &amp;&nbsp;</td>
+          <td class="paramname"> <em>label</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"> const</td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+search for label 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>findLabel </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>label</em>&nbsp;</td><td>name of label to search for </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>index of found label in program </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<a class="anchor" name="e75e8a7709afcebc7f1537db247f9671"></a><!-- doxytag: member="CProgram::compile" ref="e75e8a7709afcebc7f1537db247f9671" args="(std::istream &amp;in)" -->
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void CProgram::compile           </td>
+          <td>(</td>
+          <td class="paramtype">std::istream &amp;&nbsp;</td>
+          <td class="paramname"> <em>in</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+create instructions from parsing stream 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>compile </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>in</em>&nbsp;</td><td>inputstream to read from </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>void </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li>mycpu/<a class="el" href="cprogram_8h-source.html">cprogram.h</a><li>mycpu/cprogram.cpp</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCVectorMem-members.html b/ue3/doxygen/classCVectorMem-members.html
new file mode 100644
index 0000000..30a783a
--- /dev/null
+++ b/ue3/doxygen/classCVectorMem-members.html
@@ -0,0 +1,29 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Member List</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CVectorMem&lt; T, Allocator &gt; Member List</h1>This is the complete list of members for <a class="el" href="classCVectorMem.html">CVectorMem&lt; T, Allocator &gt;</a>, including all inherited members.<p><table>
+  <tr class="memlist"><td><a class="el" href="classCVectorMem.html#d45b088f04cf2af4c6c91bd670c5f9e6">initialize</a>(std::istream &amp;in)</td><td><a class="el" href="classCVectorMem.html">CVectorMem&lt; T, Allocator &gt;</a></td><td><code> [inline]</code></td></tr>
+</table><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/classCVectorMem.html b/ue3/doxygen/classCVectorMem.html
new file mode 100644
index 0000000..599c348
--- /dev/null
+++ b/ue3/doxygen/classCVectorMem.html
@@ -0,0 +1,83 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: CVectorMem&lt; T, Allocator &gt; Class Template Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>CVectorMem&lt; T, Allocator &gt; Class Template Reference</h1><!-- doxytag: class="CVectorMem" --><code>#include &lt;<a class="el" href="cmem_8h-source.html">cmem.h</a>&gt;</code>
+<p>
+
+<p>
+<a href="classCVectorMem-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr>
+<tr><td class="memItemLeft" nowrap align="right" valign="top">void&nbsp;</td><td class="memItemRight" valign="bottom"><a class="el" href="classCVectorMem.html#d45b088f04cf2af4c6c91bd670c5f9e6">initialize</a> (std::istream &amp;in)</td></tr>
+
+<tr><td class="mdescLeft">&nbsp;</td><td class="mdescRight">initialize the vector with the content of istream. istream is read per line. empty lines will add unitialized elements.  <a href="#d45b088f04cf2af4c6c91bd670c5f9e6"></a><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+<h3>template&lt;class T, class Allocator = std::allocator&lt;T&gt;&gt;<br>
+ class CVectorMem&lt; T, Allocator &gt;</h3>
+
+Extends std::vector template for use as memory for <a class="el" href="classCCPU.html">CCPU</a>. <hr><h2>Member Function Documentation</h2>
+<a class="anchor" name="d45b088f04cf2af4c6c91bd670c5f9e6"></a><!-- doxytag: member="CVectorMem::initialize" ref="d45b088f04cf2af4c6c91bd670c5f9e6" args="(std::istream &amp;in)" -->
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template&lt;class T, class Allocator = std::allocator&lt;T&gt;&gt; </div>
+      <table class="memname">
+        <tr>
+          <td class="memname">void <a class="el" href="classCVectorMem.html">CVectorMem</a>&lt; T, Allocator &gt;::initialize           </td>
+          <td>(</td>
+          <td class="paramtype">std::istream &amp;&nbsp;</td>
+          <td class="paramname"> <em>in</em>          </td>
+          <td>&nbsp;)&nbsp;</td>
+          <td width="100%"><code> [inline]</code></td>
+        </tr>
+      </table>
+</div>
+<div class="memdoc">
+
+<p>
+initialize the vector with the content of istream. istream is read per line. empty lines will add unitialized elements. 
+<p>
+<dl class="user" compact><dt><b>Methodname:</b></dt><dd>initialize </dd></dl>
+<dl compact><dt><b>Parameters:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>in</em>&nbsp;</td><td>inputstream to read from </td></tr>
+  </table>
+</dl>
+<dl class="return" compact><dt><b>Returns:</b></dt><dd>void </dd></dl>
+<dl class="user" compact><dt><b>Global variables used:</b></dt><dd>none </dd></dl>
+<dl compact><dt><b>Exceptions:</b></dt><dd>
+  <table border="0" cellspacing="2" cellpadding="0">
+    <tr><td valign="top"></td><td valign="top"><em>std::runtime_error</em>&nbsp;</td><td></td></tr>
+  </table>
+</dl>
+<dl class="user" compact><dt><b>Conditions:</b></dt><dd>none </dd></dl>
+
+</div>
+</div><p>
+<hr>The documentation for this class was generated from the following file:<ul>
+<li>mycpu/<a class="el" href="cmem_8h-source.html">cmem.h</a></ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/cmem_8h-source.html b/ue3/doxygen/cmem_8h-source.html
new file mode 100644
index 0000000..6dfeef4
--- /dev/null
+++ b/ue3/doxygen/cmem_8h-source.html
@@ -0,0 +1,95 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/cmem.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/cmem.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00008"></a>00008 <span class="preprocessor">#ifndef CMEM_H</span>
+<a name="l00009"></a>00009 <span class="preprocessor"></span><span class="preprocessor">#define CMEM_H 1</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span>
+<a name="l00011"></a>00011 <span class="preprocessor">#include &lt;vector&gt;</span>
+<a name="l00012"></a>00012 <span class="preprocessor">#include &lt;istream&gt;</span>
+<a name="l00013"></a>00013 <span class="preprocessor">#include &lt;sstream&gt;</span>
+<a name="l00014"></a>00014 <span class="preprocessor">#include &lt;stdexcept&gt;</span>
+<a name="l00015"></a>00015 <span class="preprocessor">#include &lt;boost/lexical_cast.hpp&gt;</span>
+<a name="l00016"></a>00016 <span class="preprocessor">#ifdef DEBUG</span>
+<a name="l00017"></a>00017 <span class="preprocessor"></span><span class="preprocessor"># include &lt;iostream&gt;</span>
+<a name="l00018"></a>00018 <span class="preprocessor"># include &lt;iomanip&gt;</span>
+<a name="l00019"></a>00019 <span class="preprocessor">#endif</span>
+<a name="l00020"></a>00020 <span class="preprocessor"></span><span class="preprocessor">#include "cdat.h"</span>
+<a name="l00021"></a>00021 
+<a name="l00027"></a>00027 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keyword">class</span> Allocator=std::allocator&lt;T&gt; &gt;
+<a name="l00028"></a><a class="code" href="classCVectorMem.html">00028</a> <span class="keyword">class </span><a class="code" href="classCVectorMem.html">CVectorMem</a>
+<a name="l00029"></a>00029   : <span class="keyword">public</span> std::vector&lt;T, Allocator&gt;
+<a name="l00030"></a>00030 {
+<a name="l00031"></a>00031   <span class="keyword">public</span>:
+<a name="l00032"></a>00032     <span class="keyword">using</span> std::vector&lt;T, Allocator&gt;::size;
+<a name="l00033"></a>00033     <span class="keyword">using</span> std::vector&lt;T, Allocator&gt;::at;
+<a name="l00034"></a>00034 
+<a name="l00045"></a><a class="code" href="classCVectorMem.html#d45b088f04cf2af4c6c91bd670c5f9e6">00045</a>     <span class="keywordtype">void</span> <a class="code" href="classCVectorMem.html#d45b088f04cf2af4c6c91bd670c5f9e6" title="initialize the vector with the content of istream. istream is read per line. empty...">initialize</a>(std::istream&amp; in)
+<a name="l00046"></a>00046     {
+<a name="l00047"></a>00047       <span class="keywordflow">if</span> (!in.good())
+<a name="l00048"></a>00048         <span class="keywordflow">return</span>;
+<a name="l00049"></a>00049 
+<a name="l00050"></a>00050       std::string line;
+<a name="l00051"></a>00051       <span class="keywordtype">unsigned</span> i = 0;
+<a name="l00052"></a>00052       <span class="keywordflow">while</span> (!in.eof() &amp;&amp; in.good())
+<a name="l00053"></a>00053       {
+<a name="l00054"></a>00054         ++i;
+<a name="l00055"></a>00055         std::getline(in, line);
+<a name="l00056"></a>00056 
+<a name="l00057"></a>00057         <span class="comment">/* skip last line if it's empty */</span>
+<a name="l00058"></a>00058         <span class="keywordflow">if</span> (line.empty() &amp;&amp; in.eof())
+<a name="l00059"></a>00059           <span class="keywordflow">break</span>;
+<a name="l00060"></a>00060 
+<a name="l00061"></a>00061         T value;
+<a name="l00062"></a>00062         <span class="keywordflow">try</span>
+<a name="l00063"></a>00063         {
+<a name="l00064"></a>00064           <span class="keywordflow">if</span> (!line.empty())
+<a name="l00065"></a>00065             value = boost::lexical_cast&lt;T&gt;(line);
+<a name="l00066"></a>00066         }
+<a name="l00067"></a>00067         <span class="keywordflow">catch</span>(boost::bad_lexical_cast&amp; ex)
+<a name="l00068"></a>00068         {
+<a name="l00069"></a>00069           std::stringstream sstr;
+<a name="l00070"></a>00070           sstr &lt;&lt; <span class="stringliteral">"Unable to convert input (line "</span> &lt;&lt; i &lt;&lt; <span class="stringliteral">"): "</span> &lt;&lt; ex.what();
+<a name="l00071"></a>00071           <span class="keywordflow">throw</span> std::runtime_error(sstr.str());
+<a name="l00072"></a>00072         }
+<a name="l00073"></a>00073 
+<a name="l00074"></a>00074         push_back(value);
+<a name="l00075"></a>00075       }
+<a name="l00076"></a>00076     }
+<a name="l00077"></a>00077 
+<a name="l00078"></a>00078 <span class="preprocessor">#if DEBUG</span>
+<a name="l00079"></a>00079 <span class="preprocessor"></span>
+<a name="l00088"></a>00088     <span class="keywordtype">void</span> dump(std::ostream&amp; out)
+<a name="l00089"></a>00089     {
+<a name="l00090"></a>00090       out &lt;&lt; <span class="stringliteral">"[MEMORY DUMP]"</span> &lt;&lt; std::endl;
+<a name="l00091"></a>00091       <span class="keywordflow">for</span>(<span class="keywordtype">unsigned</span> i = 0; i &lt; size(); ++i)
+<a name="l00092"></a>00092       {
+<a name="l00093"></a>00093         out &lt;&lt; <span class="stringliteral">"["</span> &lt;&lt; std::setw(4) &lt;&lt; std::setfill(<span class="charliteral">'0'</span>) &lt;&lt; i &lt;&lt; <span class="stringliteral">"]  "</span>
+<a name="l00094"></a>00094             &lt;&lt; at(i) &lt;&lt; std::endl;
+<a name="l00095"></a>00095       }
+<a name="l00096"></a>00096     }
+<a name="l00097"></a>00097 <span class="preprocessor">#endif</span>
+<a name="l00098"></a>00098 <span class="preprocessor"></span>};
+<a name="l00099"></a>00099 
+<a name="l00105"></a>00105 <span class="keyword">typedef</span> <a class="code" href="classCVectorMem.html">CVectorMem&lt;CDat&gt;</a> <a class="code" href="classCMem.html">CMem</a>;
+<a name="l00106"></a>00106 
+<a name="l00107"></a>00107 <span class="preprocessor">#endif</span>
+<a name="l00108"></a>00108 <span class="preprocessor"></span>
+<a name="l00109"></a>00109 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/cprogram_8h-source.html b/ue3/doxygen/cprogram_8h-source.html
new file mode 100644
index 0000000..dfd39a8
--- /dev/null
+++ b/ue3/doxygen/cprogram_8h-source.html
@@ -0,0 +1,60 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/cprogram.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/cprogram.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00008"></a>00008 <span class="preprocessor">#ifndef CPROGRAM_H</span>
+<a name="l00009"></a>00009 <span class="preprocessor"></span><span class="preprocessor">#define CPROGRAM_H 1</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span>
+<a name="l00011"></a>00011 <span class="preprocessor">#include &lt;vector&gt;</span>
+<a name="l00012"></a>00012 <span class="preprocessor">#include &lt;set&gt;</span>
+<a name="l00013"></a>00013 <span class="preprocessor">#include &lt;map&gt;</span>
+<a name="l00014"></a>00014 <span class="preprocessor">#include "cinstruction.h"</span>
+<a name="l00015"></a>00015 
+<a name="l00022"></a><a class="code" href="classCProgram.html">00022</a> <span class="keyword">class </span><a class="code" href="classCProgram.html">CProgram</a>
+<a name="l00023"></a>00023   : <span class="keyword">public</span> std::vector&lt;CInstruction *&gt;
+<a name="l00024"></a>00024 {
+<a name="l00025"></a>00025   <span class="keyword">public</span>:
+<a name="l00035"></a>00035     <a class="code" href="classCProgram.html#74d3ca01d5e8b892f37684254ae546ed" title="Default ctor.">CProgram</a>();
+<a name="l00036"></a>00036 
+<a name="l00046"></a>00046     <a class="code" href="classCProgram.html#7dfeb30706e7af06114fdf18262d7926" title="Default dtor.">~CProgram</a>();
+<a name="l00047"></a>00047 
+<a name="l00057"></a><a class="code" href="classCProgram.html#8d5dc184872d4616d327c87ffa665804">00057</a>     <span class="keyword">const</span> std::map&lt;std::string, unsigned&gt;&amp; <a class="code" href="classCProgram.html#8d5dc184872d4616d327c87ffa665804" title="get reference to labels map">getLabels</a>()<span class="keyword"> const</span>
+<a name="l00058"></a>00058 <span class="keyword">    </span>{
+<a name="l00059"></a>00059       <span class="keywordflow">return</span> m_labels;
+<a name="l00060"></a>00060     }
+<a name="l00061"></a>00061 
+<a name="l00071"></a>00071     <span class="keywordtype">unsigned</span> <a class="code" href="classCProgram.html#4c29c5c7932174242c50fd9d1c5bc1ec" title="search for label">findLabel</a>(<span class="keyword">const</span> std::string&amp; label) <span class="keyword">const</span>;
+<a name="l00072"></a>00072 
+<a name="l00082"></a>00082     <span class="keywordtype">void</span> <a class="code" href="classCProgram.html#e75e8a7709afcebc7f1537db247f9671" title="create instructions from parsing stream">compile</a>(std::istream&amp; in);
+<a name="l00083"></a>00083 
+<a name="l00084"></a>00084 <span class="preprocessor">#if DEBUG</span>
+<a name="l00085"></a>00085 <span class="preprocessor"></span>
+<a name="l00094"></a>00094     <span class="keywordtype">void</span> dump(std::ostream&amp; out);
+<a name="l00095"></a>00095 <span class="preprocessor">#endif</span>
+<a name="l00096"></a>00096 <span class="preprocessor"></span>
+<a name="l00097"></a>00097   <span class="keyword">private</span>:
+<a name="l00098"></a>00098     <span class="comment">/* members */</span>
+<a name="l00100"></a>00100     std::set&lt;CInstruction *&gt; m_instrset;
+<a name="l00101"></a>00101     std::map&lt;std::string, unsigned&gt; m_labels;
+<a name="l00102"></a>00102 };
+<a name="l00103"></a>00103 
+<a name="l00104"></a>00104 <span class="preprocessor">#endif</span>
+<a name="l00105"></a>00105 <span class="preprocessor"></span>
+<a name="l00106"></a>00106 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/displays_8h-source.html b/ue3/doxygen/displays_8h-source.html
new file mode 100644
index 0000000..7bc4076
--- /dev/null
+++ b/ue3/doxygen/displays_8h-source.html
@@ -0,0 +1,60 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/displays.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/displays.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00008"></a>00008 <span class="preprocessor">#ifndef DISPLAYS_H</span>
+<a name="l00009"></a>00009 <span class="preprocessor"></span><span class="preprocessor">#define DISPLAYS_H 1</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span>
+<a name="l00011"></a>00011 <span class="preprocessor">#include &lt;iomanip&gt;</span>
+<a name="l00012"></a>00012 <span class="preprocessor">#include "cdisplay.h"</span>
+<a name="l00013"></a>00013 
+<a name="l00020"></a><a class="code" href="classCDisplayWDEZ.html">00020</a> <span class="keyword">class </span><a class="code" href="classCDisplayWDEZ.html">CDisplayWDEZ</a>
+<a name="l00021"></a>00021   : <span class="keyword">public</span> <a class="code" href="classCDisplay.html">CDisplay</a>
+<a name="l00022"></a>00022 {
+<a name="l00023"></a>00023   <span class="keyword">public</span>:
+<a name="l00024"></a>00024     <a class="code" href="classCDisplayWDEZ.html">CDisplayWDEZ</a>()
+<a name="l00025"></a>00025       : <a class="code" href="classCDisplay.html">CDisplay</a>(<span class="stringliteral">"wdez"</span>)
+<a name="l00026"></a>00026     {}
+<a name="l00027"></a>00027 
+<a name="l00037"></a><a class="code" href="classCDisplayWDEZ.html#91798e80f37ec86e3aa7d0f899e3a8dc">00037</a>     <span class="keywordtype">void</span> <a class="code" href="classCDisplayWDEZ.html#91798e80f37ec86e3aa7d0f899e3a8dc" title="prints value to display">display</a>(<span class="keyword">const</span> <a class="code" href="classCDat.html">CDat</a> &amp;value)
+<a name="l00038"></a>00038     {
+<a name="l00039"></a>00039       std::cout &lt;&lt; std::dec &lt;&lt; value &lt;&lt; std::endl;
+<a name="l00040"></a>00040     }
+<a name="l00041"></a>00041 };
+<a name="l00042"></a>00042 
+<a name="l00043"></a>00043 <span class="comment">/*============================================================================*/</span>
+<a name="l00044"></a>00044 
+<a name="l00051"></a><a class="code" href="classCDisplayWHEX.html">00051</a> <span class="keyword">class </span><a class="code" href="classCDisplayWHEX.html">CDisplayWHEX</a>
+<a name="l00052"></a>00052   : <span class="keyword">public</span> <a class="code" href="classCDisplay.html">CDisplay</a>
+<a name="l00053"></a>00053 {
+<a name="l00054"></a>00054   <span class="keyword">public</span>:
+<a name="l00055"></a>00055     <a class="code" href="classCDisplayWHEX.html">CDisplayWHEX</a>()
+<a name="l00056"></a>00056       : <a class="code" href="classCDisplay.html">CDisplay</a>(<span class="stringliteral">"whex"</span>)
+<a name="l00057"></a>00057     {}
+<a name="l00058"></a>00058 
+<a name="l00068"></a><a class="code" href="classCDisplayWHEX.html#6adaa6532cd684060029e31457d83752">00068</a>     <span class="keywordtype">void</span> <a class="code" href="classCDisplayWHEX.html#6adaa6532cd684060029e31457d83752" title="prints value to display">display</a>(<span class="keyword">const</span> <a class="code" href="classCDat.html">CDat</a> &amp;value)
+<a name="l00069"></a>00069     {
+<a name="l00070"></a>00070       std::cout &lt;&lt; std::hex &lt;&lt; value &lt;&lt; std::endl;
+<a name="l00071"></a>00071     }
+<a name="l00072"></a>00072 };
+<a name="l00073"></a>00073 
+<a name="l00074"></a>00074 <span class="preprocessor">#endif</span>
+<a name="l00075"></a>00075 <span class="preprocessor"></span>
+<a name="l00076"></a>00076 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/doxygen.css b/ue3/doxygen/doxygen.css
new file mode 100644
index 0000000..c7db1a8
--- /dev/null
+++ b/ue3/doxygen/doxygen.css
@@ -0,0 +1,358 @@
+BODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV {
+	font-family: Geneva, Arial, Helvetica, sans-serif;
+}
+BODY,TD {
+       font-size: 90%;
+}
+H1 {
+	text-align: center;
+       font-size: 160%;
+}
+H2 {
+       font-size: 120%;
+}
+H3 {
+       font-size: 100%;
+}
+CAPTION { font-weight: bold }
+DIV.qindex {
+	width: 100%;
+	background-color: #e8eef2;
+	border: 1px solid #84b0c7;
+	text-align: center;
+	margin: 2px;
+	padding: 2px;
+	line-height: 140%;
+}
+DIV.nav {
+	width: 100%;
+	background-color: #e8eef2;
+	border: 1px solid #84b0c7;
+	text-align: center;
+	margin: 2px;
+	padding: 2px;
+	line-height: 140%;
+}
+DIV.navtab {
+       background-color: #e8eef2;
+       border: 1px solid #84b0c7;
+       text-align: center;
+       margin: 2px;
+       margin-right: 15px;
+       padding: 2px;
+}
+TD.navtab {
+       font-size: 70%;
+}
+A.qindex {
+       text-decoration: none;
+       font-weight: bold;
+       color: #1A419D;
+}
+A.qindex:visited {
+       text-decoration: none;
+       font-weight: bold;
+       color: #1A419D
+}
+A.qindex:hover {
+	text-decoration: none;
+	background-color: #ddddff;
+}
+A.qindexHL {
+	text-decoration: none;
+	font-weight: bold;
+	background-color: #6666cc;
+	color: #ffffff;
+	border: 1px double #9295C2;
+}
+A.qindexHL:hover {
+	text-decoration: none;
+	background-color: #6666cc;
+	color: #ffffff;
+}
+A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff }
+A.el { text-decoration: none; font-weight: bold }
+A.elRef { font-weight: bold }
+A.code:link { text-decoration: none; font-weight: normal; color: #0000FF}
+A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF}
+A.codeRef:link { font-weight: normal; color: #0000FF}
+A.codeRef:visited { font-weight: normal; color: #0000FF}
+A:hover { text-decoration: none; background-color: #f2f2ff }
+DL.el { margin-left: -1cm }
+.fragment {
+       font-family: monospace, fixed;
+       font-size: 95%;
+}
+PRE.fragment {
+	border: 1px solid #CCCCCC;
+	background-color: #f5f5f5;
+	margin-top: 4px;
+	margin-bottom: 4px;
+	margin-left: 2px;
+	margin-right: 8px;
+	padding-left: 6px;
+	padding-right: 6px;
+	padding-top: 4px;
+	padding-bottom: 4px;
+}
+DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px }
+
+DIV.groupHeader {
+       margin-left: 16px;
+       margin-top: 12px;
+       margin-bottom: 6px;
+       font-weight: bold;
+}
+DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% }
+BODY {
+	background: white;
+	color: black;
+	margin-right: 20px;
+	margin-left: 20px;
+}
+TD.indexkey {
+	background-color: #e8eef2;
+	font-weight: bold;
+	padding-right  : 10px;
+	padding-top    : 2px;
+	padding-left   : 10px;
+	padding-bottom : 2px;
+	margin-left    : 0px;
+	margin-right   : 0px;
+	margin-top     : 2px;
+	margin-bottom  : 2px;
+	border: 1px solid #CCCCCC;
+}
+TD.indexvalue {
+	background-color: #e8eef2;
+	font-style: italic;
+	padding-right  : 10px;
+	padding-top    : 2px;
+	padding-left   : 10px;
+	padding-bottom : 2px;
+	margin-left    : 0px;
+	margin-right   : 0px;
+	margin-top     : 2px;
+	margin-bottom  : 2px;
+	border: 1px solid #CCCCCC;
+}
+TR.memlist {
+   background-color: #f0f0f0; 
+}
+P.formulaDsp { text-align: center; }
+IMG.formulaDsp { }
+IMG.formulaInl { vertical-align: middle; }
+SPAN.keyword       { color: #008000 }
+SPAN.keywordtype   { color: #604020 }
+SPAN.keywordflow   { color: #e08000 }
+SPAN.comment       { color: #800000 }
+SPAN.preprocessor  { color: #806020 }
+SPAN.stringliteral { color: #002080 }
+SPAN.charliteral   { color: #008080 }
+.mdescLeft {
+       padding: 0px 8px 4px 8px;
+	font-size: 80%;
+	font-style: italic;
+	background-color: #FAFAFA;
+	border-top: 1px none #E0E0E0;
+	border-right: 1px none #E0E0E0;
+	border-bottom: 1px none #E0E0E0;
+	border-left: 1px none #E0E0E0;
+	margin: 0px;
+}
+.mdescRight {
+       padding: 0px 8px 4px 8px;
+	font-size: 80%;
+	font-style: italic;
+	background-color: #FAFAFA;
+	border-top: 1px none #E0E0E0;
+	border-right: 1px none #E0E0E0;
+	border-bottom: 1px none #E0E0E0;
+	border-left: 1px none #E0E0E0;
+	margin: 0px;
+}
+.memItemLeft {
+	padding: 1px 0px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: solid;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memItemRight {
+	padding: 1px 8px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: solid;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memTemplItemLeft {
+	padding: 1px 0px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: none;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memTemplItemRight {
+	padding: 1px 8px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: none;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memTemplParams {
+	padding: 1px 0px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: solid;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+       color: #606060;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.search     { color: #003399;
+              font-weight: bold;
+}
+FORM.search {
+              margin-bottom: 0px;
+              margin-top: 0px;
+}
+INPUT.search { font-size: 75%;
+               color: #000080;
+               font-weight: normal;
+               background-color: #e8eef2;
+}
+TD.tiny      { font-size: 75%;
+}
+a {
+	color: #1A41A8;
+}
+a:visited {
+	color: #2A3798;
+}
+.dirtab { padding: 4px;
+          border-collapse: collapse;
+          border: 1px solid #84b0c7;
+}
+TH.dirtab { background: #e8eef2;
+            font-weight: bold;
+}
+HR { height: 1px;
+     border: none;
+     border-top: 1px solid black;
+}
+
+/* Style for detailed member documentation */
+.memtemplate {
+  font-size: 80%;
+  color: #606060;
+  font-weight: normal;
+} 
+.memnav { 
+  background-color: #e8eef2;
+  border: 1px solid #84b0c7;
+  text-align: center;
+  margin: 2px;
+  margin-right: 15px;
+  padding: 2px;
+}
+.memitem {
+  padding: 4px;
+  background-color: #eef3f5;
+  border-width: 1px;
+  border-style: solid;
+  border-color: #dedeee;
+  -moz-border-radius: 8px 8px 8px 8px;
+}
+.memname {
+  white-space: nowrap;
+  font-weight: bold;
+}
+.memdoc{
+  padding-left: 10px;
+}
+.memproto {
+  background-color: #d5e1e8;
+  width: 100%;
+  border-width: 1px;
+  border-style: solid;
+  border-color: #84b0c7;
+  font-weight: bold;
+  -moz-border-radius: 8px 8px 8px 8px;
+}
+.paramkey {
+  text-align: right;
+}
+.paramtype {
+  white-space: nowrap;
+}
+.paramname {
+  color: #602020;
+  font-style: italic;
+  white-space: nowrap;
+}
+/* End Styling for detailed member documentation */
+
+/* for the tree view */
+.ftvtree {
+	font-family: sans-serif;
+	margin:0.5em;
+}
+.directory { font-size: 9pt; font-weight: bold; }
+.directory h3 { margin: 0px; margin-top: 1em; font-size: 11pt; }
+.directory > h3 { margin-top: 0; }
+.directory p { margin: 0px; white-space: nowrap; }
+.directory div { display: none; margin: 0px; }
+.directory img { vertical-align: -30%; }
diff --git a/ue3/doxygen/doxygen.png b/ue3/doxygen/doxygen.png
new file mode 100644
index 0000000..f0a274b
Binary files /dev/null and b/ue3/doxygen/doxygen.png differ
diff --git a/ue3/doxygen/files.html b/ue3/doxygen/files.html
new file mode 100644
index 0000000..7921007
--- /dev/null
+++ b/ue3/doxygen/files.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: File Index</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu File List</h1>Here is a list of all documented files with brief descriptions:<table>
+  <tr><td class="indexkey">mycpu/<b>ccpu.h</b> <a href="ccpu_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey">mycpu/<b>cdat.h</b> <a href="cdat_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey">mycpu/<b>cdisplay.h</b> <a href="cdisplay_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey">mycpu/<b>cinstruction.h</b> <a href="cinstruction_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey">mycpu/<b>cmem.h</b> <a href="cmem_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey">mycpu/<b>cprogram.h</b> <a href="cprogram_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey">mycpu/<b>displays.h</b> <a href="displays_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey">mycpu/<b>instructions.h</b> <a href="instructions_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+</table>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/functions.html b/ue3/doxygen/functions.html
new file mode 100644
index 0000000..2ec6814
--- /dev/null
+++ b/ue3/doxygen/functions.html
@@ -0,0 +1,259 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Class Members</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li class="current"><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li class="current"><a href="functions.html"><span>All</span></a></li>
+    <li><a href="functions_func.html"><span>Functions</span></a></li>
+    <li><a href="functions_vars.html"><span>Variables</span></a></li>
+    <li><a href="functions_rela.html"><span>Related&nbsp;Functions</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="#index_c"><span>c</span></a></li>
+    <li><a href="#index_d"><span>d</span></a></li>
+    <li><a href="#index_e"><span>e</span></a></li>
+    <li><a href="#index_f"><span>f</span></a></li>
+    <li><a href="#index_g"><span>g</span></a></li>
+    <li><a href="#index_i"><span>i</span></a></li>
+    <li><a href="#index_m"><span>m</span></a></li>
+    <li><a href="#index_o"><span>o</span></a></li>
+    <li><a href="#index_p"><span>p</span></a></li>
+    <li><a href="#index_r"><span>r</span></a></li>
+    <li><a href="#index_s"><span>s</span></a></li>
+    <li><a href="#index_~"><span>~</span></a></li>
+  </ul>
+</div>
+
+<p>
+Here is a list of all documented class members with links to the class documentation for each member:
+<p>
+<h3><a class="anchor" name="index_c">- c -</a></h3><ul>
+<li>CCPU()
+: <a class="el" href="classCCPU.html#12b0f403ddbfae0ff52cbf079b96395b">CCPU</a>
+<li>CDatT()
+: <a class="el" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4">CDatT&lt; T &gt;</a>
+<li>CDisplayT()
+: <a class="el" href="classCDisplayT.html#d65d27ce8533285525788f3cc534ff14">CDisplayT&lt; T &gt;</a>
+<li>checkRegister()
+: <a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">CInstruction</a>
+<li>CInstruction()
+: <a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>
+<li>compile()
+: <a class="el" href="classCInstructionTest.html#b09f0e02ab71b01af6eda0152d1fc975">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#9848bf36bd3ec75ae481d8ef1f36c6ee">CInstructionStore</a>
+, <a class="el" href="classCInstructionJumpZ.html#e4c05192b829d2bcc1e838de195ef3d9">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionDiv.html#349324231c5516886d99caf07ecb8c0c">CInstructionDiv</a>
+, <a class="el" href="classCInstructionMul.html#188024d90dd19fcea0687d32e98c67a7">CInstructionMul</a>
+, <a class="el" href="classCInstructionSub.html#9fe6d8f0f805313c98f8806a4739cbe9">CInstructionSub</a>
+, <a class="el" href="classCInstructionAdd.html#1da9f4b4016d27f2866add0b91e3b0fc">CInstructionAdd</a>
+, <a class="el" href="classCInstructionDec.html#84347e9b3a373bafc5c1ae79a557f4c3">CInstructionDec</a>
+, <a class="el" href="classCInstructionInc.html#ae36e952ec66b1c5cc2fb7e7c80064cc">CInstructionInc</a>
+, <a class="el" href="classCProgram.html#e75e8a7709afcebc7f1537db247f9671">CProgram</a>
+, <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>
+, <a class="el" href="classCInstructionJumpA.html#f772a57214b192263594d2ff46f03a1e">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionJumpS.html#671d749a6e93f26851879c4ceac09f4c">CInstructionJumpS</a>
+, <a class="el" href="classCInstructionWrite.html#23f5bb8e4b8a74f7a8703d593323b991">CInstructionWrite</a>
+, <a class="el" href="classCInstructionLoad.html#4aa70fe481286e0bcc27f7a9ce896d3d">CInstructionLoad</a>
+, <a class="el" href="classCInstructionLabel.html#321fd849ae169d900964431b4100321f">CInstructionLabel</a>
+<li>CProgram()
+: <a class="el" href="classCProgram.html#74d3ca01d5e8b892f37684254ae546ed">CProgram</a>
+</ul>
+<h3><a class="anchor" name="index_d">- d -</a></h3><ul>
+<li>display()
+: <a class="el" href="classCDisplayT.html#5a15f96d3d76bdbb2b172c52036859c2">CDisplayT&lt; T &gt;</a>
+, <a class="el" href="classCDisplayWDEZ.html#91798e80f37ec86e3aa7d0f899e3a8dc">CDisplayWDEZ</a>
+, <a class="el" href="classCDisplayWHEX.html#6adaa6532cd684060029e31457d83752">CDisplayWHEX</a>
+<li>dump()
+: <a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">CInstruction</a>
+</ul>
+<h3><a class="anchor" name="index_e">- e -</a></h3><ul>
+<li>execute()
+: <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>
+, <a class="el" href="classCInstructionWrite.html#1852e50c21b758a4db205a6cd20e208d">CInstructionWrite</a>
+, <a class="el" href="classCInstructionJumpS.html#8c2e8e077463e64ca64204bb6ed20f71">CInstructionJumpS</a>
+, <a class="el" href="classCInstructionJumpZ.html#92f15deda156ebd20e8af47589753783">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionJumpA.html#76daeedb9c7cb3be0173580be9390887">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionLabel.html#665f2fc395ffed3bd968659f67868f53">CInstructionLabel</a>
+, <a class="el" href="classCInstructionTest.html#955cf58c41c9e305059baea28b65cf3a">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#fd5ee6692540613ee8cc9a2bf8ff920a">CInstructionStore</a>
+, <a class="el" href="classCInstructionLoad.html#fdda1d554401f9bfd32a6300f5ad2bb6">CInstructionLoad</a>
+, <a class="el" href="classCInstructionDiv.html#7fee4e02bc6904c9d6039aa467aed1f4">CInstructionDiv</a>
+, <a class="el" href="classCInstructionMul.html#0675f51cbfb5d0d76e605f64b0b2555c">CInstructionMul</a>
+, <a class="el" href="classCInstructionSub.html#03e098595198d4cc2f45d906e45e7f28">CInstructionSub</a>
+, <a class="el" href="classCInstructionAdd.html#3c6844fd425de436ba3e7fbc98fd69e8">CInstructionAdd</a>
+, <a class="el" href="classCInstructionDec.html#b0a51da3b41aaa4e3e51baaa4151ebca">CInstructionDec</a>
+, <a class="el" href="classCInstructionInc.html#2830b4c1aa89410e309821119ecf4d6f">CInstructionInc</a>
+</ul>
+<h3><a class="anchor" name="index_f">- f -</a></h3><ul>
+<li>factory()
+: <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>
+, <a class="el" href="classCInstructionInc.html#d55c35cbbd5c88fd29a392051e79f5f1">CInstructionInc</a>
+, <a class="el" href="classCInstructionWrite.html#a33ddc8fb13dfaa253704eb0952f3cea">CInstructionWrite</a>
+, <a class="el" href="classCInstructionJumpS.html#4b25703a62dafb568700dcad217f7ba6">CInstructionJumpS</a>
+, <a class="el" href="classCInstructionJumpZ.html#e0750f1ce4a5746be3317024f4ef92eb">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionJumpA.html#d7679ea0d70ab9725f84dcce76adc057">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionLabel.html#66ba5bd6facecd45f3616fc94eb2845f">CInstructionLabel</a>
+, <a class="el" href="classCInstructionTest.html#9e4e1ac29b5173a70dc1172bbb096671">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#cab0d4c9bf2cc0d6b1b450ef9aeebcc0">CInstructionStore</a>
+, <a class="el" href="classCInstructionAdd.html#6fa9bae98f84f5ae34946641fb03ff32">CInstructionAdd</a>
+, <a class="el" href="classCInstructionDiv.html#3445767e66ab734ec88b6084a10c4446">CInstructionDiv</a>
+, <a class="el" href="classCInstructionMul.html#1e8f23073a29a0d50fa9d651b986e821">CInstructionMul</a>
+, <a class="el" href="classCInstructionSub.html#71c77a5113f96ac25e79bc4d28072541">CInstructionSub</a>
+, <a class="el" href="classCInstructionLoad.html#35c051515ccd6a12dbb39ab4b2e33ded">CInstructionLoad</a>
+, <a class="el" href="classCInstructionDec.html#5aa3bcd55f05765e25758f45f4f55059">CInstructionDec</a>
+<li>findLabel()
+: <a class="el" href="classCProgram.html#4c29c5c7932174242c50fd9d1c5bc1ec">CProgram</a>
+</ul>
+<h3><a class="anchor" name="index_g">- g -</a></h3><ul>
+<li>getDisplays()
+: <a class="el" href="classCCPU.html#aab308415ce3083eaa66b9aa1dcbb0c6">CCPU</a>
+<li>getFlagSign()
+: <a class="el" href="classCCPU.html#c3d7d2bf5f93aa2d7b6f5959b8448ea2">CCPU</a>
+<li>getFlagZero()
+: <a class="el" href="classCCPU.html#9398f58c5a715653c3502040029501a1">CCPU</a>
+<li>getLabels()
+: <a class="el" href="classCProgram.html#8d5dc184872d4616d327c87ffa665804">CProgram</a>
+<li>getMemory()
+: <a class="el" href="classCCPU.html#47e3302a8d9582b29a4d722735d8aa60">CCPU</a>
+<li>getName()
+: <a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">CInstruction</a>
+, <a class="el" href="classCDisplayT.html#32897b9abaec6e9a0e73ae746ab5cec0">CDisplayT&lt; T &gt;</a>
+<li>getProgram()
+: <a class="el" href="classCCPU.html#f7c34c0ba7230ecc980a5ff7730cdbae">CCPU</a>
+<li>getRegisterCount()
+: <a class="el" href="classCCPU.html#b25ee10ea09dfe12d9e77e5eb2126d32">CCPU</a>
+<li>getRegisters()
+: <a class="el" href="classCCPU.html#efe3e22919627e5daf525d11b13d5c44">CCPU</a>
+<li>getValue()
+: <a class="el" href="classCDatT.html#8c226fb0b0974a0cbb7897d94f75e4e0">CDatT&lt; T &gt;</a>
+</ul>
+<h3><a class="anchor" name="index_i">- i -</a></h3><ul>
+<li>initialize()
+: <a class="el" href="classCVectorMem.html#d45b088f04cf2af4c6c91bd670c5f9e6">CVectorMem&lt; T, Allocator &gt;</a>
+</ul>
+<h3><a class="anchor" name="index_m">- m -</a></h3><ul>
+<li>m_addr
+: <a class="el" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">CInstructionJumpS</a>
+<li>m_dev
+: <a class="el" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">CInstructionWrite</a>
+<li>m_name
+: <a class="el" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">CDisplayT&lt; T &gt;</a>
+, <a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">CInstruction</a>
+<li>m_regidx1
+: <a class="el" href="classCInstructionDec.html#4ea09ae25025e93c2790d5dc1536f41c">CInstructionDec</a>
+, <a class="el" href="classCInstructionWrite.html#7af118a6f35320bbbee55051188311d6">CInstructionWrite</a>
+, <a class="el" href="classCInstructionAdd.html#2808878fbfbee48f1c300bdd976446f4">CInstructionAdd</a>
+, <a class="el" href="classCInstructionSub.html#f9884524cd60c34f3d9a5142e1e586fb">CInstructionSub</a>
+, <a class="el" href="classCInstructionMul.html#c5c3b5b125973a0396c3ad7e0233b79f">CInstructionMul</a>
+, <a class="el" href="classCInstructionDiv.html#356508c5c90a345bdd0055385227852f">CInstructionDiv</a>
+, <a class="el" href="classCInstructionTest.html#26744f0f306f4a181936fc6e389eb9e3">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#5e57d0d27d70f13a590355f5c1782cc9">CInstructionStore</a>
+, <a class="el" href="classCInstructionLoad.html#91139a066176d4be83258eba0b412cb6">CInstructionLoad</a>
+, <a class="el" href="classCInstructionInc.html#b910df5b37f4d1352736913ee0cb7fb0">CInstructionInc</a>
+<li>m_regidx2
+: <a class="el" href="classCInstructionMul.html#eaaaff76fe29741fce14b322d4da8a54">CInstructionMul</a>
+, <a class="el" href="classCInstructionDiv.html#5a9c4be1386df1fa866927336abe3054">CInstructionDiv</a>
+, <a class="el" href="classCInstructionAdd.html#98e9005e15d5eb69ce561a91348a3a91">CInstructionAdd</a>
+, <a class="el" href="classCInstructionLoad.html#dbb1c5a56e063ce77d3b8d26355e2a49">CInstructionLoad</a>
+, <a class="el" href="classCInstructionSub.html#67030fafc6429936130bbe26874c337c">CInstructionSub</a>
+, <a class="el" href="classCInstructionStore.html#d960c6b85e7022704b4d7d059e1766d1">CInstructionStore</a>
+<li>m_regidx3
+: <a class="el" href="classCInstructionSub.html#a059bfa11944c55216619bb4328ed44e">CInstructionSub</a>
+, <a class="el" href="classCInstructionAdd.html#1c5979587fea23262a9bc593b9dc61a3">CInstructionAdd</a>
+, <a class="el" href="classCInstructionMul.html#171d8573f80224249ac14e4c8fec0c7b">CInstructionMul</a>
+, <a class="el" href="classCInstructionDiv.html#3e7033bb26ef68b051b0da8a8279df85">CInstructionDiv</a>
+</ul>
+<h3><a class="anchor" name="index_o">- o -</a></h3><ul>
+<li>operator &amp;=()
+: <a class="el" href="classCDatT.html#3ec7b2fac8d93e51cd87acda04d7f41e">CDatT&lt; T &gt;</a>
+<li>operator *=()
+: <a class="el" href="classCDatT.html#707446768fff0c8e9a56c4af874d0224">CDatT&lt; T &gt;</a>
+<li>operator T()
+: <a class="el" href="classCDatT.html#5915d4f7de6dceea7d0d7253ce8ff5c9">CDatT&lt; T &gt;</a>
+<li>operator%=()
+: <a class="el" href="classCDatT.html#403d947a670fcc25dc0ae4e00293cc33">CDatT&lt; T &gt;</a>
+<li>operator()()
+: <a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">CInstruction</a>
+<li>operator++()
+: <a class="el" href="classCDatT.html#9a17a5e35049ad6a150ec800ddb81e64">CDatT&lt; T &gt;</a>
+<li>operator+=()
+: <a class="el" href="classCDatT.html#f4f1e37bd94b17229dd0e181fcf41860">CDatT&lt; T &gt;</a>
+<li>operator--()
+: <a class="el" href="classCDatT.html#ec2be360ce61195c92db1ba4d2db0d8b">CDatT&lt; T &gt;</a>
+<li>operator-=()
+: <a class="el" href="classCDatT.html#24cf91d1ac4e0277547ec158ed35544a">CDatT&lt; T &gt;</a>
+<li>operator/=()
+: <a class="el" href="classCDatT.html#c68e6cd45ae94ef7485650e72f07c49d">CDatT&lt; T &gt;</a>
+<li>operator&lt;()
+: <a class="el" href="classCDatT.html#acd2ef7a53a0c4b128485147171d0cbd">CDatT&lt; T &gt;</a>
+<li>operator&lt;&lt;
+: <a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">CInstruction</a>
+, <a class="el" href="classCDatT.html#81465346cb4f31cf76336d46c512d0f6">CDatT&lt; T &gt;</a>
+<li>operator==()
+: <a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">CInstruction</a>
+, <a class="el" href="classCDatT.html#884afb7b0c4e972c25f12f6eff15177d">CDatT&lt; T &gt;</a>
+<li>operator&gt;&gt;
+: <a class="el" href="classCDatT.html#16f0666a0b7c3383eb965daf48134fab">CDatT&lt; T &gt;</a>
+<li>operator^=()
+: <a class="el" href="classCDatT.html#03cf22edd6b2489e63be6cc846de789f">CDatT&lt; T &gt;</a>
+<li>operator|=()
+: <a class="el" href="classCDatT.html#f98140b24016e58307bf92b556157a13">CDatT&lt; T &gt;</a>
+</ul>
+<h3><a class="anchor" name="index_p">- p -</a></h3><ul>
+<li>parseRegister()
+: <a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">CInstruction</a>
+</ul>
+<h3><a class="anchor" name="index_r">- r -</a></h3><ul>
+<li>run()
+: <a class="el" href="classCCPU.html#045df5c772702bdc1454fb90d512fb68">CCPU</a>
+</ul>
+<h3><a class="anchor" name="index_s">- s -</a></h3><ul>
+<li>setFlagSign()
+: <a class="el" href="classCCPU.html#d8226c190477e2fbce0ddf7d814a272e">CCPU</a>
+<li>setFlagZero()
+: <a class="el" href="classCCPU.html#33c8a01cbafddb40cf9283109b3a0b08">CCPU</a>
+<li>setMemory()
+: <a class="el" href="classCCPU.html#bb2644a658cbfbcdd7c579a2840cee67">CCPU</a>
+<li>setProgram()
+: <a class="el" href="classCCPU.html#3790f6567091892f8867329424d03f71">CCPU</a>
+</ul>
+<h3><a class="anchor" name="index_~">- ~ -</a></h3><ul>
+<li>~CCPU()
+: <a class="el" href="classCCPU.html#7523a3b0b832774c3df57bd019273a68">CCPU</a>
+<li>~CDatT()
+: <a class="el" href="classCDatT.html#8ddaa1aaef85fea9e7c3613ccdc5a891">CDatT&lt; T &gt;</a>
+<li>~CDisplayT()
+: <a class="el" href="classCDisplayT.html#edeeab4320b2c3a5b482d216e73e5999">CDisplayT&lt; T &gt;</a>
+<li>~CInstruction()
+: <a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">CInstruction</a>
+<li>~CProgram()
+: <a class="el" href="classCProgram.html#7dfeb30706e7af06114fdf18262d7926">CProgram</a>
+</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/functions_func.html b/ue3/doxygen/functions_func.html
new file mode 100644
index 0000000..bb8ca9a
--- /dev/null
+++ b/ue3/doxygen/functions_func.html
@@ -0,0 +1,219 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Class Members - Functions</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li class="current"><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="functions.html"><span>All</span></a></li>
+    <li class="current"><a href="functions_func.html"><span>Functions</span></a></li>
+    <li><a href="functions_vars.html"><span>Variables</span></a></li>
+    <li><a href="functions_rela.html"><span>Related&nbsp;Functions</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="#index_c"><span>c</span></a></li>
+    <li><a href="#index_d"><span>d</span></a></li>
+    <li><a href="#index_e"><span>e</span></a></li>
+    <li><a href="#index_f"><span>f</span></a></li>
+    <li><a href="#index_g"><span>g</span></a></li>
+    <li><a href="#index_i"><span>i</span></a></li>
+    <li><a href="#index_o"><span>o</span></a></li>
+    <li><a href="#index_p"><span>p</span></a></li>
+    <li><a href="#index_r"><span>r</span></a></li>
+    <li><a href="#index_s"><span>s</span></a></li>
+    <li><a href="#index_~"><span>~</span></a></li>
+  </ul>
+</div>
+
+<p>
+&nbsp;
+<p>
+<h3><a class="anchor" name="index_c">- c -</a></h3><ul>
+<li>CCPU()
+: <a class="el" href="classCCPU.html#12b0f403ddbfae0ff52cbf079b96395b">CCPU</a>
+<li>CDatT()
+: <a class="el" href="classCDatT.html#afb8aa2eb6000ad2f54f31d6d5df57a4">CDatT&lt; T &gt;</a>
+<li>CDisplayT()
+: <a class="el" href="classCDisplayT.html#d65d27ce8533285525788f3cc534ff14">CDisplayT&lt; T &gt;</a>
+<li>checkRegister()
+: <a class="el" href="classCInstruction.html#8e938360a34f1cd3bf799f21e2ce6f6c">CInstruction</a>
+<li>CInstruction()
+: <a class="el" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78">CInstruction</a>
+<li>compile()
+: <a class="el" href="classCInstructionTest.html#b09f0e02ab71b01af6eda0152d1fc975">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#9848bf36bd3ec75ae481d8ef1f36c6ee">CInstructionStore</a>
+, <a class="el" href="classCInstructionJumpZ.html#e4c05192b829d2bcc1e838de195ef3d9">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionDiv.html#349324231c5516886d99caf07ecb8c0c">CInstructionDiv</a>
+, <a class="el" href="classCInstructionMul.html#188024d90dd19fcea0687d32e98c67a7">CInstructionMul</a>
+, <a class="el" href="classCInstructionSub.html#9fe6d8f0f805313c98f8806a4739cbe9">CInstructionSub</a>
+, <a class="el" href="classCInstructionAdd.html#1da9f4b4016d27f2866add0b91e3b0fc">CInstructionAdd</a>
+, <a class="el" href="classCInstructionDec.html#84347e9b3a373bafc5c1ae79a557f4c3">CInstructionDec</a>
+, <a class="el" href="classCInstructionInc.html#ae36e952ec66b1c5cc2fb7e7c80064cc">CInstructionInc</a>
+, <a class="el" href="classCProgram.html#e75e8a7709afcebc7f1537db247f9671">CProgram</a>
+, <a class="el" href="classCInstruction.html#15e2ce88b04fcf208ba43c43f7dd57aa">CInstruction</a>
+, <a class="el" href="classCInstructionJumpA.html#f772a57214b192263594d2ff46f03a1e">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionJumpS.html#671d749a6e93f26851879c4ceac09f4c">CInstructionJumpS</a>
+, <a class="el" href="classCInstructionWrite.html#23f5bb8e4b8a74f7a8703d593323b991">CInstructionWrite</a>
+, <a class="el" href="classCInstructionLoad.html#4aa70fe481286e0bcc27f7a9ce896d3d">CInstructionLoad</a>
+, <a class="el" href="classCInstructionLabel.html#321fd849ae169d900964431b4100321f">CInstructionLabel</a>
+<li>CProgram()
+: <a class="el" href="classCProgram.html#74d3ca01d5e8b892f37684254ae546ed">CProgram</a>
+</ul>
+<h3><a class="anchor" name="index_d">- d -</a></h3><ul>
+<li>display()
+: <a class="el" href="classCDisplayT.html#5a15f96d3d76bdbb2b172c52036859c2">CDisplayT&lt; T &gt;</a>
+, <a class="el" href="classCDisplayWDEZ.html#91798e80f37ec86e3aa7d0f899e3a8dc">CDisplayWDEZ</a>
+, <a class="el" href="classCDisplayWHEX.html#6adaa6532cd684060029e31457d83752">CDisplayWHEX</a>
+<li>dump()
+: <a class="el" href="classCInstruction.html#040a2394e2161a65f37ef31d16bb6a35">CInstruction</a>
+</ul>
+<h3><a class="anchor" name="index_e">- e -</a></h3><ul>
+<li>execute()
+: <a class="el" href="classCInstruction.html#127fd09a772e9f584550cd342af770d1">CInstruction</a>
+, <a class="el" href="classCInstructionWrite.html#1852e50c21b758a4db205a6cd20e208d">CInstructionWrite</a>
+, <a class="el" href="classCInstructionJumpS.html#8c2e8e077463e64ca64204bb6ed20f71">CInstructionJumpS</a>
+, <a class="el" href="classCInstructionJumpZ.html#92f15deda156ebd20e8af47589753783">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionJumpA.html#76daeedb9c7cb3be0173580be9390887">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionLabel.html#665f2fc395ffed3bd968659f67868f53">CInstructionLabel</a>
+, <a class="el" href="classCInstructionTest.html#955cf58c41c9e305059baea28b65cf3a">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#fd5ee6692540613ee8cc9a2bf8ff920a">CInstructionStore</a>
+, <a class="el" href="classCInstructionLoad.html#fdda1d554401f9bfd32a6300f5ad2bb6">CInstructionLoad</a>
+, <a class="el" href="classCInstructionDiv.html#7fee4e02bc6904c9d6039aa467aed1f4">CInstructionDiv</a>
+, <a class="el" href="classCInstructionMul.html#0675f51cbfb5d0d76e605f64b0b2555c">CInstructionMul</a>
+, <a class="el" href="classCInstructionSub.html#03e098595198d4cc2f45d906e45e7f28">CInstructionSub</a>
+, <a class="el" href="classCInstructionAdd.html#3c6844fd425de436ba3e7fbc98fd69e8">CInstructionAdd</a>
+, <a class="el" href="classCInstructionDec.html#b0a51da3b41aaa4e3e51baaa4151ebca">CInstructionDec</a>
+, <a class="el" href="classCInstructionInc.html#2830b4c1aa89410e309821119ecf4d6f">CInstructionInc</a>
+</ul>
+<h3><a class="anchor" name="index_f">- f -</a></h3><ul>
+<li>factory()
+: <a class="el" href="classCInstruction.html#fae8dc231b375db91f874df0d085b7dc">CInstruction</a>
+, <a class="el" href="classCInstructionInc.html#d55c35cbbd5c88fd29a392051e79f5f1">CInstructionInc</a>
+, <a class="el" href="classCInstructionWrite.html#a33ddc8fb13dfaa253704eb0952f3cea">CInstructionWrite</a>
+, <a class="el" href="classCInstructionJumpS.html#4b25703a62dafb568700dcad217f7ba6">CInstructionJumpS</a>
+, <a class="el" href="classCInstructionJumpZ.html#e0750f1ce4a5746be3317024f4ef92eb">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionJumpA.html#d7679ea0d70ab9725f84dcce76adc057">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionLabel.html#66ba5bd6facecd45f3616fc94eb2845f">CInstructionLabel</a>
+, <a class="el" href="classCInstructionTest.html#9e4e1ac29b5173a70dc1172bbb096671">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#cab0d4c9bf2cc0d6b1b450ef9aeebcc0">CInstructionStore</a>
+, <a class="el" href="classCInstructionAdd.html#6fa9bae98f84f5ae34946641fb03ff32">CInstructionAdd</a>
+, <a class="el" href="classCInstructionDiv.html#3445767e66ab734ec88b6084a10c4446">CInstructionDiv</a>
+, <a class="el" href="classCInstructionMul.html#1e8f23073a29a0d50fa9d651b986e821">CInstructionMul</a>
+, <a class="el" href="classCInstructionSub.html#71c77a5113f96ac25e79bc4d28072541">CInstructionSub</a>
+, <a class="el" href="classCInstructionLoad.html#35c051515ccd6a12dbb39ab4b2e33ded">CInstructionLoad</a>
+, <a class="el" href="classCInstructionDec.html#5aa3bcd55f05765e25758f45f4f55059">CInstructionDec</a>
+<li>findLabel()
+: <a class="el" href="classCProgram.html#4c29c5c7932174242c50fd9d1c5bc1ec">CProgram</a>
+</ul>
+<h3><a class="anchor" name="index_g">- g -</a></h3><ul>
+<li>getDisplays()
+: <a class="el" href="classCCPU.html#aab308415ce3083eaa66b9aa1dcbb0c6">CCPU</a>
+<li>getFlagSign()
+: <a class="el" href="classCCPU.html#c3d7d2bf5f93aa2d7b6f5959b8448ea2">CCPU</a>
+<li>getFlagZero()
+: <a class="el" href="classCCPU.html#9398f58c5a715653c3502040029501a1">CCPU</a>
+<li>getLabels()
+: <a class="el" href="classCProgram.html#8d5dc184872d4616d327c87ffa665804">CProgram</a>
+<li>getMemory()
+: <a class="el" href="classCCPU.html#47e3302a8d9582b29a4d722735d8aa60">CCPU</a>
+<li>getName()
+: <a class="el" href="classCInstruction.html#e8187580097fd2ced5a8bc6e6e09fe44">CInstruction</a>
+, <a class="el" href="classCDisplayT.html#32897b9abaec6e9a0e73ae746ab5cec0">CDisplayT&lt; T &gt;</a>
+<li>getProgram()
+: <a class="el" href="classCCPU.html#f7c34c0ba7230ecc980a5ff7730cdbae">CCPU</a>
+<li>getRegisterCount()
+: <a class="el" href="classCCPU.html#b25ee10ea09dfe12d9e77e5eb2126d32">CCPU</a>
+<li>getRegisters()
+: <a class="el" href="classCCPU.html#efe3e22919627e5daf525d11b13d5c44">CCPU</a>
+<li>getValue()
+: <a class="el" href="classCDatT.html#8c226fb0b0974a0cbb7897d94f75e4e0">CDatT&lt; T &gt;</a>
+</ul>
+<h3><a class="anchor" name="index_i">- i -</a></h3><ul>
+<li>initialize()
+: <a class="el" href="classCVectorMem.html#d45b088f04cf2af4c6c91bd670c5f9e6">CVectorMem&lt; T, Allocator &gt;</a>
+</ul>
+<h3><a class="anchor" name="index_o">- o -</a></h3><ul>
+<li>operator &amp;=()
+: <a class="el" href="classCDatT.html#3ec7b2fac8d93e51cd87acda04d7f41e">CDatT&lt; T &gt;</a>
+<li>operator *=()
+: <a class="el" href="classCDatT.html#707446768fff0c8e9a56c4af874d0224">CDatT&lt; T &gt;</a>
+<li>operator T()
+: <a class="el" href="classCDatT.html#5915d4f7de6dceea7d0d7253ce8ff5c9">CDatT&lt; T &gt;</a>
+<li>operator%=()
+: <a class="el" href="classCDatT.html#403d947a670fcc25dc0ae4e00293cc33">CDatT&lt; T &gt;</a>
+<li>operator()()
+: <a class="el" href="classCInstruction.html#b5b2364b0cccc6db2f5c3aaccee8aa43">CInstruction</a>
+<li>operator++()
+: <a class="el" href="classCDatT.html#9a17a5e35049ad6a150ec800ddb81e64">CDatT&lt; T &gt;</a>
+<li>operator+=()
+: <a class="el" href="classCDatT.html#f4f1e37bd94b17229dd0e181fcf41860">CDatT&lt; T &gt;</a>
+<li>operator--()
+: <a class="el" href="classCDatT.html#ec2be360ce61195c92db1ba4d2db0d8b">CDatT&lt; T &gt;</a>
+<li>operator-=()
+: <a class="el" href="classCDatT.html#24cf91d1ac4e0277547ec158ed35544a">CDatT&lt; T &gt;</a>
+<li>operator/=()
+: <a class="el" href="classCDatT.html#c68e6cd45ae94ef7485650e72f07c49d">CDatT&lt; T &gt;</a>
+<li>operator&lt;()
+: <a class="el" href="classCDatT.html#acd2ef7a53a0c4b128485147171d0cbd">CDatT&lt; T &gt;</a>
+<li>operator==()
+: <a class="el" href="classCInstruction.html#395c9bde315efbc0eefd0bbb1586950a">CInstruction</a>
+, <a class="el" href="classCDatT.html#884afb7b0c4e972c25f12f6eff15177d">CDatT&lt; T &gt;</a>
+<li>operator^=()
+: <a class="el" href="classCDatT.html#03cf22edd6b2489e63be6cc846de789f">CDatT&lt; T &gt;</a>
+<li>operator|=()
+: <a class="el" href="classCDatT.html#f98140b24016e58307bf92b556157a13">CDatT&lt; T &gt;</a>
+</ul>
+<h3><a class="anchor" name="index_p">- p -</a></h3><ul>
+<li>parseRegister()
+: <a class="el" href="classCInstruction.html#2723f8875ff0cc4e48d840db1ae5b4a8">CInstruction</a>
+</ul>
+<h3><a class="anchor" name="index_r">- r -</a></h3><ul>
+<li>run()
+: <a class="el" href="classCCPU.html#045df5c772702bdc1454fb90d512fb68">CCPU</a>
+</ul>
+<h3><a class="anchor" name="index_s">- s -</a></h3><ul>
+<li>setFlagSign()
+: <a class="el" href="classCCPU.html#d8226c190477e2fbce0ddf7d814a272e">CCPU</a>
+<li>setFlagZero()
+: <a class="el" href="classCCPU.html#33c8a01cbafddb40cf9283109b3a0b08">CCPU</a>
+<li>setMemory()
+: <a class="el" href="classCCPU.html#bb2644a658cbfbcdd7c579a2840cee67">CCPU</a>
+<li>setProgram()
+: <a class="el" href="classCCPU.html#3790f6567091892f8867329424d03f71">CCPU</a>
+</ul>
+<h3><a class="anchor" name="index_~">- ~ -</a></h3><ul>
+<li>~CCPU()
+: <a class="el" href="classCCPU.html#7523a3b0b832774c3df57bd019273a68">CCPU</a>
+<li>~CDatT()
+: <a class="el" href="classCDatT.html#8ddaa1aaef85fea9e7c3613ccdc5a891">CDatT&lt; T &gt;</a>
+<li>~CDisplayT()
+: <a class="el" href="classCDisplayT.html#edeeab4320b2c3a5b482d216e73e5999">CDisplayT&lt; T &gt;</a>
+<li>~CInstruction()
+: <a class="el" href="classCInstruction.html#d2ded1d8675749bc39a085a8c50a6612">CInstruction</a>
+<li>~CProgram()
+: <a class="el" href="classCProgram.html#7dfeb30706e7af06114fdf18262d7926">CProgram</a>
+</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/functions_rela.html b/ue3/doxygen/functions_rela.html
new file mode 100644
index 0000000..d7d0fde
--- /dev/null
+++ b/ue3/doxygen/functions_rela.html
@@ -0,0 +1,44 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Class Members - Related Functions</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li class="current"><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="functions.html"><span>All</span></a></li>
+    <li><a href="functions_func.html"><span>Functions</span></a></li>
+    <li><a href="functions_vars.html"><span>Variables</span></a></li>
+    <li class="current"><a href="functions_rela.html"><span>Related&nbsp;Functions</span></a></li>
+  </ul>
+</div>
+&nbsp;
+<p>
+<ul>
+<li>operator&lt;&lt;
+: <a class="el" href="classCDatT.html#81465346cb4f31cf76336d46c512d0f6">CDatT&lt; T &gt;</a>
+, <a class="el" href="classCInstruction.html#7651b4c147411bca34a0393adf03507d">CInstruction</a>
+<li>operator&gt;&gt;
+: <a class="el" href="classCDatT.html#16f0666a0b7c3383eb965daf48134fab">CDatT&lt; T &gt;</a>
+</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/functions_vars.html b/ue3/doxygen/functions_vars.html
new file mode 100644
index 0000000..5b7e130
--- /dev/null
+++ b/ue3/doxygen/functions_vars.html
@@ -0,0 +1,71 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Class Members - Variables</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li class="current"><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="functions.html"><span>All</span></a></li>
+    <li><a href="functions_func.html"><span>Functions</span></a></li>
+    <li class="current"><a href="functions_vars.html"><span>Variables</span></a></li>
+    <li><a href="functions_rela.html"><span>Related&nbsp;Functions</span></a></li>
+  </ul>
+</div>
+&nbsp;
+<p>
+<ul>
+<li>m_addr
+: <a class="el" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">CInstructionJumpA</a>
+, <a class="el" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">CInstructionJumpZ</a>
+, <a class="el" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">CInstructionJumpS</a>
+<li>m_dev
+: <a class="el" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">CInstructionWrite</a>
+<li>m_name
+: <a class="el" href="classCDisplayT.html#ba8ab4d4abe2426b266660134efb370f">CDisplayT&lt; T &gt;</a>
+, <a class="el" href="classCInstruction.html#0c3b94ae1323d6201d2afd20c8686194">CInstruction</a>
+<li>m_regidx1
+: <a class="el" href="classCInstructionDec.html#4ea09ae25025e93c2790d5dc1536f41c">CInstructionDec</a>
+, <a class="el" href="classCInstructionWrite.html#7af118a6f35320bbbee55051188311d6">CInstructionWrite</a>
+, <a class="el" href="classCInstructionAdd.html#2808878fbfbee48f1c300bdd976446f4">CInstructionAdd</a>
+, <a class="el" href="classCInstructionSub.html#f9884524cd60c34f3d9a5142e1e586fb">CInstructionSub</a>
+, <a class="el" href="classCInstructionMul.html#c5c3b5b125973a0396c3ad7e0233b79f">CInstructionMul</a>
+, <a class="el" href="classCInstructionDiv.html#356508c5c90a345bdd0055385227852f">CInstructionDiv</a>
+, <a class="el" href="classCInstructionTest.html#26744f0f306f4a181936fc6e389eb9e3">CInstructionTest</a>
+, <a class="el" href="classCInstructionStore.html#5e57d0d27d70f13a590355f5c1782cc9">CInstructionStore</a>
+, <a class="el" href="classCInstructionLoad.html#91139a066176d4be83258eba0b412cb6">CInstructionLoad</a>
+, <a class="el" href="classCInstructionInc.html#b910df5b37f4d1352736913ee0cb7fb0">CInstructionInc</a>
+<li>m_regidx2
+: <a class="el" href="classCInstructionMul.html#eaaaff76fe29741fce14b322d4da8a54">CInstructionMul</a>
+, <a class="el" href="classCInstructionDiv.html#5a9c4be1386df1fa866927336abe3054">CInstructionDiv</a>
+, <a class="el" href="classCInstructionAdd.html#98e9005e15d5eb69ce561a91348a3a91">CInstructionAdd</a>
+, <a class="el" href="classCInstructionLoad.html#dbb1c5a56e063ce77d3b8d26355e2a49">CInstructionLoad</a>
+, <a class="el" href="classCInstructionSub.html#67030fafc6429936130bbe26874c337c">CInstructionSub</a>
+, <a class="el" href="classCInstructionStore.html#d960c6b85e7022704b4d7d059e1766d1">CInstructionStore</a>
+<li>m_regidx3
+: <a class="el" href="classCInstructionSub.html#a059bfa11944c55216619bb4328ed44e">CInstructionSub</a>
+, <a class="el" href="classCInstructionAdd.html#1c5979587fea23262a9bc593b9dc61a3">CInstructionAdd</a>
+, <a class="el" href="classCInstructionMul.html#171d8573f80224249ac14e4c8fec0c7b">CInstructionMul</a>
+, <a class="el" href="classCInstructionDiv.html#3e7033bb26ef68b051b0da8a8279df85">CInstructionDiv</a>
+</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/hierarchy.html b/ue3/doxygen/hierarchy.html
new file mode 100644
index 0000000..2fd63a5
--- /dev/null
+++ b/ue3/doxygen/hierarchy.html
@@ -0,0 +1,58 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Hierarchical Index</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<div class="tabs">
+  <ul>
+    <li><a href="annotated.html"><span>Class&nbsp;List</span></a></li>
+    <li class="current"><a href="hierarchy.html"><span>Class&nbsp;Hierarchy</span></a></li>
+    <li><a href="functions.html"><span>Class&nbsp;Members</span></a></li>
+  </ul>
+</div>
+<h1>mycpu Class Hierarchy</h1>This inheritance list is sorted roughly, but not completely, alphabetically:<ul>
+<li><a class="el" href="classCCPU.html">CCPU</a>
+<li><a class="el" href="classCDat.html">CDat</a>
+<li><a class="el" href="classCDatT.html">CDatT&lt; T &gt;</a>
+<li><a class="el" href="classCDisplay.html">CDisplay</a>
+<ul>
+<li><a class="el" href="classCDisplayWDEZ.html">CDisplayWDEZ</a>
+<li><a class="el" href="classCDisplayWHEX.html">CDisplayWHEX</a>
+</ul>
+<li><a class="el" href="classCDisplayT.html">CDisplayT&lt; T &gt;</a>
+<li><a class="el" href="classCInstruction.html">CInstruction</a>
+<ul>
+<li><a class="el" href="classCInstructionAdd.html">CInstructionAdd</a>
+<li><a class="el" href="classCInstructionDec.html">CInstructionDec</a>
+<li><a class="el" href="classCInstructionDiv.html">CInstructionDiv</a>
+<li><a class="el" href="classCInstructionInc.html">CInstructionInc</a>
+<li><a class="el" href="classCInstructionJumpA.html">CInstructionJumpA</a>
+<li><a class="el" href="classCInstructionJumpS.html">CInstructionJumpS</a>
+<li><a class="el" href="classCInstructionJumpZ.html">CInstructionJumpZ</a>
+<li><a class="el" href="classCInstructionLabel.html">CInstructionLabel</a>
+<li><a class="el" href="classCInstructionLoad.html">CInstructionLoad</a>
+<li><a class="el" href="classCInstructionMul.html">CInstructionMul</a>
+<li><a class="el" href="classCInstructionStore.html">CInstructionStore</a>
+<li><a class="el" href="classCInstructionSub.html">CInstructionSub</a>
+<li><a class="el" href="classCInstructionTest.html">CInstructionTest</a>
+<li><a class="el" href="classCInstructionWrite.html">CInstructionWrite</a>
+</ul>
+<li><a class="el" href="classCMem.html">CMem</a>
+<li><a class="el" href="classCProgram.html">CProgram</a>
+<li><a class="el" href="classCVectorMem.html">CVectorMem&lt; T, Allocator &gt;</a>
+</ul>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/index.html b/ue3/doxygen/index.html
new file mode 100644
index 0000000..502a5e9
--- /dev/null
+++ b/ue3/doxygen/index.html
@@ -0,0 +1,22 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Main Page</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li class="current"><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu Documentation</h1>
+<p>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/instructions_8h-source.html b/ue3/doxygen/instructions_8h-source.html
new file mode 100644
index 0000000..7054830
--- /dev/null
+++ b/ue3/doxygen/instructions_8h-source.html
@@ -0,0 +1,347 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: mycpu/instructions.h Source File</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li class="current"><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu/instructions.h</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 
+<a name="l00008"></a>00008 <span class="preprocessor">#ifndef INSTRUCTIONS_H</span>
+<a name="l00009"></a>00009 <span class="preprocessor"></span><span class="preprocessor">#define INSTRUCTIONS_H 1</span>
+<a name="l00010"></a>00010 <span class="preprocessor"></span>
+<a name="l00011"></a>00011 <span class="preprocessor">#include "cinstruction.h"</span>
+<a name="l00012"></a>00012 <span class="preprocessor">#include "ccpu.h"</span>
+<a name="l00013"></a>00013 
+<a name="l00021"></a><a class="code" href="classCInstructionInc.html">00021</a> <span class="keyword">class </span><a class="code" href="classCInstructionInc.html">CInstructionInc</a>
+<a name="l00022"></a>00022  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00023"></a>00023 {
+<a name="l00024"></a>00024   <span class="keyword">public</span>:
+<a name="l00025"></a>00025     <a class="code" href="classCInstructionInc.html">CInstructionInc</a>()
+<a name="l00026"></a>00026       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"inc"</span>)
+<a name="l00027"></a>00027     {}
+<a name="l00028"></a>00028 
+<a name="l00029"></a><a class="code" href="classCInstructionInc.html#d55c35cbbd5c88fd29a392051e79f5f1">00029</a>     <a class="code" href="classCInstructionInc.html">CInstructionInc</a> *<a class="code" href="classCInstructionInc.html#d55c35cbbd5c88fd29a392051e79f5f1" title="creates a new instance of this instruction">factory</a>()
+<a name="l00030"></a>00030     {
+<a name="l00031"></a>00031       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionInc.html">CInstructionInc</a>;
+<a name="l00032"></a>00032     }
+<a name="l00033"></a>00033 
+<a name="l00034"></a>00034     <span class="keywordtype">void</span> <a class="code" href="classCInstructionInc.html#ae36e952ec66b1c5cc2fb7e7c80064cc" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00035"></a>00035     <span class="keywordtype">void</span> <a class="code" href="classCInstructionInc.html#2830b4c1aa89410e309821119ecf4d6f" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00036"></a>00036 
+<a name="l00037"></a>00037   <span class="keyword">protected</span>:
+<a name="l00039"></a><a class="code" href="classCInstructionInc.html#b910df5b37f4d1352736913ee0cb7fb0">00039</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionInc.html#b910df5b37f4d1352736913ee0cb7fb0">m_regidx1</a>;
+<a name="l00040"></a>00040 };
+<a name="l00041"></a>00041 
+<a name="l00042"></a>00042 <span class="comment">/*============================================================================*/</span>
+<a name="l00043"></a>00043 
+<a name="l00051"></a><a class="code" href="classCInstructionDec.html">00051</a> <span class="keyword">class </span><a class="code" href="classCInstructionDec.html">CInstructionDec</a>
+<a name="l00052"></a>00052  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00053"></a>00053 {
+<a name="l00054"></a>00054   <span class="keyword">public</span>:
+<a name="l00055"></a>00055     <a class="code" href="classCInstructionDec.html">CInstructionDec</a>()
+<a name="l00056"></a>00056       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"dec"</span>)
+<a name="l00057"></a>00057     {}
+<a name="l00058"></a>00058 
+<a name="l00059"></a><a class="code" href="classCInstructionDec.html#5aa3bcd55f05765e25758f45f4f55059">00059</a>     <a class="code" href="classCInstructionDec.html">CInstructionDec</a> *<a class="code" href="classCInstructionDec.html#5aa3bcd55f05765e25758f45f4f55059" title="creates a new instance of this instruction">factory</a>()
+<a name="l00060"></a>00060     {
+<a name="l00061"></a>00061       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionDec.html">CInstructionDec</a>;
+<a name="l00062"></a>00062     }
+<a name="l00063"></a>00063 
+<a name="l00064"></a>00064     <span class="keywordtype">void</span> <a class="code" href="classCInstructionDec.html#84347e9b3a373bafc5c1ae79a557f4c3" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00065"></a>00065     <span class="keywordtype">void</span> <a class="code" href="classCInstructionDec.html#b0a51da3b41aaa4e3e51baaa4151ebca" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00066"></a>00066 
+<a name="l00067"></a>00067   <span class="keyword">protected</span>:
+<a name="l00069"></a><a class="code" href="classCInstructionDec.html#4ea09ae25025e93c2790d5dc1536f41c">00069</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionDec.html#4ea09ae25025e93c2790d5dc1536f41c">m_regidx1</a>;
+<a name="l00070"></a>00070 };
+<a name="l00071"></a>00071 
+<a name="l00072"></a>00072 <span class="comment">/*============================================================================*/</span>
+<a name="l00073"></a>00073 
+<a name="l00081"></a><a class="code" href="classCInstructionAdd.html">00081</a> <span class="keyword">class </span><a class="code" href="classCInstructionAdd.html">CInstructionAdd</a>
+<a name="l00082"></a>00082  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00083"></a>00083 {
+<a name="l00084"></a>00084   <span class="keyword">public</span>:
+<a name="l00085"></a>00085     <a class="code" href="classCInstructionAdd.html">CInstructionAdd</a>()
+<a name="l00086"></a>00086       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"add"</span>)
+<a name="l00087"></a>00087     {}
+<a name="l00088"></a>00088 
+<a name="l00089"></a><a class="code" href="classCInstructionAdd.html#6fa9bae98f84f5ae34946641fb03ff32">00089</a>     <a class="code" href="classCInstructionAdd.html">CInstructionAdd</a> *<a class="code" href="classCInstructionAdd.html#6fa9bae98f84f5ae34946641fb03ff32" title="creates a new instance of this instruction">factory</a>()
+<a name="l00090"></a>00090     {
+<a name="l00091"></a>00091       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionAdd.html">CInstructionAdd</a>;
+<a name="l00092"></a>00092     }
+<a name="l00093"></a>00093 
+<a name="l00094"></a>00094     <span class="keywordtype">void</span> <a class="code" href="classCInstructionAdd.html#1da9f4b4016d27f2866add0b91e3b0fc" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00095"></a>00095     <span class="keywordtype">void</span> <a class="code" href="classCInstructionAdd.html#3c6844fd425de436ba3e7fbc98fd69e8" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00096"></a>00096 
+<a name="l00097"></a>00097   <span class="keyword">protected</span>:
+<a name="l00099"></a><a class="code" href="classCInstructionAdd.html#2808878fbfbee48f1c300bdd976446f4">00099</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionAdd.html#2808878fbfbee48f1c300bdd976446f4">m_regidx1</a>;
+<a name="l00101"></a><a class="code" href="classCInstructionAdd.html#98e9005e15d5eb69ce561a91348a3a91">00101</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionAdd.html#98e9005e15d5eb69ce561a91348a3a91">m_regidx2</a>;
+<a name="l00103"></a><a class="code" href="classCInstructionAdd.html#1c5979587fea23262a9bc593b9dc61a3">00103</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionAdd.html#1c5979587fea23262a9bc593b9dc61a3">m_regidx3</a>;
+<a name="l00104"></a>00104 };
+<a name="l00105"></a>00105 
+<a name="l00106"></a>00106 <span class="comment">/*============================================================================*/</span>
+<a name="l00107"></a>00107 
+<a name="l00115"></a><a class="code" href="classCInstructionSub.html">00115</a> <span class="keyword">class </span><a class="code" href="classCInstructionSub.html">CInstructionSub</a>
+<a name="l00116"></a>00116  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00117"></a>00117 {
+<a name="l00118"></a>00118   <span class="keyword">public</span>:
+<a name="l00119"></a>00119     <a class="code" href="classCInstructionSub.html">CInstructionSub</a>()
+<a name="l00120"></a>00120       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"sub"</span>)
+<a name="l00121"></a>00121     {}
+<a name="l00122"></a>00122 
+<a name="l00123"></a><a class="code" href="classCInstructionSub.html#71c77a5113f96ac25e79bc4d28072541">00123</a>     <a class="code" href="classCInstructionSub.html">CInstructionSub</a> *<a class="code" href="classCInstructionSub.html#71c77a5113f96ac25e79bc4d28072541" title="creates a new instance of this instruction">factory</a>()
+<a name="l00124"></a>00124     {
+<a name="l00125"></a>00125       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionSub.html">CInstructionSub</a>;
+<a name="l00126"></a>00126     }
+<a name="l00127"></a>00127 
+<a name="l00128"></a>00128     <span class="keywordtype">void</span> <a class="code" href="classCInstructionSub.html#9fe6d8f0f805313c98f8806a4739cbe9" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00129"></a>00129     <span class="keywordtype">void</span> <a class="code" href="classCInstructionSub.html#03e098595198d4cc2f45d906e45e7f28" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00130"></a>00130 
+<a name="l00131"></a>00131   <span class="keyword">protected</span>:
+<a name="l00133"></a><a class="code" href="classCInstructionSub.html#f9884524cd60c34f3d9a5142e1e586fb">00133</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionSub.html#f9884524cd60c34f3d9a5142e1e586fb">m_regidx1</a>;
+<a name="l00135"></a><a class="code" href="classCInstructionSub.html#67030fafc6429936130bbe26874c337c">00135</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionSub.html#67030fafc6429936130bbe26874c337c">m_regidx2</a>;
+<a name="l00137"></a><a class="code" href="classCInstructionSub.html#a059bfa11944c55216619bb4328ed44e">00137</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionSub.html#a059bfa11944c55216619bb4328ed44e">m_regidx3</a>;
+<a name="l00138"></a>00138 };
+<a name="l00139"></a>00139 
+<a name="l00140"></a>00140 <span class="comment">/*============================================================================*/</span>
+<a name="l00141"></a>00141 
+<a name="l00149"></a><a class="code" href="classCInstructionMul.html">00149</a> <span class="keyword">class </span><a class="code" href="classCInstructionMul.html">CInstructionMul</a>
+<a name="l00150"></a>00150  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00151"></a>00151 {
+<a name="l00152"></a>00152   <span class="keyword">public</span>:
+<a name="l00153"></a>00153     <a class="code" href="classCInstructionMul.html">CInstructionMul</a>()
+<a name="l00154"></a>00154       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"mul"</span>)
+<a name="l00155"></a>00155     {}
+<a name="l00156"></a>00156 
+<a name="l00157"></a><a class="code" href="classCInstructionMul.html#1e8f23073a29a0d50fa9d651b986e821">00157</a>     <a class="code" href="classCInstructionMul.html">CInstructionMul</a> *<a class="code" href="classCInstructionMul.html#1e8f23073a29a0d50fa9d651b986e821" title="creates a new instance of this instruction">factory</a>()
+<a name="l00158"></a>00158     {
+<a name="l00159"></a>00159       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionMul.html">CInstructionMul</a>;
+<a name="l00160"></a>00160     }
+<a name="l00161"></a>00161 
+<a name="l00162"></a>00162     <span class="keywordtype">void</span> <a class="code" href="classCInstructionMul.html#188024d90dd19fcea0687d32e98c67a7" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00163"></a>00163     <span class="keywordtype">void</span> <a class="code" href="classCInstructionMul.html#0675f51cbfb5d0d76e605f64b0b2555c" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00164"></a>00164 
+<a name="l00165"></a>00165   <span class="keyword">protected</span>:
+<a name="l00167"></a><a class="code" href="classCInstructionMul.html#c5c3b5b125973a0396c3ad7e0233b79f">00167</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionMul.html#c5c3b5b125973a0396c3ad7e0233b79f">m_regidx1</a>;
+<a name="l00169"></a><a class="code" href="classCInstructionMul.html#eaaaff76fe29741fce14b322d4da8a54">00169</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionMul.html#eaaaff76fe29741fce14b322d4da8a54">m_regidx2</a>;
+<a name="l00171"></a><a class="code" href="classCInstructionMul.html#171d8573f80224249ac14e4c8fec0c7b">00171</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionMul.html#171d8573f80224249ac14e4c8fec0c7b">m_regidx3</a>;
+<a name="l00172"></a>00172 };
+<a name="l00173"></a>00173 
+<a name="l00174"></a>00174 <span class="comment">/*============================================================================*/</span>
+<a name="l00175"></a>00175 
+<a name="l00183"></a><a class="code" href="classCInstructionDiv.html">00183</a> <span class="keyword">class </span><a class="code" href="classCInstructionDiv.html">CInstructionDiv</a>
+<a name="l00184"></a>00184  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00185"></a>00185 {
+<a name="l00186"></a>00186   <span class="keyword">public</span>:
+<a name="l00187"></a>00187     <a class="code" href="classCInstructionDiv.html">CInstructionDiv</a>()
+<a name="l00188"></a>00188       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"div"</span>)
+<a name="l00189"></a>00189     {}
+<a name="l00190"></a>00190 
+<a name="l00191"></a><a class="code" href="classCInstructionDiv.html#3445767e66ab734ec88b6084a10c4446">00191</a>     <a class="code" href="classCInstructionDiv.html">CInstructionDiv</a> *<a class="code" href="classCInstructionDiv.html#3445767e66ab734ec88b6084a10c4446" title="creates a new instance of this instruction">factory</a>()
+<a name="l00192"></a>00192     {
+<a name="l00193"></a>00193       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionDiv.html">CInstructionDiv</a>;
+<a name="l00194"></a>00194     }
+<a name="l00195"></a>00195 
+<a name="l00196"></a>00196     <span class="keywordtype">void</span> <a class="code" href="classCInstructionDiv.html#349324231c5516886d99caf07ecb8c0c" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00197"></a>00197     <span class="keywordtype">void</span> <a class="code" href="classCInstructionDiv.html#7fee4e02bc6904c9d6039aa467aed1f4" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00198"></a>00198 
+<a name="l00199"></a>00199   <span class="keyword">protected</span>:
+<a name="l00201"></a><a class="code" href="classCInstructionDiv.html#356508c5c90a345bdd0055385227852f">00201</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionDiv.html#356508c5c90a345bdd0055385227852f">m_regidx1</a>;
+<a name="l00203"></a><a class="code" href="classCInstructionDiv.html#5a9c4be1386df1fa866927336abe3054">00203</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionDiv.html#5a9c4be1386df1fa866927336abe3054">m_regidx2</a>;
+<a name="l00205"></a><a class="code" href="classCInstructionDiv.html#3e7033bb26ef68b051b0da8a8279df85">00205</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionDiv.html#3e7033bb26ef68b051b0da8a8279df85">m_regidx3</a>;
+<a name="l00206"></a>00206 };
+<a name="l00207"></a>00207 
+<a name="l00208"></a>00208 <span class="comment">/*============================================================================*/</span>
+<a name="l00209"></a>00209 
+<a name="l00217"></a><a class="code" href="classCInstructionLoad.html">00217</a> <span class="keyword">class </span><a class="code" href="classCInstructionLoad.html">CInstructionLoad</a>
+<a name="l00218"></a>00218  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00219"></a>00219 {
+<a name="l00220"></a>00220   <span class="keyword">public</span>:
+<a name="l00221"></a>00221     <a class="code" href="classCInstructionLoad.html">CInstructionLoad</a>()
+<a name="l00222"></a>00222       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"load"</span>)
+<a name="l00223"></a>00223     {}
+<a name="l00224"></a>00224 
+<a name="l00225"></a><a class="code" href="classCInstructionLoad.html#35c051515ccd6a12dbb39ab4b2e33ded">00225</a>     <a class="code" href="classCInstructionLoad.html">CInstructionLoad</a> *<a class="code" href="classCInstructionLoad.html#35c051515ccd6a12dbb39ab4b2e33ded" title="creates a new instance of this instruction">factory</a>()
+<a name="l00226"></a>00226     {
+<a name="l00227"></a>00227       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionLoad.html">CInstructionLoad</a>;
+<a name="l00228"></a>00228     }
+<a name="l00229"></a>00229 
+<a name="l00230"></a>00230     <span class="keywordtype">void</span> <a class="code" href="classCInstructionLoad.html#4aa70fe481286e0bcc27f7a9ce896d3d" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00231"></a>00231     <span class="keywordtype">void</span> <a class="code" href="classCInstructionLoad.html#fdda1d554401f9bfd32a6300f5ad2bb6" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00232"></a>00232 
+<a name="l00233"></a>00233   <span class="keyword">protected</span>:
+<a name="l00235"></a><a class="code" href="classCInstructionLoad.html#91139a066176d4be83258eba0b412cb6">00235</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionLoad.html#91139a066176d4be83258eba0b412cb6">m_regidx1</a>;
+<a name="l00237"></a><a class="code" href="classCInstructionLoad.html#dbb1c5a56e063ce77d3b8d26355e2a49">00237</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionLoad.html#dbb1c5a56e063ce77d3b8d26355e2a49">m_regidx2</a>;
+<a name="l00238"></a>00238 };
+<a name="l00239"></a>00239 
+<a name="l00240"></a>00240 <span class="comment">/*============================================================================*/</span>
+<a name="l00241"></a>00241 
+<a name="l00249"></a><a class="code" href="classCInstructionStore.html">00249</a> <span class="keyword">class </span><a class="code" href="classCInstructionStore.html">CInstructionStore</a>
+<a name="l00250"></a>00250  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00251"></a>00251 {
+<a name="l00252"></a>00252   <span class="keyword">public</span>:
+<a name="l00253"></a>00253     <a class="code" href="classCInstructionStore.html">CInstructionStore</a>()
+<a name="l00254"></a>00254       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"store"</span>)
+<a name="l00255"></a>00255     {}
+<a name="l00256"></a>00256 
+<a name="l00257"></a><a class="code" href="classCInstructionStore.html#cab0d4c9bf2cc0d6b1b450ef9aeebcc0">00257</a>     <a class="code" href="classCInstructionStore.html">CInstructionStore</a> *<a class="code" href="classCInstructionStore.html#cab0d4c9bf2cc0d6b1b450ef9aeebcc0" title="creates a new instance of this instruction">factory</a>()
+<a name="l00258"></a>00258     {
+<a name="l00259"></a>00259       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionStore.html">CInstructionStore</a>;
+<a name="l00260"></a>00260     }
+<a name="l00261"></a>00261 
+<a name="l00262"></a>00262     <span class="keywordtype">void</span> <a class="code" href="classCInstructionStore.html#9848bf36bd3ec75ae481d8ef1f36c6ee" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00263"></a>00263     <span class="keywordtype">void</span> <a class="code" href="classCInstructionStore.html#fd5ee6692540613ee8cc9a2bf8ff920a" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00264"></a>00264 
+<a name="l00265"></a>00265   <span class="keyword">protected</span>:
+<a name="l00267"></a><a class="code" href="classCInstructionStore.html#5e57d0d27d70f13a590355f5c1782cc9">00267</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionStore.html#5e57d0d27d70f13a590355f5c1782cc9">m_regidx1</a>;
+<a name="l00269"></a><a class="code" href="classCInstructionStore.html#d960c6b85e7022704b4d7d059e1766d1">00269</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionStore.html#d960c6b85e7022704b4d7d059e1766d1">m_regidx2</a>;
+<a name="l00270"></a>00270 };
+<a name="l00271"></a>00271 
+<a name="l00272"></a>00272 <span class="comment">/*============================================================================*/</span>
+<a name="l00273"></a>00273 
+<a name="l00281"></a><a class="code" href="classCInstructionTest.html">00281</a> <span class="keyword">class </span><a class="code" href="classCInstructionTest.html">CInstructionTest</a>
+<a name="l00282"></a>00282  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00283"></a>00283 {
+<a name="l00284"></a>00284   <span class="keyword">public</span>:
+<a name="l00285"></a>00285     <a class="code" href="classCInstructionTest.html">CInstructionTest</a>()
+<a name="l00286"></a>00286       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"test"</span>)
+<a name="l00287"></a>00287     {}
+<a name="l00288"></a>00288 
+<a name="l00289"></a><a class="code" href="classCInstructionTest.html#9e4e1ac29b5173a70dc1172bbb096671">00289</a>     <a class="code" href="classCInstructionTest.html">CInstructionTest</a> *<a class="code" href="classCInstructionTest.html#9e4e1ac29b5173a70dc1172bbb096671" title="creates a new instance of this instruction">factory</a>()
+<a name="l00290"></a>00290     {
+<a name="l00291"></a>00291       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionTest.html">CInstructionTest</a>;
+<a name="l00292"></a>00292     }
+<a name="l00293"></a>00293 
+<a name="l00294"></a>00294     <span class="keywordtype">void</span> <a class="code" href="classCInstructionTest.html#b09f0e02ab71b01af6eda0152d1fc975" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00295"></a>00295     <span class="keywordtype">void</span> <a class="code" href="classCInstructionTest.html#955cf58c41c9e305059baea28b65cf3a" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00296"></a>00296 
+<a name="l00297"></a>00297   <span class="keyword">protected</span>:
+<a name="l00299"></a><a class="code" href="classCInstructionTest.html#26744f0f306f4a181936fc6e389eb9e3">00299</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionTest.html#26744f0f306f4a181936fc6e389eb9e3">m_regidx1</a>;
+<a name="l00300"></a>00300 };
+<a name="l00301"></a>00301 
+<a name="l00302"></a>00302 <span class="comment">/*============================================================================*/</span>
+<a name="l00303"></a>00303 
+<a name="l00310"></a><a class="code" href="classCInstructionLabel.html">00310</a> <span class="keyword">class </span><a class="code" href="classCInstructionLabel.html">CInstructionLabel</a>
+<a name="l00311"></a>00311  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00312"></a>00312 {
+<a name="l00313"></a>00313   <span class="keyword">public</span>:
+<a name="l00314"></a>00314     <a class="code" href="classCInstructionLabel.html">CInstructionLabel</a>()
+<a name="l00315"></a>00315       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"label"</span>)
+<a name="l00316"></a>00316     {}
+<a name="l00317"></a>00317 
+<a name="l00318"></a><a class="code" href="classCInstructionLabel.html#66ba5bd6facecd45f3616fc94eb2845f">00318</a>     <a class="code" href="classCInstructionLabel.html">CInstructionLabel</a> *<a class="code" href="classCInstructionLabel.html#66ba5bd6facecd45f3616fc94eb2845f" title="creates a new instance of this instruction">factory</a>()
+<a name="l00319"></a>00319     {
+<a name="l00320"></a>00320       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionLabel.html">CInstructionLabel</a>;
+<a name="l00321"></a>00321     }
+<a name="l00322"></a>00322 
+<a name="l00323"></a><a class="code" href="classCInstructionLabel.html#321fd849ae169d900964431b4100321f">00323</a>     <span class="keywordtype">void</span> <a class="code" href="classCInstructionLabel.html#321fd849ae169d900964431b4100321f" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params)
+<a name="l00324"></a>00324     {}
+<a name="l00325"></a>00325 
+<a name="l00326"></a><a class="code" href="classCInstructionLabel.html#665f2fc395ffed3bd968659f67868f53">00326</a>     <span class="keywordtype">void</span> <a class="code" href="classCInstructionLabel.html#665f2fc395ffed3bd968659f67868f53" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu)
+<a name="l00327"></a>00327     {}
+<a name="l00328"></a>00328 };
+<a name="l00329"></a>00329 
+<a name="l00330"></a>00330 <span class="comment">/*============================================================================*/</span>
+<a name="l00331"></a>00331 
+<a name="l00339"></a><a class="code" href="classCInstructionJumpA.html">00339</a> <span class="keyword">class </span><a class="code" href="classCInstructionJumpA.html">CInstructionJumpA</a>
+<a name="l00340"></a>00340  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00341"></a>00341 {
+<a name="l00342"></a>00342   <span class="keyword">public</span>:
+<a name="l00343"></a>00343     <a class="code" href="classCInstructionJumpA.html">CInstructionJumpA</a>()
+<a name="l00344"></a>00344       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"jumpa"</span>), <a class="code" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">m_addr</a>(<span class="stringliteral">""</span>)
+<a name="l00345"></a>00345     {}
+<a name="l00346"></a>00346 
+<a name="l00347"></a><a class="code" href="classCInstructionJumpA.html#d7679ea0d70ab9725f84dcce76adc057">00347</a>     <a class="code" href="classCInstructionJumpA.html">CInstructionJumpA</a> *<a class="code" href="classCInstructionJumpA.html#d7679ea0d70ab9725f84dcce76adc057" title="creates a new instance of this instruction">factory</a>()
+<a name="l00348"></a>00348     {
+<a name="l00349"></a>00349       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionJumpA.html">CInstructionJumpA</a>;
+<a name="l00350"></a>00350     }
+<a name="l00351"></a>00351 
+<a name="l00352"></a>00352     <span class="keywordtype">void</span> <a class="code" href="classCInstructionJumpA.html#f772a57214b192263594d2ff46f03a1e" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00353"></a>00353     <span class="keywordtype">void</span> <a class="code" href="classCInstructionJumpA.html#76daeedb9c7cb3be0173580be9390887" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00354"></a>00354 
+<a name="l00355"></a>00355   <span class="keyword">protected</span>:
+<a name="l00357"></a><a class="code" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">00357</a>     std::string <a class="code" href="classCInstructionJumpA.html#ee10410094e2b3781da3cb53c390fb9e">m_addr</a>;
+<a name="l00358"></a>00358 };
+<a name="l00359"></a>00359 
+<a name="l00360"></a>00360 <span class="comment">/*============================================================================*/</span>
+<a name="l00361"></a>00361 
+<a name="l00369"></a><a class="code" href="classCInstructionJumpZ.html">00369</a> <span class="keyword">class </span><a class="code" href="classCInstructionJumpZ.html">CInstructionJumpZ</a>
+<a name="l00370"></a>00370  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00371"></a>00371 {
+<a name="l00372"></a>00372   <span class="keyword">public</span>:
+<a name="l00373"></a>00373     <a class="code" href="classCInstructionJumpZ.html">CInstructionJumpZ</a>()
+<a name="l00374"></a>00374       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"jumpz"</span>), <a class="code" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">m_addr</a>(<span class="stringliteral">""</span>)
+<a name="l00375"></a>00375     {}
+<a name="l00376"></a>00376 
+<a name="l00377"></a><a class="code" href="classCInstructionJumpZ.html#e0750f1ce4a5746be3317024f4ef92eb">00377</a>     <a class="code" href="classCInstructionJumpZ.html">CInstructionJumpZ</a> *<a class="code" href="classCInstructionJumpZ.html#e0750f1ce4a5746be3317024f4ef92eb" title="creates a new instance of this instruction">factory</a>()
+<a name="l00378"></a>00378     {
+<a name="l00379"></a>00379       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionJumpZ.html">CInstructionJumpZ</a>;
+<a name="l00380"></a>00380     }
+<a name="l00381"></a>00381 
+<a name="l00382"></a>00382     <span class="keywordtype">void</span> <a class="code" href="classCInstructionJumpZ.html#e4c05192b829d2bcc1e838de195ef3d9" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00383"></a>00383     <span class="keywordtype">void</span> <a class="code" href="classCInstructionJumpZ.html#92f15deda156ebd20e8af47589753783" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00384"></a>00384 
+<a name="l00385"></a>00385   <span class="keyword">protected</span>:
+<a name="l00387"></a><a class="code" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">00387</a>     std::string <a class="code" href="classCInstructionJumpZ.html#4f0147cd62010e0d178c9259737e8c10">m_addr</a>;
+<a name="l00388"></a>00388 };
+<a name="l00389"></a>00389 
+<a name="l00390"></a>00390 <span class="comment">/*============================================================================*/</span>
+<a name="l00391"></a>00391 
+<a name="l00399"></a><a class="code" href="classCInstructionJumpS.html">00399</a> <span class="keyword">class </span><a class="code" href="classCInstructionJumpS.html">CInstructionJumpS</a>
+<a name="l00400"></a>00400  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00401"></a>00401 {
+<a name="l00402"></a>00402   <span class="keyword">public</span>:
+<a name="l00403"></a>00403     <a class="code" href="classCInstructionJumpS.html">CInstructionJumpS</a>()
+<a name="l00404"></a>00404       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"jumps"</span>), <a class="code" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">m_addr</a>(<span class="stringliteral">""</span>)
+<a name="l00405"></a>00405     {}
+<a name="l00406"></a>00406 
+<a name="l00407"></a><a class="code" href="classCInstructionJumpS.html#4b25703a62dafb568700dcad217f7ba6">00407</a>     <a class="code" href="classCInstructionJumpS.html">CInstructionJumpS</a> *<a class="code" href="classCInstructionJumpS.html#4b25703a62dafb568700dcad217f7ba6" title="creates a new instance of this instruction">factory</a>()
+<a name="l00408"></a>00408     {
+<a name="l00409"></a>00409       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionJumpS.html">CInstructionJumpS</a>;
+<a name="l00410"></a>00410     }
+<a name="l00411"></a>00411 
+<a name="l00412"></a>00412     <span class="keywordtype">void</span> <a class="code" href="classCInstructionJumpS.html#671d749a6e93f26851879c4ceac09f4c" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00413"></a>00413     <span class="keywordtype">void</span> <a class="code" href="classCInstructionJumpS.html#8c2e8e077463e64ca64204bb6ed20f71" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00414"></a>00414 
+<a name="l00415"></a>00415   <span class="keyword">protected</span>:
+<a name="l00417"></a><a class="code" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">00417</a>     std::string <a class="code" href="classCInstructionJumpS.html#f610b22fcf027db2ad2152c52c006eda">m_addr</a>;
+<a name="l00418"></a>00418 };
+<a name="l00419"></a>00419 
+<a name="l00420"></a>00420 <span class="comment">/*============================================================================*/</span>
+<a name="l00421"></a>00421 
+<a name="l00429"></a><a class="code" href="classCInstructionWrite.html">00429</a> <span class="keyword">class </span><a class="code" href="classCInstructionWrite.html">CInstructionWrite</a>
+<a name="l00430"></a>00430  : <span class="keyword">public</span> <a class="code" href="classCInstruction.html">CInstruction</a>
+<a name="l00431"></a>00431 {
+<a name="l00432"></a>00432   <span class="keyword">public</span>:
+<a name="l00433"></a>00433     <a class="code" href="classCInstructionWrite.html">CInstructionWrite</a>()
+<a name="l00434"></a>00434       : <a class="code" href="classCInstruction.html#263195c9e1f109bf44f7040727dcfa78" title="Default ctor.">CInstruction</a>(<span class="stringliteral">"write"</span>), <a class="code" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">m_dev</a>(<span class="stringliteral">""</span>)
+<a name="l00435"></a>00435     {}
+<a name="l00436"></a>00436 
+<a name="l00437"></a><a class="code" href="classCInstructionWrite.html#a33ddc8fb13dfaa253704eb0952f3cea">00437</a>     <a class="code" href="classCInstructionWrite.html">CInstructionWrite</a> *<a class="code" href="classCInstructionWrite.html#a33ddc8fb13dfaa253704eb0952f3cea" title="creates a new instance of this instruction">factory</a>()
+<a name="l00438"></a>00438     {
+<a name="l00439"></a>00439       <span class="keywordflow">return</span> <span class="keyword">new</span> <a class="code" href="classCInstructionWrite.html">CInstructionWrite</a>;
+<a name="l00440"></a>00440     }
+<a name="l00441"></a>00441 
+<a name="l00442"></a>00442     <span class="keywordtype">void</span> <a class="code" href="classCInstructionWrite.html#23f5bb8e4b8a74f7a8703d593323b991" title="parses instruction parameters and prepares the instruction for executing">compile</a>(std::list&lt;std::string&gt;&amp; params);
+<a name="l00443"></a>00443     <span class="keywordtype">void</span> <a class="code" href="classCInstructionWrite.html#1852e50c21b758a4db205a6cd20e208d" title="executes the instruction">execute</a>(<a class="code" href="classCCPU.html">CCPU</a> *cpu);
+<a name="l00444"></a>00444 
+<a name="l00445"></a>00445   <span class="keyword">protected</span>:
+<a name="l00447"></a><a class="code" href="classCInstructionWrite.html#7af118a6f35320bbbee55051188311d6">00447</a>     <span class="keywordtype">unsigned</span> <a class="code" href="classCInstructionWrite.html#7af118a6f35320bbbee55051188311d6">m_regidx1</a>;
+<a name="l00449"></a><a class="code" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">00449</a>     std::string <a class="code" href="classCInstructionWrite.html#a8ac6c36d3fbbfedfa2311f15c0608cc">m_dev</a>;
+<a name="l00450"></a>00450 };
+<a name="l00451"></a>00451 
+<a name="l00452"></a>00452 <span class="preprocessor">#endif</span>
+<a name="l00453"></a>00453 <span class="preprocessor"></span>
+<a name="l00454"></a>00454 <span class="comment">/* vim: set et sw=2 ts=2: */</span>
+</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:16 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/namespaces.html b/ue3/doxygen/namespaces.html
new file mode 100644
index 0000000..171e4d7
--- /dev/null
+++ b/ue3/doxygen/namespaces.html
@@ -0,0 +1,23 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: Namespace Index</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li class="current"><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>mycpu Namespace List</h1>Here is a list of all documented namespaces with brief descriptions:<table>
+  <tr><td class="indexkey"><a class="el" href="namespacestd.html">std</a></td><td class="indexvalue">CPU implementation. Used as a container for memory and instructions. Implements an run method to execute the program (= the instructions) </td></tr>
+</table>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/namespacestd.html b/ue3/doxygen/namespacestd.html
new file mode 100644
index 0000000..29c962a
--- /dev/null
+++ b/ue3/doxygen/namespacestd.html
@@ -0,0 +1,32 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+<title>mycpu: std Namespace Reference</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<!-- Generated by Doxygen 1.5.3 -->
+<div class="tabs">
+  <ul>
+    <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
+    <li class="current"><a href="namespaces.html"><span>Namespaces</span></a></li>
+    <li><a href="annotated.html"><span>Classes</span></a></li>
+    <li><a href="files.html"><span>Files</span></a></li>
+  </ul>
+</div>
+<h1>std Namespace Reference</h1>CPU implementation. Used as a container for memory and instructions. Implements an run method to execute the program (= the instructions).  
+<a href="#_details">More...</a>
+<p>
+<table border="0" cellpadding="0" cellspacing="0">
+<tr><td></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+CPU implementation. Used as a container for memory and instructions. Implements an run method to execute the program (= the instructions). 
+<p>
+<dl class="user" compact><dt><b>Modulname:</b></dt><dd>ccpu </dd></dl>
+<dl class="author" compact><dt><b>Author:</b></dt><dd>Guenther Neuwirth (0626638), Manuel Mausz (0728348) </dd></dl>
+<dl class="date" compact><dt><b>Date:</b></dt><dd>10.05.2009 </dd></dl>
+<hr size="1"><address style="text-align: right;"><small>Generated on Thu May 14 18:19:17 2009 for mycpu by&nbsp;
+<a href="http://www.doxygen.org/index.html">
+<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
+</body>
+</html>
diff --git a/ue3/doxygen/tab_b.gif b/ue3/doxygen/tab_b.gif
new file mode 100644
index 0000000..0d62348
Binary files /dev/null and b/ue3/doxygen/tab_b.gif differ
diff --git a/ue3/doxygen/tab_l.gif b/ue3/doxygen/tab_l.gif
new file mode 100644
index 0000000..9b1e633
Binary files /dev/null and b/ue3/doxygen/tab_l.gif differ
diff --git a/ue3/doxygen/tab_r.gif b/ue3/doxygen/tab_r.gif
new file mode 100644
index 0000000..ce9dd9f
Binary files /dev/null and b/ue3/doxygen/tab_r.gif differ
diff --git a/ue3/doxygen/tabs.css b/ue3/doxygen/tabs.css
new file mode 100644
index 0000000..c37faaf
--- /dev/null
+++ b/ue3/doxygen/tabs.css
@@ -0,0 +1,102 @@
+/* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */
+
+DIV.tabs
+{
+   float            : left;
+   width            : 100%;
+   background       : url("tab_b.gif") repeat-x bottom;
+   margin-bottom    : 4px;
+}
+
+DIV.tabs UL
+{
+   margin           : 0px;
+   padding-left     : 10px;
+   list-style       : none;
+}
+
+DIV.tabs LI, DIV.tabs FORM
+{
+   display          : inline;
+   margin           : 0px;
+   padding          : 0px;
+}
+
+DIV.tabs FORM
+{
+   float            : right;
+}
+
+DIV.tabs A
+{
+   float            : left;
+   background       : url("tab_r.gif") no-repeat right top;
+   border-bottom    : 1px solid #84B0C7;
+   font-size        : x-small;
+   font-weight      : bold;
+   text-decoration  : none;
+}
+
+DIV.tabs A:hover
+{
+   background-position: 100% -150px;
+}
+
+DIV.tabs A:link, DIV.tabs A:visited,
+DIV.tabs A:active, DIV.tabs A:hover
+{
+       color: #1A419D;
+}
+
+DIV.tabs SPAN
+{
+   float            : left;
+   display          : block;
+   background       : url("tab_l.gif") no-repeat left top;
+   padding          : 5px 9px;
+   white-space      : nowrap;
+}
+
+DIV.tabs INPUT
+{
+   float            : right;
+   display          : inline;
+   font-size        : 1em;
+}
+
+DIV.tabs TD
+{
+   font-size        : x-small;
+   font-weight      : bold;
+   text-decoration  : none;
+}
+
+
+
+/* Commented Backslash Hack hides rule from IE5-Mac \*/
+DIV.tabs SPAN {float : none;}
+/* End IE5-Mac hack */
+
+DIV.tabs A:hover SPAN
+{
+   background-position: 0% -150px;
+}
+
+DIV.tabs LI.current A
+{
+   background-position: 100% -150px;
+   border-width     : 0px;
+}
+
+DIV.tabs LI.current SPAN
+{
+   background-position: 0% -150px;
+   padding-bottom   : 6px;
+}
+
+DIV.nav
+{
+   background       : none;
+   border           : none;
+   border-bottom    : 1px solid #84B0C7;
+}
diff --git a/ue3/mycpu/cdisplay.h b/ue3/mycpu/cdisplay.h
index 1523f68..82776ee 100644
--- a/ue3/mycpu/cdisplay.h
+++ b/ue3/mycpu/cdisplay.h
@@ -57,7 +57,7 @@ class CDisplayT
     }
 
     /**
-     * @method getName
+     * @method display
      * @brief  prints value to display
      * @param  value  value to display
      * @return -
diff --git a/ue3/mycpu/displays.h b/ue3/mycpu/displays.h
index 87b9408..d4f3f36 100644
--- a/ue3/mycpu/displays.h
+++ b/ue3/mycpu/displays.h
@@ -25,6 +25,15 @@ class CDisplayWDEZ
       : CDisplay("wdez")
     {}
 
+    /**
+     * @method display
+     * @brief  prints value to display
+     * @param  value  value to display
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
     void display(const CDat &value)
     {
       std::cout << std::dec << value << std::endl;
@@ -47,6 +56,15 @@ class CDisplayWHEX
       : CDisplay("whex")
     {}
 
+    /**
+     * @method display
+     * @brief  prints value to display
+     * @param  value  value to display
+     * @return -
+     * @globalvars none
+     * @exception  none
+     * @conditions none
+     */
     void display(const CDat &value)
     {
       std::cout << std::hex << value << std::endl;
-- 
cgit v1.2.3