From dcd1c9a6e1fbb7462db67a15b9e0dfd22d4f6a4f Mon Sep 17 00:00:00 2001 From: manuel Date: Sat, 30 May 2009 16:32:43 +0200 Subject: adding doxygen --- ue4/doxygen/annotated.html | 56 ++ ue4/doxygen/ccpu_8h-source.html | 209 ++++++ ue4/doxygen/cdat_8h-source.html | 145 ++++ ue4/doxygen/cdatn_8h-source.html | 156 ++++ ue4/doxygen/cdatset_8h-source.html | 56 ++ ue4/doxygen/cdisplay_8h-source.html | 49 ++ ue4/doxygen/cinstruction_8h-source.html | 136 ++++ ue4/doxygen/classCCPU-members.html | 41 ++ ue4/doxygen/classCCPU.html | 632 ++++++++++++++++ ue4/doxygen/classCCPUError-members.html | 28 + ue4/doxygen/classCCPUError.html | 78 ++ ue4/doxygen/classCDat-members.html | 48 ++ ue4/doxygen/classCDat.html | 919 ++++++++++++++++++++++++ ue4/doxygen/classCDatN-members.html | 49 ++ ue4/doxygen/classCDatN.html | 902 +++++++++++++++++++++++ ue4/doxygen/classCDatSet-members.html | 51 ++ ue4/doxygen/classCDatSet.html | 178 +++++ ue4/doxygen/classCDatSet.png | Bin 0 -> 564 bytes ue4/doxygen/classCDisplay-members.html | 32 + ue4/doxygen/classCDisplay.html | 242 +++++++ ue4/doxygen/classCDisplay.png | Bin 0 -> 706 bytes ue4/doxygen/classCDisplayWDEZ-members.html | 33 + ue4/doxygen/classCDisplayWDEZ.html | 94 +++ ue4/doxygen/classCDisplayWDEZ.png | Bin 0 -> 458 bytes ue4/doxygen/classCDisplayWHEX-members.html | 33 + ue4/doxygen/classCDisplayWHEX.html | 94 +++ ue4/doxygen/classCDisplayWHEX.png | Bin 0 -> 452 bytes ue4/doxygen/classCInstruction-members.html | 40 ++ ue4/doxygen/classCInstruction.html | 615 ++++++++++++++++ ue4/doxygen/classCInstruction.png | Bin 0 -> 3523 bytes ue4/doxygen/classCInstructionAdd-members.html | 44 ++ ue4/doxygen/classCInstructionAdd.html | 240 +++++++ ue4/doxygen/classCInstructionAdd.png | Bin 0 -> 451 bytes ue4/doxygen/classCInstructionDec-members.html | 42 ++ ue4/doxygen/classCInstructionDec.html | 202 ++++++ ue4/doxygen/classCInstructionDec.png | Bin 0 -> 450 bytes ue4/doxygen/classCInstructionDiv-members.html | 44 ++ ue4/doxygen/classCInstructionDiv.html | 240 +++++++ ue4/doxygen/classCInstructionDiv.png | Bin 0 -> 448 bytes ue4/doxygen/classCInstructionError-members.html | 28 + ue4/doxygen/classCInstructionError.html | 78 ++ ue4/doxygen/classCInstructionInc-members.html | 42 ++ ue4/doxygen/classCInstructionInc.html | 202 ++++++ ue4/doxygen/classCInstructionInc.png | Bin 0 -> 433 bytes ue4/doxygen/classCInstructionJumpA-members.html | 42 ++ ue4/doxygen/classCInstructionJumpA.html | 202 ++++++ ue4/doxygen/classCInstructionJumpA.png | Bin 0 -> 481 bytes ue4/doxygen/classCInstructionJumpS-members.html | 42 ++ ue4/doxygen/classCInstructionJumpS.html | 202 ++++++ ue4/doxygen/classCInstructionJumpS.png | Bin 0 -> 481 bytes ue4/doxygen/classCInstructionJumpZ-members.html | 42 ++ ue4/doxygen/classCInstructionJumpZ.html | 202 ++++++ ue4/doxygen/classCInstructionJumpZ.png | Bin 0 -> 480 bytes ue4/doxygen/classCInstructionLabel-members.html | 41 ++ ue4/doxygen/classCInstructionLabel.html | 181 +++++ ue4/doxygen/classCInstructionLabel.png | Bin 0 -> 459 bytes ue4/doxygen/classCInstructionLoad-members.html | 43 ++ ue4/doxygen/classCInstructionLoad.html | 221 ++++++ ue4/doxygen/classCInstructionLoad.png | Bin 0 -> 459 bytes ue4/doxygen/classCInstructionMul-members.html | 44 ++ ue4/doxygen/classCInstructionMul.html | 240 +++++++ ue4/doxygen/classCInstructionMul.png | Bin 0 -> 448 bytes ue4/doxygen/classCInstructionStore-members.html | 43 ++ ue4/doxygen/classCInstructionStore.html | 221 ++++++ ue4/doxygen/classCInstructionStore.png | Bin 0 -> 465 bytes ue4/doxygen/classCInstructionSub-members.html | 44 ++ ue4/doxygen/classCInstructionSub.html | 240 +++++++ ue4/doxygen/classCInstructionSub.png | Bin 0 -> 450 bytes ue4/doxygen/classCInstructionTest-members.html | 42 ++ ue4/doxygen/classCInstructionTest.html | 202 ++++++ ue4/doxygen/classCInstructionTest.png | Bin 0 -> 454 bytes ue4/doxygen/classCInstructionWrite-members.html | 43 ++ ue4/doxygen/classCInstructionWrite.html | 221 ++++++ ue4/doxygen/classCInstructionWrite.png | Bin 0 -> 457 bytes ue4/doxygen/classCMem-members.html | 28 + ue4/doxygen/classCMem.html | 93 +++ ue4/doxygen/classCMemError-members.html | 28 + ue4/doxygen/classCMemError.html | 78 ++ ue4/doxygen/classCProgram-members.html | 32 + ue4/doxygen/classCProgram.html | 251 +++++++ ue4/doxygen/classCProgramError-members.html | 28 + ue4/doxygen/classCProgramError.html | 78 ++ ue4/doxygen/cmem_8h-source.html | 104 +++ ue4/doxygen/cprogram_8h-source.html | 237 ++++++ ue4/doxygen/displays_8h-source.html | 61 ++ ue4/doxygen/doxygen.css | 358 +++++++++ ue4/doxygen/doxygen.png | Bin 0 -> 1281 bytes ue4/doxygen/files.html | 31 + ue4/doxygen/functions.html | 297 ++++++++ ue4/doxygen/functions_func.html | 249 +++++++ ue4/doxygen/functions_rela.html | 46 ++ ue4/doxygen/functions_vars.html | 75 ++ ue4/doxygen/hierarchy.html | 65 ++ ue4/doxygen/index.html | 21 + ue4/doxygen/instructions_8h-source.html | 752 +++++++++++++++++++ ue4/doxygen/tab_b.gif | Bin 0 -> 35 bytes ue4/doxygen/tab_l.gif | Bin 0 -> 706 bytes ue4/doxygen/tab_r.gif | Bin 0 -> 2585 bytes ue4/doxygen/tabs.css | 102 +++ 99 files changed, 11650 insertions(+) create mode 100644 ue4/doxygen/annotated.html create mode 100644 ue4/doxygen/ccpu_8h-source.html create mode 100644 ue4/doxygen/cdat_8h-source.html create mode 100644 ue4/doxygen/cdatn_8h-source.html create mode 100644 ue4/doxygen/cdatset_8h-source.html create mode 100644 ue4/doxygen/cdisplay_8h-source.html create mode 100644 ue4/doxygen/cinstruction_8h-source.html create mode 100644 ue4/doxygen/classCCPU-members.html create mode 100644 ue4/doxygen/classCCPU.html create mode 100644 ue4/doxygen/classCCPUError-members.html create mode 100644 ue4/doxygen/classCCPUError.html create mode 100644 ue4/doxygen/classCDat-members.html create mode 100644 ue4/doxygen/classCDat.html create mode 100644 ue4/doxygen/classCDatN-members.html create mode 100644 ue4/doxygen/classCDatN.html create mode 100644 ue4/doxygen/classCDatSet-members.html create mode 100644 ue4/doxygen/classCDatSet.html create mode 100644 ue4/doxygen/classCDatSet.png create mode 100644 ue4/doxygen/classCDisplay-members.html create mode 100644 ue4/doxygen/classCDisplay.html create mode 100644 ue4/doxygen/classCDisplay.png create mode 100644 ue4/doxygen/classCDisplayWDEZ-members.html create mode 100644 ue4/doxygen/classCDisplayWDEZ.html create mode 100644 ue4/doxygen/classCDisplayWDEZ.png create mode 100644 ue4/doxygen/classCDisplayWHEX-members.html create mode 100644 ue4/doxygen/classCDisplayWHEX.html create mode 100644 ue4/doxygen/classCDisplayWHEX.png create mode 100644 ue4/doxygen/classCInstruction-members.html create mode 100644 ue4/doxygen/classCInstruction.html create mode 100644 ue4/doxygen/classCInstruction.png create mode 100644 ue4/doxygen/classCInstructionAdd-members.html create mode 100644 ue4/doxygen/classCInstructionAdd.html create mode 100644 ue4/doxygen/classCInstructionAdd.png create mode 100644 ue4/doxygen/classCInstructionDec-members.html create mode 100644 ue4/doxygen/classCInstructionDec.html create mode 100644 ue4/doxygen/classCInstructionDec.png create mode 100644 ue4/doxygen/classCInstructionDiv-members.html create mode 100644 ue4/doxygen/classCInstructionDiv.html create mode 100644 ue4/doxygen/classCInstructionDiv.png create mode 100644 ue4/doxygen/classCInstructionError-members.html create mode 100644 ue4/doxygen/classCInstructionError.html create mode 100644 ue4/doxygen/classCInstructionInc-members.html create mode 100644 ue4/doxygen/classCInstructionInc.html create mode 100644 ue4/doxygen/classCInstructionInc.png create mode 100644 ue4/doxygen/classCInstructionJumpA-members.html create mode 100644 ue4/doxygen/classCInstructionJumpA.html create mode 100644 ue4/doxygen/classCInstructionJumpA.png create mode 100644 ue4/doxygen/classCInstructionJumpS-members.html create mode 100644 ue4/doxygen/classCInstructionJumpS.html create mode 100644 ue4/doxygen/classCInstructionJumpS.png create mode 100644 ue4/doxygen/classCInstructionJumpZ-members.html create mode 100644 ue4/doxygen/classCInstructionJumpZ.html create mode 100644 ue4/doxygen/classCInstructionJumpZ.png create mode 100644 ue4/doxygen/classCInstructionLabel-members.html create mode 100644 ue4/doxygen/classCInstructionLabel.html create mode 100644 ue4/doxygen/classCInstructionLabel.png create mode 100644 ue4/doxygen/classCInstructionLoad-members.html create mode 100644 ue4/doxygen/classCInstructionLoad.html create mode 100644 ue4/doxygen/classCInstructionLoad.png create mode 100644 ue4/doxygen/classCInstructionMul-members.html create mode 100644 ue4/doxygen/classCInstructionMul.html create mode 100644 ue4/doxygen/classCInstructionMul.png create mode 100644 ue4/doxygen/classCInstructionStore-members.html create mode 100644 ue4/doxygen/classCInstructionStore.html create mode 100644 ue4/doxygen/classCInstructionStore.png create mode 100644 ue4/doxygen/classCInstructionSub-members.html create mode 100644 ue4/doxygen/classCInstructionSub.html create mode 100644 ue4/doxygen/classCInstructionSub.png create mode 100644 ue4/doxygen/classCInstructionTest-members.html create mode 100644 ue4/doxygen/classCInstructionTest.html create mode 100644 ue4/doxygen/classCInstructionTest.png create mode 100644 ue4/doxygen/classCInstructionWrite-members.html create mode 100644 ue4/doxygen/classCInstructionWrite.html create mode 100644 ue4/doxygen/classCInstructionWrite.png create mode 100644 ue4/doxygen/classCMem-members.html create mode 100644 ue4/doxygen/classCMem.html create mode 100644 ue4/doxygen/classCMemError-members.html create mode 100644 ue4/doxygen/classCMemError.html create mode 100644 ue4/doxygen/classCProgram-members.html create mode 100644 ue4/doxygen/classCProgram.html create mode 100644 ue4/doxygen/classCProgramError-members.html create mode 100644 ue4/doxygen/classCProgramError.html create mode 100644 ue4/doxygen/cmem_8h-source.html create mode 100644 ue4/doxygen/cprogram_8h-source.html create mode 100644 ue4/doxygen/displays_8h-source.html create mode 100644 ue4/doxygen/doxygen.css create mode 100644 ue4/doxygen/doxygen.png create mode 100644 ue4/doxygen/files.html create mode 100644 ue4/doxygen/functions.html create mode 100644 ue4/doxygen/functions_func.html create mode 100644 ue4/doxygen/functions_rela.html create mode 100644 ue4/doxygen/functions_vars.html create mode 100644 ue4/doxygen/hierarchy.html create mode 100644 ue4/doxygen/index.html create mode 100644 ue4/doxygen/instructions_8h-source.html create mode 100644 ue4/doxygen/tab_b.gif create mode 100644 ue4/doxygen/tab_l.gif create mode 100644 ue4/doxygen/tab_r.gif create mode 100644 ue4/doxygen/tabs.css diff --git a/ue4/doxygen/annotated.html b/ue4/doxygen/annotated.html new file mode 100644 index 0000000..ffd5645 --- /dev/null +++ b/ue4/doxygen/annotated.html @@ -0,0 +1,56 @@ + + +mycpu: Class List + + + + +
+ +
+
+ +
+

mycpu Class List

Here are the classes, structs, unions and interfaces with brief descriptions: + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CCPU< T >
CCPUError
CDat< T >
CDatN
CDatSet
CDisplay< T >
CDisplayWDEZ< T >
CDisplayWHEX< T >
CInstruction< T >
CInstructionAdd< T >
CInstructionDec< T >
CInstructionDiv< T >
CInstructionError
CInstructionInc< T >
CInstructionJumpA< T >
CInstructionJumpS< T >
CInstructionJumpZ< T >
CInstructionLabel< T >
CInstructionLoad< T >
CInstructionMul< T >
CInstructionStore< T >
CInstructionSub< T >
CInstructionTest< T >
CInstructionWrite< T >
CMem< T >
CMemError
CProgram< T >
CProgramError
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/ccpu_8h-source.html b/ue4/doxygen/ccpu_8h-source.html new file mode 100644 index 0000000..32b8612 --- /dev/null +++ b/ue4/doxygen/ccpu_8h-source.html @@ -0,0 +1,209 @@ + + +mycpu: mycpu/ccpu.h Source File + + + + +
+ +
+

mycpu/ccpu.h

00001 
+00009 #ifndef CCPU_H
+00010 #define CCPU_H 1
+00011 
+00012 #include <iostream>
+00013 #include <set>
+00014 #include <stdexcept>
+00015 #ifdef DEBUG
+00016 # include <iostream>
+00017 # include <iomanip>
+00018 #endif
+00019 
+00025 class CCPUError
+00026  : public std::invalid_argument
+00027 {
+00028   public:
+00039     CCPUError(const std::string& what)
+00040       : std::invalid_argument(what)
+00041     {}
+00042 };
+00043 
+00044 #include "cmem.h"
+00045 #include "displays.h"
+00046 #include "cprogram.h"
+00047 
+00048 /* forward declare CProgram */
+00049 template <class T>
+00050 class CProgram;
+00051 
+00058 template <class T>
+00059 class CCPU
+00060 {
+00061   typedef typename std::set<CDisplay<T> *>::iterator displayiterator;
+00062 
+00063   public:
+00075     CCPU(const unsigned cnt, T& datatype);
+00076 
+00087     ~CCPU();
+00088 
+00099     const unsigned getRegisterCount() const
+00100     {
+00101       return m_regcnt;
+00102     }
+00103 
+00114     std::vector<T> &getRegisters()
+00115     {
+00116       return m_registers;
+00117     }
+00118 
+00129     void setMemory(CMem<T> *memory)
+00130     {
+00131       m_memory = memory;
+00132     }
+00133 
+00144     CMem<T> *getMemory() const
+00145     {
+00146       return m_memory;
+00147     }
+00148 
+00159     void setProgram(const CProgram<T> *program)
+00160     {
+00161       m_program = program;
+00162     }
+00163 
+00174     const CProgram<T> *getProgram()
+00175     {
+00176       return m_program;
+00177     }
+00178 
+00189     const std::set<CDisplay<T> *>& getDisplays()
+00190     {
+00191       return m_displays;
+00192     }
+00193 
+00204     void setFlagZero(const bool value)
+00205     {
+00206       m_flagzero = value;
+00207     }
+00208 
+00219     const bool getFlagZero()
+00220     {
+00221       return m_flagzero;
+00222     }
+00223 
+00234     void setFlagSign(const bool value)
+00235     {
+00236       m_flagsign = value;
+00237     }
+00238 
+00249     const bool getFlagSign()
+00250     {
+00251       return m_flagsign;
+00252     }
+00253 
+00264     void run();
+00265 
+00266 #if DEBUG
+00267 
+00277     void dumpRegisters(std::ostream& out);
+00278 #endif
+00279 
+00280   private:
+00281     /* members */
+00282     T m_datatype;
+00283     std::vector<T> m_registers;
+00284     unsigned m_regcnt;
+00285     CMem<T> *m_memory;
+00286     const CProgram<T> *m_program;
+00287     std::set<CDisplay<T> *> m_displays;
+00288     bool m_flagzero;
+00289     bool m_flagsign;
+00290 };
+00291 
+00292 /*----------------------------------------------------------------------------*/
+00293 
+00294 template <class T>
+00295 CCPU<T>::CCPU(const unsigned cnt, T& datatype)
+00296   : m_datatype(datatype), m_registers(cnt, T(m_datatype) = 0), m_regcnt(cnt), m_memory(NULL), m_program(NULL), m_flagzero(false), m_flagsign(false)
+00297 {
+00298   /* create displays */
+00299   m_displays.insert(new CDisplayWDEZ<T>);
+00300   m_displays.insert(new CDisplayWHEX<T>);
+00301 }
+00302 
+00303 /*----------------------------------------------------------------------------*/
+00304 
+00305 template <class T>
+00306 CCPU<T>::~CCPU()
+00307 {
+00308   /* delete displays */
+00309   for (displayiterator it = m_displays.begin() ; it != m_displays.end(); ++it)
+00310     delete *it;
+00311 }
+00312 
+00313 /*----------------------------------------------------------------------------*/
+00314 
+00315 template <class T>
+00316 void CCPU<T>::run()
+00317 {
+00318   if (m_memory == NULL)
+00319     throw CCPUError("CPU has no memory");
+00320   if (m_program == NULL)
+00321     throw CCPUError("CPU has no program to execute");
+00322   if (m_regcnt == 0)
+00323     throw CCPUError("CPU has no registers");
+00324 
+00325   bool run = true;
+00326   while(run)
+00327   {
+00328     unsigned pc = static_cast<unsigned>(m_registers[0]);
+00329 
+00330     /* end of the program reached */
+00331     if (pc == m_program->size())
+00332       break;
+00333 
+00334     /* pc is out of bound */
+00335     if (pc > m_program->size())
+00336       throw CCPUError("Programcounter is out of bound");
+00337 
+00338     /* execute instruction */
+00339     try
+00340     {
+00341       (*m_program->at(pc))(this);
+00342       ++m_registers[0];
+00343     }
+00344     catch(CInstructionError& ex)
+00345     {
+00346       throw CCPUError(ex.what());
+00347     }
+00348   }
+00349 }
+00350 
+00351 /*----------------------------------------------------------------------------*/
+00352 
+00353 #if DEBUG
+00354 template <class T>
+00355 void CCPU<T>::dumpRegisters(std::ostream& out)
+00356 {
+00357   out << "[REGISTER DUMP]" << std::endl;
+00358   for(unsigned i = 0; i < getRegisterCount(); ++i)
+00359   {
+00360     out << "[" << std::setw(4) << std::setfill('0') << i << "]  "
+00361         << m_registers[i] << std::endl;
+00362   }
+00363 }
+00364 #endif
+00365 
+00366 #endif
+00367 
+00368 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/cdat_8h-source.html b/ue4/doxygen/cdat_8h-source.html new file mode 100644 index 0000000..f90051e --- /dev/null +++ b/ue4/doxygen/cdat_8h-source.html @@ -0,0 +1,145 @@ + + +mycpu: mycpu/cdat.h Source File + + + + +
+ +
+

mycpu/cdat.h

00001 
+00008 #ifndef CDAT_H
+00009 #define CDAT_H 1
+00010 
+00011 #include <boost/operators.hpp>
+00012 #include <iostream>
+00013 
+00019 template <class T>
+00020 class CDat
+00021   : public boost::operators<CDat<T> >
+00022 {
+00023   public:
+00034     CDat()
+00035     {}
+00036 
+00047     virtual ~CDat()
+00048     {}
+00049 
+00060     CDat(const CDat& other)
+00061       : m_value(other.m_value)
+00062     {}
+00063 
+00074     CDat(const T newval)
+00075       : m_value(newval)
+00076     {}
+00077 
+00088     T getValue() const
+00089     {
+00090       return m_value;
+00091     }
+00092 
+00103     operator T()
+00104     {
+00105       return m_value;
+00106     }
+00107 
+00118     bool operator<(const CDat& x) const
+00119     {
+00120       return m_value < x.m_value;
+00121     }
+00122 
+00133     bool operator==(const CDat& x) const
+00134     {
+00135       return m_value == x.m_value;
+00136     }
+00137 
+00148     CDat& operator+=(const CDat& x)
+00149     {
+00150       m_value += x.m_value;
+00151       return *this;
+00152     }
+00153 
+00164     CDat& operator-=(const CDat& x)
+00165     {
+00166       m_value -= x.m_value;
+00167       return *this;
+00168     }
+00169 
+00180     CDat& operator*=(const CDat& x)
+00181     {
+00182       m_value *= x.m_value;
+00183       return *this;
+00184     }
+00185 
+00196     CDat& operator/=(const CDat& x)
+00197     {
+00198       m_value /= x.m_value;
+00199       return *this;
+00200     }
+00201 
+00212     CDat& operator%=(const CDat& x)
+00213     {
+00214       m_value %= x.m_value;
+00215       return *this;
+00216     }
+00217 
+00228     CDat& operator|=(const CDat& x)
+00229     {
+00230       m_value |= x.m_value;
+00231       return *this;
+00232     }
+00233 
+00244     CDat& operator&=(const CDat& x)
+00245     {
+00246       m_value &= x.m_value;
+00247       return *this;
+00248     }
+00249 
+00260     CDat& operator^=(const CDat& x)
+00261     {
+00262       m_value ^= x.m_value;
+00263       return *this;
+00264     }
+00265 
+00276     CDat& operator++()
+00277     {
+00278       m_value++;
+00279       return *this;
+00280     }
+00281 
+00292     CDat& operator--()
+00293     {
+00294       m_value--;
+00295       return *this;
+00296     }
+00297 
+00309     friend std::ostream& operator<<(std::ostream& stream, CDat cdat)
+00310     {
+00311       stream << cdat.m_value;
+00312       return stream;
+00313     }
+00314 
+00326     friend std::istream& operator>>(std::istream & stream, CDat& cdat)
+00327     {
+00328       stream >> cdat.m_value;
+00329       return stream;
+00330     }
+00331 
+00332   protected:
+00333     /* members */
+00335     T m_value;
+00336 };
+00337 
+00338 #endif
+00339 
+00340 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/cdatn_8h-source.html b/ue4/doxygen/cdatn_8h-source.html new file mode 100644 index 0000000..af04fe7 --- /dev/null +++ b/ue4/doxygen/cdatn_8h-source.html @@ -0,0 +1,156 @@ + + +mycpu: mycpu/cdatn.h Source File + + + + +
+ +
+

mycpu/cdatn.h

00001 
+00008 #ifndef CDATN_H
+00009 #define CDATN_H 1
+00010 
+00011 #include <boost/operators.hpp>
+00012 #include <iostream>
+00013 
+00019 class CDatN
+00020   : public boost::operators<CDatN>
+00021 {
+00022   private:
+00033     CDatN()
+00034     {}
+00035 
+00036   public:
+00047     virtual ~CDatN()
+00048     {}
+00049 
+00060     CDatN(const CDatN& other)
+00061       : m_value(other.m_value), m_width(other.m_width)
+00062     {}
+00063 
+00075     CDatN(const int newval, unsigned width = 31)
+00076       : m_value(((1 << width) - 1) & newval), m_width(width)
+00077     {
+00078       if (width < 2 || width > 32)
+00079         throw std::runtime_error("width must be between 2 and 32");
+00080     }
+00081 
+00092     int getValue() const
+00093     {
+00094       return m_value;
+00095     }
+00096 
+00107     operator int()
+00108     {
+00109       return m_value;
+00110     }
+00111 
+00122     bool operator<(const CDatN& x) const
+00123     {
+00124       return m_value < x.m_value;
+00125     }
+00126 
+00137     bool operator==(const CDatN& x) const
+00138     {
+00139       return m_value == x.m_value;
+00140     }
+00141 
+00152     CDatN &operator=(const int& newval)
+00153     {
+00154       m_value = ((1 << m_width) - 1) & newval;
+00155       return *this;
+00156     }
+00157 
+00168     CDatN& operator+=(const CDatN& x)
+00169     {
+00170       m_value = ((1 << m_width) - 1) & (m_value + x.m_value);
+00171       return *this;
+00172     }
+00173 
+00184     CDatN& operator-=(const CDatN& x)
+00185     {
+00186       m_value = ((1 << m_width) - 1) & (m_value - x.m_value);
+00187       return *this;
+00188     }
+00189 
+00200     CDatN& operator*=(const CDatN& x)
+00201     {
+00202       m_value = ((1 << m_width) - 1) & (m_value * x.m_value);
+00203       return *this;
+00204     }
+00205 
+00216     CDatN& operator/=(const CDatN& x)
+00217     {
+00218       m_value = ((1 << m_width) - 1) & (m_value / x.m_value);
+00219       return *this;
+00220     }
+00221 
+00232     CDatN& operator%=(const CDatN& x)
+00233     {
+00234       m_value = ((1 << m_width) - 1) & (m_value % x.m_value);
+00235       return *this;
+00236     }
+00237 
+00248     CDatN& operator|=(const CDatN& x)
+00249     {
+00250       m_value = ((1 << m_width) - 1) & (m_value | x.m_value);
+00251       return *this;
+00252     }
+00253 
+00264     CDatN& operator&=(const CDatN& x)
+00265     {
+00266       m_value = ((1 << m_width) - 1) & (m_value & x.m_value);
+00267       return *this;
+00268     }
+00269 
+00280     CDatN& operator^=(const CDatN& x)
+00281     {
+00282       m_value = ((1 << m_width) - 1) & (m_value ^ x.m_value);
+00283       return *this;
+00284     }
+00285 
+00296     CDatN& operator++()
+00297     {
+00298       m_value = ((1 << m_width) - 1) & (m_value + 1);
+00299       return *this;
+00300     }
+00301 
+00312     CDatN& operator--()
+00313     {
+00314       m_value--;
+00315       return *this;
+00316     }
+00317 
+00329     friend std::ostream& operator<<(std::ostream& stream, CDatN cdat)
+00330     {
+00331       stream << cdat.m_value;
+00332       return stream;
+00333     }
+00334 
+00346     friend std::istream& operator>>(std::istream & stream, CDatN& cdat)
+00347     {
+00348       stream >> cdat.m_value;
+00349       cdat.m_value = ((1 << cdat.m_width) - 1) & cdat.m_value;
+00350       return stream;
+00351     }
+00352 
+00353   protected:
+00354     /* members */
+00356     int m_value;
+00358     unsigned m_width;
+00359 };
+00360 
+00361 #endif
+00362 
+00363 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/cdatset_8h-source.html b/ue4/doxygen/cdatset_8h-source.html new file mode 100644 index 0000000..ee161cf --- /dev/null +++ b/ue4/doxygen/cdatset_8h-source.html @@ -0,0 +1,56 @@ + + +mycpu: mycpu/cdatset.h Source File + + + + +
+ +
+

mycpu/cdatset.h

00001 
+00008 #ifndef CDATSET_H
+00009 #define CDATSET_H 1
+00010 
+00011 #include <iostream>
+00012 #include "cdat.h"
+00013 
+00019 class CDatSet
+00020   : public CDat<int>, public boost::operators<CDatSet>
+00021 {
+00022   public:
+00033     CDatSet()
+00034     {}
+00035 
+00046     CDatSet(const int newval)
+00047       : CDat<int>(newval)
+00048     {}
+00049 
+00061     friend std::istream& operator>>(std::istream & stream, CDatSet& cdat)
+00062     {
+00063       unsigned count = 0;
+00064       while(stream.good() && !stream.eof())
+00065       {
+00066         int val = stream.get();
+00067         if (val != 'o')
+00068           break;
+00069         ++count;
+00070       }
+00071       stream.clear();
+00072       cdat.m_value = count;
+00073       return stream;
+00074     }
+00075 };
+00076 
+00077 #endif
+00078 
+00079 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/cdisplay_8h-source.html b/ue4/doxygen/cdisplay_8h-source.html new file mode 100644 index 0000000..1326ef2 --- /dev/null +++ b/ue4/doxygen/cdisplay_8h-source.html @@ -0,0 +1,49 @@ + + +mycpu: mycpu/cdisplay.h Source File + + + + +
+ +
+

mycpu/cdisplay.h

00001 
+00008 #ifndef CDISPLAY_H
+00009 #define CDISPLAY_H 1
+00010 
+00016 template <class T>
+00017 class CDisplay
+00018 {
+00019   public:
+00030     CDisplay(std::string name)
+00031       : m_name(name)
+00032     {}
+00033 
+00044     virtual ~CDisplay()
+00045     {}
+00046 
+00057     virtual const std::string& getName()
+00058     {
+00059       return m_name;
+00060     }
+00061 
+00072     virtual void display(const T &value) = 0;
+00073 
+00074   protected:
+00075     /* members */
+00077     std::string m_name;
+00078 };
+00079 
+00080 #endif
+00081 
+00082 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/cinstruction_8h-source.html b/ue4/doxygen/cinstruction_8h-source.html new file mode 100644 index 0000000..2026b0e --- /dev/null +++ b/ue4/doxygen/cinstruction_8h-source.html @@ -0,0 +1,136 @@ + + +mycpu: mycpu/cinstruction.h Source File + + + + +
+ +
+

mycpu/cinstruction.h

00001 
+00008 #ifndef CINSTRUCTION_H
+00009 #define CINSTRUCTION_H 1
+00010 
+00011 #include <iostream>
+00012 #include <list>
+00013 #include <sstream>
+00014 #include <boost/lexical_cast.hpp>
+00015 #include <assert.h>
+00016 #include <stdexcept>
+00017 
+00023 class CInstructionError
+00024  : public std::invalid_argument
+00025 {
+00026   public:
+00037     CInstructionError(const std::string& what)
+00038       : std::invalid_argument(what)
+00039     {}
+00040 };
+00041 
+00042 #include "ccpu.h"
+00043 
+00044 /* forward declare CCPU */
+00045 template <class T>
+00046 class CCPU;
+00047 
+00053 template <class T>
+00054 class CInstruction
+00055 {
+00056   public:
+00067     CInstruction(std::string name)
+00068       : m_name(name)
+00069     {}
+00070 
+00081     virtual ~CInstruction()
+00082     {}
+00083 
+00094     virtual bool operator==(std::string& name)
+00095     {
+00096       return name == m_name;
+00097     }
+00098 
+00109     virtual CInstruction& operator()(CCPU<T> *cpu)
+00110     {
+00111       execute(cpu);
+00112       return *this;
+00113     }
+00114 
+00125     virtual const std::string& getName()
+00126     {
+00127       return m_name;
+00128     }
+00129 
+00140     virtual std::ostream& dump(std::ostream& stream)
+00141     {
+00142       stream << m_name;
+00143       return stream;
+00144     }
+00145 
+00157     friend std::ostream& operator<<(std::ostream& stream, CInstruction& instr)
+00158     {
+00159       return instr.dump(stream);
+00160     }
+00161 
+00172     virtual const unsigned parseRegister(const std::string& str);
+00173 
+00186     virtual void checkRegister(CCPU<T> *cpu, const unsigned regidx);
+00187 
+00198     virtual CInstruction *factory() = 0;
+00199 
+00211     virtual void compile(std::list<std::string>& params) = 0;
+00212 
+00223     virtual void execute(CCPU<T> *cpu) = 0;
+00224 
+00225   protected:
+00226     /* members */
+00228     std::string m_name;
+00229 };
+00230 
+00231 /*----------------------------------------------------------------------------*/
+00232 
+00233 template<class T>
+00234 const unsigned CInstruction<T>::parseRegister(const std::string& str)
+00235 {
+00236   unsigned reg;
+00237   if (str.length() < 2 || str[0] != 'r')
+00238     throw CInstructionError("Invalid syntax of register");
+00239 
+00240   try
+00241   {
+00242     reg = boost::lexical_cast<unsigned>(str.substr(1));
+00243   }
+00244   catch(boost::bad_lexical_cast& ex)
+00245   {
+00246     throw CInstructionError("Invalid syntax of register");
+00247   }
+00248 
+00249   return reg;
+00250 }
+00251 
+00252 /*----------------------------------------------------------------------------*/
+00253 
+00254 template<class T>
+00255 inline void CInstruction<T>::checkRegister(CCPU<T> *cpu, const unsigned regidx)
+00256 {
+00257   assert(cpu != NULL);
+00258   if (regidx >= cpu->getRegisterCount())
+00259   {
+00260     std::stringstream sstr;
+00261     sstr << "Register R" << regidx << " doesn't exist (out of bound)";
+00262     throw CInstructionError(sstr.str());
+00263   }
+00264 }
+00265 
+00266 #endif
+00267 
+00268 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCCPU-members.html b/ue4/doxygen/classCCPU-members.html new file mode 100644 index 0000000..9a6f0e2 --- /dev/null +++ b/ue4/doxygen/classCCPU-members.html @@ -0,0 +1,41 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CCPU< T > Member List

This is the complete list of members for CCPU< T >, including all inherited members.

+ + + + + + + + + + + + + + +
CCPU(const unsigned cnt, T &datatype)CCPU< T > [inline]
getDisplays()CCPU< T > [inline]
getFlagSign()CCPU< T > [inline]
getFlagZero()CCPU< T > [inline]
getMemory() const CCPU< T > [inline]
getProgram()CCPU< T > [inline]
getRegisterCount() const CCPU< T > [inline]
getRegisters()CCPU< T > [inline]
run()CCPU< T > [inline]
setFlagSign(const bool value)CCPU< T > [inline]
setFlagZero(const bool value)CCPU< T > [inline]
setMemory(CMem< T > *memory)CCPU< T > [inline]
setProgram(const CProgram< T > *program)CCPU< T > [inline]
~CCPU()CCPU< T > [inline]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCCPU.html b/ue4/doxygen/classCCPU.html new file mode 100644 index 0000000..b4698e0 --- /dev/null +++ b/ue4/doxygen/classCCPU.html @@ -0,0 +1,632 @@ + + +mycpu: CCPU< T > Class Template Reference + + + + +
+ +
+
+ +
+

CCPU< T > Class Template Reference

#include <ccpu.h> +

+ +

+List of all members. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 CCPU (const unsigned cnt, T &datatype)
 Default ctor.
 ~CCPU ()
 Default dtor.
const unsigned getRegisterCount () const
 get number of registers
std::vector< T > & getRegisters ()
 get reference to registers vector
void setMemory (CMem< T > *memory)
 set memory of cpu
CMem< T > * getMemory () const
 get pointer to memory
void setProgram (const CProgram< T > *program)
 set program to execute
const CProgram< T > * getProgram ()
 get pointer to program
const std::set
+< CDisplay< T > * > & 		getDisplays ()
 get set of pointers to displays
void setFlagZero (const bool value)
 set zero flag
const bool getFlagZero ()
 get value of zero flag
void setFlagSign (const bool value)
 set sign flag
const bool getFlagSign ()
 get value of sign flag
void run ()
 execute current program
+

Detailed Description

+

template<class T>
+ class CCPU< T >

+ +CPU implementation. Used as a container for memory and instructions. Implements a run method to execute the program (= the instructions).

Constructor & Destructor Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + + + + + + + + + + +
CCPU< T >::CCPU (const unsigned  cnt,
T &  datatype 
) [inline]
+
+
+ +

+Default ctor. +

+

Methodname:
CCPU
+
Parameters:
+ + + +
cnt number of registers to allocate for this cpu
datatype reference instance of datatype to copy from
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
CCPU< T >::~CCPU (  )  [inline]
+
+
+ +

+Default dtor. +

+

Methodname:
~CCPU
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
const unsigned CCPU< T >::getRegisterCount (  )  const [inline]
+
+
+ +

+get number of registers +

+

Methodname:
getRegisterCount
+
Parameters:
+ + +
- 
+
+
Returns:
number of registers
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
std::vector<T>& CCPU< T >::getRegisters (  )  [inline]
+
+
+ +

+get reference to registers vector +

+

Methodname:
getRegisters
+
Parameters:
+ + +
- 
+
+
Returns:
reference to registers vector
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CCPU< T >::setMemory (CMem< T > *  memory  )  [inline]
+
+
+ +

+set memory of cpu +

+

Methodname:
setMemory
+
Parameters:
+ + +
memory pointer to memory
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
CMem<T>* CCPU< T >::getMemory (  )  const [inline]
+
+
+ +

+get pointer to memory +

+

Methodname:
getMemory
+
Parameters:
+ + +
- 
+
+
Returns:
pointer to memory
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CCPU< T >::setProgram (const CProgram< T > *  program  )  [inline]
+
+
+ +

+set program to execute +

+

Methodname:
setProgram
+
Parameters:
+ + +
program pointer to program
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
const CProgram<T>* CCPU< T >::getProgram (  )  [inline]
+
+
+ +

+get pointer to program +

+

Methodname:
getProgram
+
Parameters:
+ + +
- 
+
+
Returns:
pointer to program
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
const std::set<CDisplay<T> *>& CCPU< T >::getDisplays (  )  [inline]
+
+
+ +

+get set of pointers to displays +

+

Methodname:
getDisplays
+
Parameters:
+ + +
- 
+
+
Returns:
reference to set of pointers to displays
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CCPU< T >::setFlagZero (const bool  value  )  [inline]
+
+
+ +

+set zero flag +

+

Methodname:
setFlagZero
+
Parameters:
+ + +
value new value of zero flag
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
const bool CCPU< T >::getFlagZero (  )  [inline]
+
+
+ +

+get value of zero flag +

+

Methodname:
getFlagZero
+
Parameters:
+ + +
- 
+
+
Returns:
value of zero flag
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CCPU< T >::setFlagSign (const bool  value  )  [inline]
+
+
+ +

+set sign flag +

+

Methodname:
setFlagSign
+
Parameters:
+ + +
value new value of sign flag
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
const bool CCPU< T >::getFlagSign (  )  [inline]
+
+
+ +

+get value of sign flag +

+

Methodname:
getFlagSign
+
Parameters:
+ + +
- 
+
+
Returns:
value of sign flag
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
void CCPU< T >::run (  )  [inline]
+
+
+ +

+execute current program +

+

Methodname:
run
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CCPUError 
+
+
Precondition:
m_memory and m_program still exist
+
Postcondition:
none
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCCPUError-members.html b/ue4/doxygen/classCCPUError-members.html new file mode 100644 index 0000000..7af9a2f --- /dev/null +++ b/ue4/doxygen/classCCPUError-members.html @@ -0,0 +1,28 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CCPUError Member List

This is the complete list of members for CCPUError, including all inherited members.

+ +
CCPUError(const std::string &what)CCPUError [inline]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCCPUError.html b/ue4/doxygen/classCCPUError.html new file mode 100644 index 0000000..caea779 --- /dev/null +++ b/ue4/doxygen/classCCPUError.html @@ -0,0 +1,78 @@ + + +mycpu: CCPUError Class Reference + + + + +
+ +
+
+ +
+

CCPUError Class Reference

#include <ccpu.h> +

+ +

+List of all members. + + + + + +

Public Member Functions

 CCPUError (const std::string &what)
 Default exception ctor.
+

Detailed Description

+Exception thrown by implemententations of CCPU

Constructor & Destructor Documentation

+ +
+
+ + + + + + + + + +
CCPUError::CCPUError (const std::string &  what  )  [inline]
+
+
+ +

+Default exception ctor. +

+

Methodname:
CCPUError
+
Parameters:
+ + +
what message to pass along
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDat-members.html b/ue4/doxygen/classCDat-members.html new file mode 100644 index 0000000..0701a18 --- /dev/null +++ b/ue4/doxygen/classCDat-members.html @@ -0,0 +1,48 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CDat< T > Member List

This is the complete list of members for CDat< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + +
CDat()CDat< T > [inline]
CDat(const CDat &other)CDat< T > [inline]
CDat(const T newval)CDat< T > [inline]
getValue() const CDat< T > [inline]
m_valueCDat< T > [protected]
operator &=(const CDat &x)CDat< T > [inline]
operator *=(const CDat &x)CDat< T > [inline]
operator T()CDat< T > [inline]
operator%=(const CDat &x)CDat< T > [inline]
operator++()CDat< T > [inline]
operator+=(const CDat &x)CDat< T > [inline]
operator--()CDat< T > [inline]
operator-=(const CDat &x)CDat< T > [inline]
operator/=(const CDat &x)CDat< T > [inline]
operator<(const CDat &x) const CDat< T > [inline]
operator<<(std::ostream &stream, CDat cdat)CDat< T > [friend]
operator==(const CDat &x) const CDat< T > [inline]
operator>>(std::istream &stream, CDat &cdat)CDat< T > [friend]
operator^=(const CDat &x)CDat< T > [inline]
operator|=(const CDat &x)CDat< T > [inline]
~CDat()CDat< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDat.html b/ue4/doxygen/classCDat.html new file mode 100644 index 0000000..40c2ba4 --- /dev/null +++ b/ue4/doxygen/classCDat.html @@ -0,0 +1,919 @@ + + +mycpu: CDat< T > Class Template Reference + + + + +
+ +
+
+ +
+

CDat< T > Class Template Reference

#include <cdat.h> +

+ +

+List of all members. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 CDat ()
 Default ctor.
virtual ~CDat ()
 Default dtor.
 CDat (const CDat &other)
 Copy constructor for CDat.
 CDat (const T newval)
 Copy constructor for T.
T getValue () const
 returns value of CDat
 operator T ()
 convert to T
bool operator< (const CDat &x) const
 implementation of operator <
bool operator== (const CDat &x) const
 implementation of operator ==
CDat & operator+= (const CDat &x)
 implementation of operator +=
CDat & operator-= (const CDat &x)
 implementation of operator -=
CDat & operator *= (const CDat &x)
 implementation of operator *=
CDat & operator/= (const CDat &x)
 implementation of operator /=
CDat & operator%= (const CDat &x)
 implementation of operator %=
CDat & operator|= (const CDat &x)
 implementation of operator |=
CDat & operator &= (const CDat &x)
 implementation of operator &=
CDat & operator^= (const CDat &x)
 implementation of operator ^=
CDat & operator++ ()
 implementation of operator ++
CDat & operator-- ()
 implementation of operator --

Protected Attributes

T m_value

Friends

std::ostream & operator<< (std::ostream &stream, CDat cdat)
 Shift/output operator for outputstream.
std::istream & operator>> (std::istream &stream, CDat &cdat)
 Shift/read operator for inputstream.
+

Detailed Description

+

template<class T>
+ class CDat< T >

+ +Datatype template for CCPU and CMem.

Constructor & Destructor Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CDat< T >::CDat (  )  [inline]
+
+
+ +

+Default ctor. +

+

Methodname:
CDat
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
bad_alloc 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
virtual CDat< T >::~CDat (  )  [inline, virtual]
+
+
+ +

+Default dtor. +

+

Methodname:
~CDat
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat< T >::CDat (const CDat< T > &  other  )  [inline]
+
+
+ +

+Copy constructor for CDat. +

+

Methodname:
CDat
+
Parameters:
+ + +
other reference to CDat which will be copied
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat< T >::CDat (const T  newval  )  [inline]
+
+
+ +

+Copy constructor for T. +

+

Methodname:
CDat
+
Parameters:
+ + +
newval new value for CDat
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
T CDat< T >::getValue (  )  const [inline]
+
+
+ +

+returns value of CDat +

+

Methodname:
getValue
+
Parameters:
+ + +
- 
+
+
Returns:
value of CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
CDat< T >::operator T (  )  [inline]
+
+
+ +

+convert to T +

+

Methodname:
operator T
+
Parameters:
+ + +
- 
+
+
Returns:
T
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
bool CDat< T >::operator< (const CDat< T > &  x  )  const [inline]
+
+
+ +

+implementation of operator < +

+

Methodname:
operator<
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
true if cdat is less than object x
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
bool CDat< T >::operator== (const CDat< T > &  x  )  const [inline]
+
+
+ +

+implementation of operator == +

+

Methodname:
operator==
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
true if cdat equals object x
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator+= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator += +

+

Methodname:
operator+=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator-= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator -= +

+

Methodname:
operator-=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator *= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator *= +

+

Methodname:
operator*=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator/= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator /= +

+

Methodname:
operator/=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator%= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator %= +

+

Methodname:
operator%=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator|= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator |= +

+

Methodname:
operator|=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator &= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator &= +

+

Methodname:
operator&=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
CDat& CDat< T >::operator^= (const CDat< T > &  x  )  [inline]
+
+
+ +

+implementation of operator ^= +

+

Methodname:
operator^=
+
Parameters:
+ + +
x reference to CDat
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
CDat& CDat< T >::operator++ (  )  [inline]
+
+
+ +

+implementation of operator ++ +

+

Methodname:
operator++
+
Parameters:
+ + +
- 
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
CDat& CDat< T >::operator-- (  )  [inline]
+
+
+ +

+implementation of operator -- +

+

Methodname:
operator--
+
Parameters:
+ + +
- 
+
+
Returns:
refecence to CDat
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Friends And Related Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + + + + + + + + + + +
std::ostream& operator<< (std::ostream &  stream,
CDat< T >  cdat 
) [friend]
+
+
+ +

+Shift/output operator for outputstream. +

+

Methodname:
operator<<
+
Parameters:
+ + + +
stream reference to outputstream
cdat object which will be printed to stream
+
+
Returns:
reference to outputstream
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + + + + + + + + + + +
std::istream& operator>> (std::istream &  stream,
CDat< T > &  cdat 
) [friend]
+
+
+ +

+Shift/read operator for inputstream. +

+

Methodname:
operator>>
+
Parameters:
+ + + +
stream reference to inputstream
cdat reference to object which will be read from stream
+
+
Returns:
reference to inputstream
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
T CDat< T >::m_value [protected]
+
+
+ +

+internal value of datatype +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDatN-members.html b/ue4/doxygen/classCDatN-members.html new file mode 100644 index 0000000..9c29029 --- /dev/null +++ b/ue4/doxygen/classCDatN-members.html @@ -0,0 +1,49 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CDatN Member List

This is the complete list of members for CDatN, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + +
CDatN(const CDatN &other)CDatN [inline]
CDatN(const int newval, unsigned width=31)CDatN [inline]
getValue() const CDatN [inline]
m_valueCDatN [protected]
m_widthCDatN [protected]
operator &=(const CDatN &x)CDatN [inline]
operator *=(const CDatN &x)CDatN [inline]
operator int()CDatN [inline]
operator%=(const CDatN &x)CDatN [inline]
operator++()CDatN [inline]
operator+=(const CDatN &x)CDatN [inline]
operator--()CDatN [inline]
operator-=(const CDatN &x)CDatN [inline]
operator/=(const CDatN &x)CDatN [inline]
operator<(const CDatN &x) const CDatN [inline]
operator<<(std::ostream &stream, CDatN cdat)CDatN [friend]
operator=(const int &newval)CDatN [inline]
operator==(const CDatN &x) const CDatN [inline]
operator>>(std::istream &stream, CDatN &cdat)CDatN [friend]
operator^=(const CDatN &x)CDatN [inline]
operator|=(const CDatN &x)CDatN [inline]
~CDatN()CDatN [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDatN.html b/ue4/doxygen/classCDatN.html new file mode 100644 index 0000000..334a66a --- /dev/null +++ b/ue4/doxygen/classCDatN.html @@ -0,0 +1,902 @@ + + +mycpu: CDatN Class Reference + + + + +
+ +
+
+ +
+

CDatN Class Reference

#include <cdatn.h> +

+ +

+List of all members. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

virtual ~CDatN ()
 Default dtor.
 CDatN (const CDatN &other)
 Copy constructor for CDatN.
 CDatN (const int newval, unsigned width=31)
 Copy constructor for int.
int getValue () const
 returns value of CDatN
 operator int ()
 convert to int
bool operator< (const CDatN &x) const
 implementation of operator <
bool operator== (const CDatN &x) const
 implementation of operator ==
CDatN & operator= (const int &newval)
 implementation of operator =
CDatN & operator+= (const CDatN &x)
 implementation of operator +=
CDatN & operator-= (const CDatN &x)
 implementation of operator -=
CDatN & operator *= (const CDatN &x)
 implementation of operator *=
CDatN & operator/= (const CDatN &x)
 implementation of operator /=
CDatN & operator%= (const CDatN &x)
 implementation of operator %=
CDatN & operator|= (const CDatN &x)
 implementation of operator |=
CDatN & operator &= (const CDatN &x)
 implementation of operator &=
CDatN & operator^= (const CDatN &x)
 implementation of operator ^=
CDatN & operator++ ()
 implementation of operator ++
CDatN & operator-- ()
 implementation of operator --

Protected Attributes

int m_value
unsigned m_width

Friends

std::ostream & operator<< (std::ostream &stream, CDatN cdat)
 Shift/output operator for outputstream.
std::istream & operator>> (std::istream &stream, CDatN &cdat)
 Shift/read operator for inputstream.
+

Detailed Description

+Datatype template for CCPU and CMem.

Constructor & Destructor Documentation

+ +
+
+ + + + + + + + +
virtual CDatN::~CDatN (  )  [inline, virtual]
+
+
+ +

+Default dtor. +

+

Methodname:
~CDatN
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN::CDatN (const CDatN &  other  )  [inline]
+
+
+ +

+Copy constructor for CDatN. +

+

Methodname:
CDatN
+
Parameters:
+ + +
other reference to CDatN which will be copied
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + + + + + + + + + + +
CDatN::CDatN (const int  newval,
unsigned  width = 31 
) [inline]
+
+
+ +

+Copy constructor for int. +

+

Methodname:
CDatN
+
Parameters:
+ + + +
newval new value for CDatN
width maximum width
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
std::runtime_error 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Function Documentation

+ +
+
+ + + + + + + + +
int CDatN::getValue (  )  const [inline]
+
+
+ +

+returns value of CDatN +

+

Methodname:
getValue
+
Parameters:
+ + +
- 
+
+
Returns:
value of CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + +
CDatN::operator int (  )  [inline]
+
+
+ +

+convert to int +

+

Methodname:
operator int
+
Parameters:
+ + +
- 
+
+
Returns:
int
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
bool CDatN::operator< (const CDatN &  x  )  const [inline]
+
+
+ +

+implementation of operator < +

+

Methodname:
operator<
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
true if cdat is less than object x
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
bool CDatN::operator== (const CDatN &  x  )  const [inline]
+
+
+ +

+implementation of operator == +

+

Methodname:
operator==
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
true if cdat equals object x
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator= (const int &  newval  )  [inline]
+
+
+ +

+implementation of operator = +

+

Methodname:
operator=
+
Parameters:
+ + +
newval reference to int
+
+
Returns:
refecence to int
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator+= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator += +

+

Methodname:
operator+=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator-= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator -= +

+

Methodname:
operator-=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator *= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator *= +

+

Methodname:
operator*=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator/= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator /= +

+

Methodname:
operator/=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator%= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator %= +

+

Methodname:
operator%=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator|= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator |= +

+

Methodname:
operator|=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator &= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator &= +

+

Methodname:
operator&=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatN& CDatN::operator^= (const CDatN &  x  )  [inline]
+
+
+ +

+implementation of operator ^= +

+

Methodname:
operator^=
+
Parameters:
+ + +
x reference to CDatN
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + +
CDatN& CDatN::operator++ (  )  [inline]
+
+
+ +

+implementation of operator ++ +

+

Methodname:
operator++
+
Parameters:
+ + +
- 
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + +
CDatN& CDatN::operator-- (  )  [inline]
+
+
+ +

+implementation of operator -- +

+

Methodname:
operator--
+
Parameters:
+ + +
- 
+
+
Returns:
refecence to CDatN
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Friends And Related Function Documentation

+ +
+
+ + + + + + + + + + + + + + + + + + +
std::ostream& operator<< (std::ostream &  stream,
CDatN  cdat 
) [friend]
+
+
+ +

+Shift/output operator for outputstream. +

+

Methodname:
operator<<
+
Parameters:
+ + + +
stream reference to outputstream
cdat object which will be printed to stream
+
+
Returns:
reference to outputstream
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + + + + + + + + + + +
std::istream& operator>> (std::istream &  stream,
CDatN &  cdat 
) [friend]
+
+
+ +

+Shift/read operator for inputstream. +

+

Methodname:
operator>>
+
Parameters:
+ + + +
stream reference to inputstream
cdat reference to object which will be read from stream
+
+
Returns:
reference to inputstream
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Data Documentation

+ +
+
+ + + + +
int CDatN::m_value [protected]
+
+
+ +

+internal value of datatype +

+

+ +

+
+ + + + +
unsigned CDatN::m_width [protected]
+
+
+ +

+width of datatype +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDatSet-members.html b/ue4/doxygen/classCDatSet-members.html new file mode 100644 index 0000000..3c8e77a --- /dev/null +++ b/ue4/doxygen/classCDatSet-members.html @@ -0,0 +1,51 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CDatSet Member List

This is the complete list of members for CDatSet, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + +
CDat()CDat< int > [inline]
CDat(const CDat &other)CDat< int > [inline]
CDat(const intnewval)CDat< int > [inline]
CDatSet()CDatSet [inline]
CDatSet(const int newval)CDatSet [inline]
getValue() const CDat< int > [inline]
m_valueCDat< int > [protected]
operator &=(const CDat &x)CDat< int > [inline]
operator *=(const CDat &x)CDat< int > [inline]
operator int()CDat< int > [inline]
operator%=(const CDat &x)CDat< int > [inline]
operator++()CDat< int > [inline]
operator+=(const CDat &x)CDat< int > [inline]
operator--()CDat< int > [inline]
operator-=(const CDat &x)CDat< int > [inline]
operator/=(const CDat &x)CDat< int > [inline]
operator<(const CDat &x) const CDat< int > [inline]
operator<<(std::ostream &stream, CDat cdat)CDat< int > [friend]
operator==(const CDat &x) const CDat< int > [inline]
operator>>(std::istream &stream, CDatSet &cdat)CDatSet [friend]
CDat< int >::operator>>(std::istream &stream, CDat &cdat)CDat< int > [friend]
operator^=(const CDat &x)CDat< int > [inline]
operator|=(const CDat &x)CDat< int > [inline]
~CDat()CDat< int > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDatSet.html b/ue4/doxygen/classCDatSet.html new file mode 100644 index 0000000..6b9a173 --- /dev/null +++ b/ue4/doxygen/classCDatSet.html @@ -0,0 +1,178 @@ + + +mycpu: CDatSet Class Reference + + + + +
+ +
+
+ +
+

CDatSet Class Reference

#include <cdatset.h> +

+

+Inheritance diagram for CDatSet:
+
+ +

+ +CDat< int > + +
+ +

+List of all members. + + + + + + + + + + + + +

Public Member Functions

 CDatSet ()
 Default ctor.
 CDatSet (const int newval)
 Copy constructor for int.

Friends

std::istream & operator>> (std::istream &stream, CDatSet &cdat)
 Shift/read operator for inputstream.
+

Detailed Description

+Datatype template for CCPU and CMem.

Constructor & Destructor Documentation

+ +
+
+ + + + + + + + +
CDatSet::CDatSet (  )  [inline]
+
+
+ +

+Default ctor. +

+

Methodname:
CDatSet
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
bad_alloc 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+ + + + + + + + + +
CDatSet::CDatSet (const int  newval  )  [inline]
+
+
+ +

+Copy constructor for int. +

+

Methodname:
CDatSet
+
Parameters:
+ + +
newval new value for CDatSet
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Friends And Related Function Documentation

+ +
+
+ + + + + + + + + + + + + + + + + + +
std::istream& operator>> (std::istream &  stream,
CDatSet &  cdat 
) [friend]
+
+
+ +

+Shift/read operator for inputstream. +

+

Methodname:
operator>>
+
Parameters:
+ + + +
stream reference to inputstream
cdat reference to object which will be read from stream
+
+
Returns:
reference to inputstream
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
stream != null
+
Postcondition:
cdat.m_value = count of char 'o'
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDatSet.png b/ue4/doxygen/classCDatSet.png new file mode 100644 index 0000000..0e26cac Binary files /dev/null and b/ue4/doxygen/classCDatSet.png differ diff --git a/ue4/doxygen/classCDisplay-members.html b/ue4/doxygen/classCDisplay-members.html new file mode 100644 index 0000000..79cde49 --- /dev/null +++ b/ue4/doxygen/classCDisplay-members.html @@ -0,0 +1,32 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CDisplay< T > Member List

This is the complete list of members for CDisplay< T >, including all inherited members.

+ + + + + +
CDisplay(std::string name)CDisplay< T > [inline]
display(const T &value)=0CDisplay< T > [pure virtual]
getName()CDisplay< T > [inline, virtual]
m_nameCDisplay< T > [protected]
~CDisplay()CDisplay< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDisplay.html b/ue4/doxygen/classCDisplay.html new file mode 100644 index 0000000..ffa56d0 --- /dev/null +++ b/ue4/doxygen/classCDisplay.html @@ -0,0 +1,242 @@ + + +mycpu: CDisplay< T > Class Template Reference + + + + +
+ +
+
+ +
+

CDisplay< T > Class Template Reference

#include <cdisplay.h> +

+

+Inheritance diagram for CDisplay< T >:
+
+ +

+ +CDisplayWDEZ< T > +CDisplayWHEX< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + + +

Public Member Functions

 CDisplay (std::string name)
 Default ctor.
virtual ~CDisplay ()
 Default dtor.
virtual const
+std::string & 		getName ()
 returns name of display
virtual void display (const T &value)=0
 prints value to display

Protected Attributes

std::string m_name
+

Detailed Description

+

template<class T>
+ class CDisplay< T >

+ +Abstract template class for displays

Constructor & Destructor Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + +
CDisplay< T >::CDisplay (std::string  name  )  [inline]
+
+
+ +

+Default ctor. +

+

Methodname:
CDisplay
+
Parameters:
+ + +
name name of display
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
virtual CDisplay< T >::~CDisplay (  )  [inline, virtual]
+
+
+ +

+Default dtor. +

+

Methodname:
~CDisplay
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
virtual const std::string& CDisplay< T >::getName (  )  [inline, virtual]
+
+
+ +

+returns name of display +

+

Methodname:
getName
+
Parameters:
+ + +
- 
+
+
Returns:
name of display
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
virtual void CDisplay< T >::display (const T &  value  )  [pure virtual]
+
+
+ +

+prints value to display +

+

Methodname:
display
+
Parameters:
+ + +
value value to display
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implemented in CDisplayWDEZ< T >, and CDisplayWHEX< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
std::string CDisplay< T >::m_name [protected]
+
+
+ +

+name of display +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDisplay.png b/ue4/doxygen/classCDisplay.png new file mode 100644 index 0000000..17d9a2b Binary files /dev/null and b/ue4/doxygen/classCDisplay.png differ diff --git a/ue4/doxygen/classCDisplayWDEZ-members.html b/ue4/doxygen/classCDisplayWDEZ-members.html new file mode 100644 index 0000000..d677a09 --- /dev/null +++ b/ue4/doxygen/classCDisplayWDEZ-members.html @@ -0,0 +1,33 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CDisplayWDEZ< T > Member List

This is the complete list of members for CDisplayWDEZ< T >, including all inherited members.

+ + + + + + +
CDisplay(std::string name)CDisplay< T > [inline]
CDisplayWDEZ() (defined in CDisplayWDEZ< T >)CDisplayWDEZ< T > [inline]
display(const T &value)CDisplayWDEZ< T > [inline, virtual]
getName()CDisplay< T > [inline, virtual]
m_nameCDisplay< T > [protected]
~CDisplay()CDisplay< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDisplayWDEZ.html b/ue4/doxygen/classCDisplayWDEZ.html new file mode 100644 index 0000000..224a3eb --- /dev/null +++ b/ue4/doxygen/classCDisplayWDEZ.html @@ -0,0 +1,94 @@ + + +mycpu: CDisplayWDEZ< T > Class Template Reference + + + + +
+ +
+
+ +
+

CDisplayWDEZ< T > Class Template Reference

#include <displays.h> +

+

+Inheritance diagram for CDisplayWDEZ< T >:
+
+ +

+ +CDisplay< T > + +
+ +

+List of all members. + + + + + +

Public Member Functions

void display (const T &value)
 prints value to display
+

Detailed Description

+

template<class T>
+ class CDisplayWDEZ< T >

+ +Implementation of CDisplay Prints T to stdout as decimal

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + +
void CDisplayWDEZ< T >::display (const T &  value  )  [inline, virtual]
+
+
+ +

+prints value to display +

+

Methodname:
display
+
Parameters:
+ + +
value value to display
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CDisplay< T >.

+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDisplayWDEZ.png b/ue4/doxygen/classCDisplayWDEZ.png new file mode 100644 index 0000000..7a1d4fd Binary files /dev/null and b/ue4/doxygen/classCDisplayWDEZ.png differ diff --git a/ue4/doxygen/classCDisplayWHEX-members.html b/ue4/doxygen/classCDisplayWHEX-members.html new file mode 100644 index 0000000..51bc3ec --- /dev/null +++ b/ue4/doxygen/classCDisplayWHEX-members.html @@ -0,0 +1,33 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CDisplayWHEX< T > Member List

This is the complete list of members for CDisplayWHEX< T >, including all inherited members.

+ + + + + + +
CDisplay(std::string name)CDisplay< T > [inline]
CDisplayWHEX() (defined in CDisplayWHEX< T >)CDisplayWHEX< T > [inline]
display(const T &value)CDisplayWHEX< T > [inline, virtual]
getName()CDisplay< T > [inline, virtual]
m_nameCDisplay< T > [protected]
~CDisplay()CDisplay< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDisplayWHEX.html b/ue4/doxygen/classCDisplayWHEX.html new file mode 100644 index 0000000..2aa8f8d --- /dev/null +++ b/ue4/doxygen/classCDisplayWHEX.html @@ -0,0 +1,94 @@ + + +mycpu: CDisplayWHEX< T > Class Template Reference + + + + +
+ +
+
+ +
+

CDisplayWHEX< T > Class Template Reference

#include <displays.h> +

+

+Inheritance diagram for CDisplayWHEX< T >:
+
+ +

+ +CDisplay< T > + +
+ +

+List of all members. + + + + + +

Public Member Functions

void display (const T &value)
 prints value to display
+

Detailed Description

+

template<class T>
+ class CDisplayWHEX< T >

+ +Implementation of CDisplay Prints T to stdout as decimal

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + +
void CDisplayWHEX< T >::display (const T &  value  )  [inline, virtual]
+
+
+ +

+prints value to display +

+

Methodname:
display
+
Parameters:
+ + +
value value to display
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CDisplay< T >.

+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCDisplayWHEX.png b/ue4/doxygen/classCDisplayWHEX.png new file mode 100644 index 0000000..280ad62 Binary files /dev/null and b/ue4/doxygen/classCDisplayWHEX.png differ diff --git a/ue4/doxygen/classCInstruction-members.html b/ue4/doxygen/classCInstruction-members.html new file mode 100644 index 0000000..61ffc30 --- /dev/null +++ b/ue4/doxygen/classCInstruction-members.html @@ -0,0 +1,40 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstruction< T > Member List

This is the complete list of members for CInstruction< T >, including all inherited members.

+ + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
compile(std::list< std::string > &params)=0CInstruction< T > [pure virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)=0CInstruction< T > [pure virtual]
factory()=0CInstruction< T > [pure virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstruction.html b/ue4/doxygen/classCInstruction.html new file mode 100644 index 0000000..2cb1e9b --- /dev/null +++ b/ue4/doxygen/classCInstruction.html @@ -0,0 +1,615 @@ + + +mycpu: CInstruction< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstruction< T > Class Template Reference

#include <cinstruction.h> +

+

+Inheritance diagram for CInstruction< T >:
+
+ +

+ +CInstructionAdd< T > +CInstructionDec< T > +CInstructionDiv< T > +CInstructionInc< T > +CInstructionJumpA< T > +CInstructionJumpS< T > +CInstructionJumpZ< T > +CInstructionLabel< T > +CInstructionLoad< T > +CInstructionMul< T > +CInstructionStore< T > +CInstructionSub< T > +CInstructionTest< T > +CInstructionWrite< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 CInstruction (std::string name)
 Default ctor.
virtual ~CInstruction ()
 Default dtor.
virtual bool operator== (std::string &name)
 implementation of operator ==
virtual CInstruction & operator() (CCPU< T > *cpu)
 implementation of operator (CCPU)
virtual const
+std::string & 		getName ()
 returns instruction name
virtual std::ostream & dump (std::ostream &stream)
 dumps information about instruction to outputstream
virtual const unsigned parseRegister (const std::string &str)
 parses register syntax Rx (e.g. "R1")
virtual void checkRegister (CCPU< T > *cpu, const unsigned regidx)
 performs a register boundary check does the register exist in cpu?
virtual CInstruction * factory ()=0
 creates a new instance of this instruction
virtual void compile (std::list< std::string > &params)=0
 parses instruction parameters and prepares the instruction for executing
virtual void execute (CCPU< T > *cpu)=0
 executes the instruction

Protected Attributes

std::string m_name

Friends

std::ostream & operator<< (std::ostream &stream, CInstruction &instr)
 Shift/output operator for outputstream.
+

Detailed Description

+

template<class T>
+ class CInstruction< T >

+ +Abstract class for instructions

Constructor & Destructor Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + +
CInstruction< T >::CInstruction (std::string  name  )  [inline]
+
+
+ +

+Default ctor. +

+

Methodname:
CInstruction
+
Parameters:
+ + +
name name of instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
virtual CInstruction< T >::~CInstruction (  )  [inline, virtual]
+
+
+ +

+Default dtor. +

+

Methodname:
~CInstruction
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + +
virtual bool CInstruction< T >::operator== (std::string &  name  )  [inline, virtual]
+
+
+ +

+implementation of operator == +

+

Methodname:
operator==
+
Parameters:
+ + +
name reference to std::string
+
+
Returns:
true if instructionname is name
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
virtual CInstruction& CInstruction< T >::operator() (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+implementation of operator (CCPU) +

+

Methodname:
operator()
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
virtual const std::string& CInstruction< T >::getName (  )  [inline, virtual]
+
+
+ +

+returns instruction name +

+

Methodname:
getName
+
Parameters:
+ + +
- 
+
+
Returns:
name of instruction
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
virtual std::ostream& CInstruction< T >::dump (std::ostream &  stream  )  [inline, virtual]
+
+
+ +

+dumps information about instruction to outputstream +

+

Methodname:
dump
+
Parameters:
+ + +
stream outputstream
+
+
Returns:
reference to outputstream
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
const unsigned CInstruction< T >::parseRegister (const std::string &  str  )  [inline, virtual]
+
+
+ +

+parses register syntax Rx (e.g. "R1") +

+

Methodname:
parseRegister
+
Parameters:
+ + +
str register in assembler syntax
+
+
Returns:
registernumber
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
str != NULL
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + + + + + + + + + + +
void CInstruction< T >::checkRegister (CCPU< T > *  cpu,
const unsigned  regidx 
) [inline, virtual]
+
+
+ +

+performs a register boundary check does the register exist in cpu? +

+

Methodname:
checkRegister
+
Parameters:
+ + + +
cpu pointer to cpu
regidx registernumber
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
virtual CInstruction* CInstruction< T >::factory (  )  [pure virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implemented in CInstructionInc< T >, CInstructionDec< T >, CInstructionAdd< T >, CInstructionSub< T >, CInstructionMul< T >, CInstructionDiv< T >, CInstructionLoad< T >, CInstructionStore< T >, CInstructionTest< T >, CInstructionLabel< T >, CInstructionJumpA< T >, CInstructionJumpZ< T >, CInstructionJumpS< T >, and CInstructionWrite< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
virtual void CInstruction< T >::compile (std::list< std::string > &  params  )  [pure virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implemented in CInstructionInc< T >, CInstructionDec< T >, CInstructionAdd< T >, CInstructionSub< T >, CInstructionMul< T >, CInstructionDiv< T >, CInstructionLoad< T >, CInstructionStore< T >, CInstructionTest< T >, CInstructionLabel< T >, CInstructionJumpA< T >, CInstructionJumpZ< T >, CInstructionJumpS< T >, and CInstructionWrite< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
virtual void CInstruction< T >::execute (CCPU< T > *  cpu  )  [pure virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implemented in CInstructionInc< T >, CInstructionDec< T >, CInstructionAdd< T >, CInstructionSub< T >, CInstructionMul< T >, CInstructionDiv< T >, CInstructionLoad< T >, CInstructionStore< T >, CInstructionTest< T >, CInstructionLabel< T >, CInstructionJumpA< T >, CInstructionJumpZ< T >, CInstructionJumpS< T >, and CInstructionWrite< T >.

+ +
+

+

Friends And Related Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + + + + + + + + + + +
std::ostream& operator<< (std::ostream &  stream,
CInstruction< T > &  instr 
) [friend]
+
+
+ +

+Shift/output operator for outputstream. +

+

Methodname:
operator<<
+
Parameters:
+ + + +
stream reference to outputstream
instr object which will be printed to stream
+
+
Returns:
reference to outputstream
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
std::string CInstruction< T >::m_name [protected]
+
+
+ +

+name of instruction +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstruction.png b/ue4/doxygen/classCInstruction.png new file mode 100644 index 0000000..f47a842 Binary files /dev/null and b/ue4/doxygen/classCInstruction.png differ diff --git a/ue4/doxygen/classCInstructionAdd-members.html b/ue4/doxygen/classCInstructionAdd-members.html new file mode 100644 index 0000000..99a9ee9 --- /dev/null +++ b/ue4/doxygen/classCInstructionAdd-members.html @@ -0,0 +1,44 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionAdd< T > Member List

This is the complete list of members for CInstructionAdd< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionAdd() (defined in CInstructionAdd< T >)CInstructionAdd< T > [inline]
compile(std::list< std::string > &params)CInstructionAdd< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionAdd< T > [inline, virtual]
factory()CInstructionAdd< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionAdd< T > [protected]
m_regidx2CInstructionAdd< T > [protected]
m_regidx3CInstructionAdd< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionAdd.html b/ue4/doxygen/classCInstructionAdd.html new file mode 100644 index 0000000..67a5c69 --- /dev/null +++ b/ue4/doxygen/classCInstructionAdd.html @@ -0,0 +1,240 @@ + + +mycpu: CInstructionAdd< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionAdd< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionAdd< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + + + +

Public Member Functions

CInstructionAdd * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
unsigned m_regidx2
unsigned m_regidx3
+

Detailed Description

+

template<class T>
+ class CInstructionAdd< T >

+ +Implementation of assembler command "add" Syntax: add R1, R2, R3 (R1 = R2 + R3)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionAdd* CInstructionAdd< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionAdd< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionAdd< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionAdd< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionAdd< T >::m_regidx2 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionAdd< T >::m_regidx3 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionAdd.png b/ue4/doxygen/classCInstructionAdd.png new file mode 100644 index 0000000..443426e Binary files /dev/null and b/ue4/doxygen/classCInstructionAdd.png differ diff --git a/ue4/doxygen/classCInstructionDec-members.html b/ue4/doxygen/classCInstructionDec-members.html new file mode 100644 index 0000000..e57d5b0 --- /dev/null +++ b/ue4/doxygen/classCInstructionDec-members.html @@ -0,0 +1,42 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionDec< T > Member List

This is the complete list of members for CInstructionDec< T >, including all inherited members.

+ + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionDec() (defined in CInstructionDec< T >)CInstructionDec< T > [inline]
compile(std::list< std::string > &params)CInstructionDec< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionDec< T > [inline, virtual]
factory()CInstructionDec< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionDec< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionDec.html b/ue4/doxygen/classCInstructionDec.html new file mode 100644 index 0000000..c71be03 --- /dev/null +++ b/ue4/doxygen/classCInstructionDec.html @@ -0,0 +1,202 @@ + + +mycpu: CInstructionDec< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionDec< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionDec< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + +

Public Member Functions

CInstructionDec * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
+

Detailed Description

+

template<class T>
+ class CInstructionDec< T >

+ +Implementation of assembler command "dec" Syntax: dec R1 (R1--)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionDec* CInstructionDec< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionDec< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionDec< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionDec< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionDec.png b/ue4/doxygen/classCInstructionDec.png new file mode 100644 index 0000000..ce3b414 Binary files /dev/null and b/ue4/doxygen/classCInstructionDec.png differ diff --git a/ue4/doxygen/classCInstructionDiv-members.html b/ue4/doxygen/classCInstructionDiv-members.html new file mode 100644 index 0000000..34c03f5 --- /dev/null +++ b/ue4/doxygen/classCInstructionDiv-members.html @@ -0,0 +1,44 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionDiv< T > Member List

This is the complete list of members for CInstructionDiv< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionDiv() (defined in CInstructionDiv< T >)CInstructionDiv< T > [inline]
compile(std::list< std::string > &params)CInstructionDiv< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionDiv< T > [inline, virtual]
factory()CInstructionDiv< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionDiv< T > [protected]
m_regidx2CInstructionDiv< T > [protected]
m_regidx3CInstructionDiv< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionDiv.html b/ue4/doxygen/classCInstructionDiv.html new file mode 100644 index 0000000..b255489 --- /dev/null +++ b/ue4/doxygen/classCInstructionDiv.html @@ -0,0 +1,240 @@ + + +mycpu: CInstructionDiv< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionDiv< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionDiv< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + + + +

Public Member Functions

CInstructionDiv * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
unsigned m_regidx2
unsigned m_regidx3
+

Detailed Description

+

template<class T>
+ class CInstructionDiv< T >

+ +Implementation of assembler command "div" Syntax: div R1, R2, R3 (R1 = R2 / R3)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionDiv* CInstructionDiv< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionDiv< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionDiv< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionDiv< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionDiv< T >::m_regidx2 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionDiv< T >::m_regidx3 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionDiv.png b/ue4/doxygen/classCInstructionDiv.png new file mode 100644 index 0000000..3e88473 Binary files /dev/null and b/ue4/doxygen/classCInstructionDiv.png differ diff --git a/ue4/doxygen/classCInstructionError-members.html b/ue4/doxygen/classCInstructionError-members.html new file mode 100644 index 0000000..d15841c --- /dev/null +++ b/ue4/doxygen/classCInstructionError-members.html @@ -0,0 +1,28 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionError Member List

This is the complete list of members for CInstructionError, including all inherited members.

+ +
CInstructionError(const std::string &what)CInstructionError [inline]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionError.html b/ue4/doxygen/classCInstructionError.html new file mode 100644 index 0000000..e6cd98c --- /dev/null +++ b/ue4/doxygen/classCInstructionError.html @@ -0,0 +1,78 @@ + + +mycpu: CInstructionError Class Reference + + + + +
+ +
+
+ +
+

CInstructionError Class Reference

#include <cinstruction.h> +

+ +

+List of all members. + + + + + +

Public Member Functions

 CInstructionError (const std::string &what)
 Default exception ctor.
+

Detailed Description

+Exception thrown by implemententations of CInstruction

Constructor & Destructor Documentation

+ +
+
+ + + + + + + + + +
CInstructionError::CInstructionError (const std::string &  what  )  [inline]
+
+
+ +

+Default exception ctor. +

+

Methodname:
CInstructionError
+
Parameters:
+ + +
what message to pass along
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionInc-members.html b/ue4/doxygen/classCInstructionInc-members.html new file mode 100644 index 0000000..1a63cf6 --- /dev/null +++ b/ue4/doxygen/classCInstructionInc-members.html @@ -0,0 +1,42 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionInc< T > Member List

This is the complete list of members for CInstructionInc< T >, including all inherited members.

+ + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionInc() (defined in CInstructionInc< T >)CInstructionInc< T > [inline]
compile(std::list< std::string > &params)CInstructionInc< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionInc< T > [inline, virtual]
factory()CInstructionInc< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionInc< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionInc.html b/ue4/doxygen/classCInstructionInc.html new file mode 100644 index 0000000..2a2ef58 --- /dev/null +++ b/ue4/doxygen/classCInstructionInc.html @@ -0,0 +1,202 @@ + + +mycpu: CInstructionInc< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionInc< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionInc< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + +

Public Member Functions

CInstructionInc * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
+

Detailed Description

+

template<class T>
+ class CInstructionInc< T >

+ +Implementation of assembler command "inc" Syntax: inc R1 (R1++)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionInc* CInstructionInc< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionInc< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionInc< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionInc< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionInc.png b/ue4/doxygen/classCInstructionInc.png new file mode 100644 index 0000000..a6ce5c2 Binary files /dev/null and b/ue4/doxygen/classCInstructionInc.png differ diff --git a/ue4/doxygen/classCInstructionJumpA-members.html b/ue4/doxygen/classCInstructionJumpA-members.html new file mode 100644 index 0000000..1851b31 --- /dev/null +++ b/ue4/doxygen/classCInstructionJumpA-members.html @@ -0,0 +1,42 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionJumpA< T > Member List

This is the complete list of members for CInstructionJumpA< T >, including all inherited members.

+ + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionJumpA() (defined in CInstructionJumpA< T >)CInstructionJumpA< T > [inline]
compile(std::list< std::string > &params)CInstructionJumpA< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionJumpA< T > [inline, virtual]
factory()CInstructionJumpA< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_addrCInstructionJumpA< T > [protected]
m_nameCInstruction< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionJumpA.html b/ue4/doxygen/classCInstructionJumpA.html new file mode 100644 index 0000000..67200fd --- /dev/null +++ b/ue4/doxygen/classCInstructionJumpA.html @@ -0,0 +1,202 @@ + + +mycpu: CInstructionJumpA< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionJumpA< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionJumpA< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + +

Public Member Functions

CInstructionJumpA * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

std::string m_addr
+

Detailed Description

+

template<class T>
+ class CInstructionJumpA< T >

+ +Implementation of assembler command "jumpa" Syntax: jumpa labelname (jump to labelname)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionJumpA* CInstructionJumpA< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionJumpA< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionJumpA< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
std::string CInstructionJumpA< T >::m_addr [protected]
+
+
+ +

+labelname +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionJumpA.png b/ue4/doxygen/classCInstructionJumpA.png new file mode 100644 index 0000000..634e836 Binary files /dev/null and b/ue4/doxygen/classCInstructionJumpA.png differ diff --git a/ue4/doxygen/classCInstructionJumpS-members.html b/ue4/doxygen/classCInstructionJumpS-members.html new file mode 100644 index 0000000..c79f32a --- /dev/null +++ b/ue4/doxygen/classCInstructionJumpS-members.html @@ -0,0 +1,42 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionJumpS< T > Member List

This is the complete list of members for CInstructionJumpS< T >, including all inherited members.

+ + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionJumpS() (defined in CInstructionJumpS< T >)CInstructionJumpS< T > [inline]
compile(std::list< std::string > &params)CInstructionJumpS< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionJumpS< T > [inline, virtual]
factory()CInstructionJumpS< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_addrCInstructionJumpS< T > [protected]
m_nameCInstruction< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionJumpS.html b/ue4/doxygen/classCInstructionJumpS.html new file mode 100644 index 0000000..2ae6444 --- /dev/null +++ b/ue4/doxygen/classCInstructionJumpS.html @@ -0,0 +1,202 @@ + + +mycpu: CInstructionJumpS< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionJumpS< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionJumpS< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + +

Public Member Functions

CInstructionJumpS * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

std::string m_addr
+

Detailed Description

+

template<class T>
+ class CInstructionJumpS< T >

+ +Implementation of assembler command "jumps" Syntax: jumps labelname (jump to labelname if signflag)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionJumpS* CInstructionJumpS< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionJumpS< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionJumpS< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
std::string CInstructionJumpS< T >::m_addr [protected]
+
+
+ +

+labelname +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionJumpS.png b/ue4/doxygen/classCInstructionJumpS.png new file mode 100644 index 0000000..a622211 Binary files /dev/null and b/ue4/doxygen/classCInstructionJumpS.png differ diff --git a/ue4/doxygen/classCInstructionJumpZ-members.html b/ue4/doxygen/classCInstructionJumpZ-members.html new file mode 100644 index 0000000..c54c76f --- /dev/null +++ b/ue4/doxygen/classCInstructionJumpZ-members.html @@ -0,0 +1,42 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionJumpZ< T > Member List

This is the complete list of members for CInstructionJumpZ< T >, including all inherited members.

+ + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionJumpZ() (defined in CInstructionJumpZ< T >)CInstructionJumpZ< T > [inline]
compile(std::list< std::string > &params)CInstructionJumpZ< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionJumpZ< T > [inline, virtual]
factory()CInstructionJumpZ< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_addrCInstructionJumpZ< T > [protected]
m_nameCInstruction< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionJumpZ.html b/ue4/doxygen/classCInstructionJumpZ.html new file mode 100644 index 0000000..81709c7 --- /dev/null +++ b/ue4/doxygen/classCInstructionJumpZ.html @@ -0,0 +1,202 @@ + + +mycpu: CInstructionJumpZ< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionJumpZ< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionJumpZ< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + +

Public Member Functions

CInstructionJumpZ * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

std::string m_addr
+

Detailed Description

+

template<class T>
+ class CInstructionJumpZ< T >

+ +Implementation of assembler command "jumpz" Syntax: jumpz labelname (jump to labelname if zeroflag)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionJumpZ* CInstructionJumpZ< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionJumpZ< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionJumpZ< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
std::string CInstructionJumpZ< T >::m_addr [protected]
+
+
+ +

+labelname +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionJumpZ.png b/ue4/doxygen/classCInstructionJumpZ.png new file mode 100644 index 0000000..3e84956 Binary files /dev/null and b/ue4/doxygen/classCInstructionJumpZ.png differ diff --git a/ue4/doxygen/classCInstructionLabel-members.html b/ue4/doxygen/classCInstructionLabel-members.html new file mode 100644 index 0000000..52734d4 --- /dev/null +++ b/ue4/doxygen/classCInstructionLabel-members.html @@ -0,0 +1,41 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionLabel< T > Member List

This is the complete list of members for CInstructionLabel< T >, including all inherited members.

+ + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionLabel() (defined in CInstructionLabel< T >)CInstructionLabel< T > [inline]
compile(std::list< std::string > &params)CInstructionLabel< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionLabel< T > [inline, virtual]
factory()CInstructionLabel< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionLabel.html b/ue4/doxygen/classCInstructionLabel.html new file mode 100644 index 0000000..89117ad --- /dev/null +++ b/ue4/doxygen/classCInstructionLabel.html @@ -0,0 +1,181 @@ + + +mycpu: CInstructionLabel< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionLabel< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionLabel< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + +

Public Member Functions

CInstructionLabel * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction
+

Detailed Description

+

template<class T>
+ class CInstructionLabel< T >

+ +Implementation of assembler command "label" Syntax: label name:

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionLabel* CInstructionLabel< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionLabel< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionLabel< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionLabel.png b/ue4/doxygen/classCInstructionLabel.png new file mode 100644 index 0000000..37b9795 Binary files /dev/null and b/ue4/doxygen/classCInstructionLabel.png differ diff --git a/ue4/doxygen/classCInstructionLoad-members.html b/ue4/doxygen/classCInstructionLoad-members.html new file mode 100644 index 0000000..60cbaf4 --- /dev/null +++ b/ue4/doxygen/classCInstructionLoad-members.html @@ -0,0 +1,43 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionLoad< T > Member List

This is the complete list of members for CInstructionLoad< T >, including all inherited members.

+ + + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionLoad() (defined in CInstructionLoad< T >)CInstructionLoad< T > [inline]
compile(std::list< std::string > &params)CInstructionLoad< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionLoad< T > [inline, virtual]
factory()CInstructionLoad< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionLoad< T > [protected]
m_regidx2CInstructionLoad< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionLoad.html b/ue4/doxygen/classCInstructionLoad.html new file mode 100644 index 0000000..97063df --- /dev/null +++ b/ue4/doxygen/classCInstructionLoad.html @@ -0,0 +1,221 @@ + + +mycpu: CInstructionLoad< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionLoad< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionLoad< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + +

Public Member Functions

CInstructionLoad * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
unsigned m_regidx2
+

Detailed Description

+

template<class T>
+ class CInstructionLoad< T >

+ +Implementation of assembler command "load" Syntax: load R1, R2 (R1 = memory[R2])

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionLoad* CInstructionLoad< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionLoad< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionLoad< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionLoad< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionLoad< T >::m_regidx2 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionLoad.png b/ue4/doxygen/classCInstructionLoad.png new file mode 100644 index 0000000..61ea62b Binary files /dev/null and b/ue4/doxygen/classCInstructionLoad.png differ diff --git a/ue4/doxygen/classCInstructionMul-members.html b/ue4/doxygen/classCInstructionMul-members.html new file mode 100644 index 0000000..c718b07 --- /dev/null +++ b/ue4/doxygen/classCInstructionMul-members.html @@ -0,0 +1,44 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionMul< T > Member List

This is the complete list of members for CInstructionMul< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionMul() (defined in CInstructionMul< T >)CInstructionMul< T > [inline]
compile(std::list< std::string > &params)CInstructionMul< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionMul< T > [inline, virtual]
factory()CInstructionMul< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionMul< T > [protected]
m_regidx2CInstructionMul< T > [protected]
m_regidx3CInstructionMul< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionMul.html b/ue4/doxygen/classCInstructionMul.html new file mode 100644 index 0000000..8328e66 --- /dev/null +++ b/ue4/doxygen/classCInstructionMul.html @@ -0,0 +1,240 @@ + + +mycpu: CInstructionMul< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionMul< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionMul< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + + + +

Public Member Functions

CInstructionMul * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
unsigned m_regidx2
unsigned m_regidx3
+

Detailed Description

+

template<class T>
+ class CInstructionMul< T >

+ +Implementation of assembler command "mul" Syntax: mul R1, R2, R3 (R1 = R2 * R3)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionMul* CInstructionMul< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionMul< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionMul< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionMul< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionMul< T >::m_regidx2 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionMul< T >::m_regidx3 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionMul.png b/ue4/doxygen/classCInstructionMul.png new file mode 100644 index 0000000..1ad8e63 Binary files /dev/null and b/ue4/doxygen/classCInstructionMul.png differ diff --git a/ue4/doxygen/classCInstructionStore-members.html b/ue4/doxygen/classCInstructionStore-members.html new file mode 100644 index 0000000..2f5eab4 --- /dev/null +++ b/ue4/doxygen/classCInstructionStore-members.html @@ -0,0 +1,43 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionStore< T > Member List

This is the complete list of members for CInstructionStore< T >, including all inherited members.

+ + + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionStore() (defined in CInstructionStore< T >)CInstructionStore< T > [inline]
compile(std::list< std::string > &params)CInstructionStore< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionStore< T > [inline, virtual]
factory()CInstructionStore< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionStore< T > [protected]
m_regidx2CInstructionStore< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionStore.html b/ue4/doxygen/classCInstructionStore.html new file mode 100644 index 0000000..df61199 --- /dev/null +++ b/ue4/doxygen/classCInstructionStore.html @@ -0,0 +1,221 @@ + + +mycpu: CInstructionStore< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionStore< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionStore< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + +

Public Member Functions

CInstructionStore * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
unsigned m_regidx2
+

Detailed Description

+

template<class T>
+ class CInstructionStore< T >

+ +Implementation of assembler command "store" Syntax: store R1, R2 (memory[R2] = R1)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionStore* CInstructionStore< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionStore< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionStore< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionStore< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionStore< T >::m_regidx2 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionStore.png b/ue4/doxygen/classCInstructionStore.png new file mode 100644 index 0000000..be22c0e Binary files /dev/null and b/ue4/doxygen/classCInstructionStore.png differ diff --git a/ue4/doxygen/classCInstructionSub-members.html b/ue4/doxygen/classCInstructionSub-members.html new file mode 100644 index 0000000..ed7e8a8 --- /dev/null +++ b/ue4/doxygen/classCInstructionSub-members.html @@ -0,0 +1,44 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionSub< T > Member List

This is the complete list of members for CInstructionSub< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionSub() (defined in CInstructionSub< T >)CInstructionSub< T > [inline]
compile(std::list< std::string > &params)CInstructionSub< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionSub< T > [inline, virtual]
factory()CInstructionSub< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionSub< T > [protected]
m_regidx2CInstructionSub< T > [protected]
m_regidx3CInstructionSub< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionSub.html b/ue4/doxygen/classCInstructionSub.html new file mode 100644 index 0000000..2200094 --- /dev/null +++ b/ue4/doxygen/classCInstructionSub.html @@ -0,0 +1,240 @@ + + +mycpu: CInstructionSub< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionSub< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionSub< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + + + +

Public Member Functions

CInstructionSub * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
unsigned m_regidx2
unsigned m_regidx3
+

Detailed Description

+

template<class T>
+ class CInstructionSub< T >

+ +Implementation of assembler command "sub" Syntax: sub R1, R2, R3 (R1 = R2 - R3)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionSub* CInstructionSub< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionSub< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionSub< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionSub< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionSub< T >::m_regidx2 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
unsigned CInstructionSub< T >::m_regidx3 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionSub.png b/ue4/doxygen/classCInstructionSub.png new file mode 100644 index 0000000..7d8f242 Binary files /dev/null and b/ue4/doxygen/classCInstructionSub.png differ diff --git a/ue4/doxygen/classCInstructionTest-members.html b/ue4/doxygen/classCInstructionTest-members.html new file mode 100644 index 0000000..c3fa759 --- /dev/null +++ b/ue4/doxygen/classCInstructionTest-members.html @@ -0,0 +1,42 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionTest< T > Member List

This is the complete list of members for CInstructionTest< T >, including all inherited members.

+ + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionTest() (defined in CInstructionTest< T >)CInstructionTest< T > [inline]
compile(std::list< std::string > &params)CInstructionTest< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionTest< T > [inline, virtual]
factory()CInstructionTest< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionTest< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionTest.html b/ue4/doxygen/classCInstructionTest.html new file mode 100644 index 0000000..f89aa8b --- /dev/null +++ b/ue4/doxygen/classCInstructionTest.html @@ -0,0 +1,202 @@ + + +mycpu: CInstructionTest< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionTest< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionTest< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + +

Public Member Functions

CInstructionTest * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
+

Detailed Description

+

template<class T>
+ class CInstructionTest< T >

+ +Implementation of assembler command "test" Syntax: test R1 (R1 == 0: zeroflag: true, R1 < 0: signflag: true)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionTest* CInstructionTest< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionTest< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionTest< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionTest< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionTest.png b/ue4/doxygen/classCInstructionTest.png new file mode 100644 index 0000000..61f9c9a Binary files /dev/null and b/ue4/doxygen/classCInstructionTest.png differ diff --git a/ue4/doxygen/classCInstructionWrite-members.html b/ue4/doxygen/classCInstructionWrite-members.html new file mode 100644 index 0000000..8b7767a --- /dev/null +++ b/ue4/doxygen/classCInstructionWrite-members.html @@ -0,0 +1,43 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CInstructionWrite< T > Member List

This is the complete list of members for CInstructionWrite< T >, including all inherited members.

+ + + + + + + + + + + + + + + + +
checkRegister(CCPU< T > *cpu, const unsigned regidx)CInstruction< T > [inline, virtual]
CInstruction(std::string name)CInstruction< T > [inline]
CInstructionWrite() (defined in CInstructionWrite< T >)CInstructionWrite< T > [inline]
compile(std::list< std::string > &params)CInstructionWrite< T > [inline, virtual]
dump(std::ostream &stream)CInstruction< T > [inline, virtual]
execute(CCPU< T > *cpu)CInstructionWrite< T > [inline, virtual]
factory()CInstructionWrite< T > [inline, virtual]
getName()CInstruction< T > [inline, virtual]
m_devCInstructionWrite< T > [protected]
m_nameCInstruction< T > [protected]
m_regidx1CInstructionWrite< T > [protected]
operator()(CCPU< T > *cpu)CInstruction< T > [inline, virtual]
operator<<(std::ostream &stream, CInstruction &instr)CInstruction< T > [friend]
operator==(std::string &name)CInstruction< T > [inline, virtual]
parseRegister(const std::string &str)CInstruction< T > [inline, virtual]
~CInstruction()CInstruction< T > [inline, virtual]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionWrite.html b/ue4/doxygen/classCInstructionWrite.html new file mode 100644 index 0000000..3a8c5c2 --- /dev/null +++ b/ue4/doxygen/classCInstructionWrite.html @@ -0,0 +1,221 @@ + + +mycpu: CInstructionWrite< T > Class Template Reference + + + + +
+ +
+
+ +
+

CInstructionWrite< T > Class Template Reference

#include <instructions.h> +

+

+Inheritance diagram for CInstructionWrite< T >:
+
+ +

+ +CInstruction< T > + +
+ +

+List of all members. + + + + + + + + + + + + + + + + +

Public Member Functions

CInstructionWrite * factory ()
 creates a new instance of this instruction
void compile (std::list< std::string > &params)
 parses instruction parameters and prepares the instruction for executing
void execute (CCPU< T > *cpu)
 executes the instruction

Protected Attributes

unsigned m_regidx1
std::string m_dev
+

Detailed Description

+

template<class T>
+ class CInstructionWrite< T >

+ +Implementation of assembler command "write" Syntax: write DEV, R1 (write R1 to DEV, which is a name of a display)

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CInstructionWrite* CInstructionWrite< T >::factory (  )  [inline, virtual]
+
+
+ +

+creates a new instance of this instruction +

+

Methodname:
factory
+
Parameters:
+ + +
- 
+
+
Returns:
new instruction instance
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionWrite< T >::compile (std::list< std::string > &  params  )  [inline, virtual]
+
+
+ +

+parses instruction parameters and prepares the instruction for executing +

+

Methodname:
compile
+
Parameters:
+ + +
params list of parameters of this instruction
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
none
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CInstructionWrite< T >::execute (CCPU< T > *  cpu  )  [inline, virtual]
+
+
+ +

+executes the instruction +

+

Methodname:
execute
+
Parameters:
+ + +
cpu pointer to cpu
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
CInstructionError 
+
+
Precondition:
cpu valid (memory, program, registers valid)
+
Postcondition:
none
+ +

Implements CInstruction< T >.

+ +
+

+

Member Data Documentation

+ +
+
+
+template<class T>
+ + + + +
unsigned CInstructionWrite< T >::m_regidx1 [protected]
+
+
+ +

+register number +

+

+ +

+
+
+template<class T>
+ + + + +
std::string CInstructionWrite< T >::m_dev [protected]
+
+
+ +

+device name +

+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCInstructionWrite.png b/ue4/doxygen/classCInstructionWrite.png new file mode 100644 index 0000000..f848e9c Binary files /dev/null and b/ue4/doxygen/classCInstructionWrite.png differ diff --git a/ue4/doxygen/classCMem-members.html b/ue4/doxygen/classCMem-members.html new file mode 100644 index 0000000..1e5af08 --- /dev/null +++ b/ue4/doxygen/classCMem-members.html @@ -0,0 +1,28 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CMem< T > Member List

This is the complete list of members for CMem< T >, including all inherited members.

+ +
initialize(std::istream &in, T &datatype)CMem< T > [inline]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCMem.html b/ue4/doxygen/classCMem.html new file mode 100644 index 0000000..84c8913 --- /dev/null +++ b/ue4/doxygen/classCMem.html @@ -0,0 +1,93 @@ + + +mycpu: CMem< T > Class Template Reference + + + + +
+ +
+
+ +
+

CMem< T > Class Template Reference

#include <cmem.h> +

+ +

+List of all members. + + + + + +

Public Member Functions

void initialize (std::istream &in, T &datatype)
 initialize the vector with the content of istream. istream is read per line. empty lines will add unitialized elements.
+

Detailed Description

+

template<class T>
+ class CMem< T >

+ +Extends std::vector template for use as memory for CCPU.

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + + + + + + + + + + + +
void CMem< T >::initialize (std::istream &  in,
T &  datatype 
) [inline]
+
+
+ +

+initialize the vector with the content of istream. istream is read per line. empty lines will add unitialized elements. +

+

Methodname:
initialize
+
Parameters:
+ + + +
in inputstream to read from
datatype reference instance of datatype to copy from
+
+
Returns:
void
+
Global variables used:
none
+
Exceptions:
+ + +
CMemError 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCMemError-members.html b/ue4/doxygen/classCMemError-members.html new file mode 100644 index 0000000..0a163fc --- /dev/null +++ b/ue4/doxygen/classCMemError-members.html @@ -0,0 +1,28 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CMemError Member List

This is the complete list of members for CMemError, including all inherited members.

+ +
CMemError(const std::string &what)CMemError [inline]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCMemError.html b/ue4/doxygen/classCMemError.html new file mode 100644 index 0000000..2522b9e --- /dev/null +++ b/ue4/doxygen/classCMemError.html @@ -0,0 +1,78 @@ + + +mycpu: CMemError Class Reference + + + + +
+ +
+
+ +
+

CMemError Class Reference

#include <cmem.h> +

+ +

+List of all members. + + + + + +

Public Member Functions

 CMemError (const std::string &what)
 Default exception ctor.
+

Detailed Description

+Exception thrown by implemententations of CMem

Constructor & Destructor Documentation

+ +
+
+ + + + + + + + + +
CMemError::CMemError (const std::string &  what  )  [inline]
+
+
+ +

+Default exception ctor. +

+

Methodname:
CMemError
+
Parameters:
+ + +
what message to pass along
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCProgram-members.html b/ue4/doxygen/classCProgram-members.html new file mode 100644 index 0000000..dcc8f8d --- /dev/null +++ b/ue4/doxygen/classCProgram-members.html @@ -0,0 +1,32 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CProgram< T > Member List

This is the complete list of members for CProgram< T >, including all inherited members.

+ + + + + +
compile(std::istream &in)CProgram< T > [inline]
CProgram()CProgram< T > [inline]
findLabel(const std::string &label) const CProgram< T > [inline]
getLabels() const CProgram< T > [inline]
~CProgram()CProgram< T > [inline]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCProgram.html b/ue4/doxygen/classCProgram.html new file mode 100644 index 0000000..4efe43a --- /dev/null +++ b/ue4/doxygen/classCProgram.html @@ -0,0 +1,251 @@ + + +mycpu: CProgram< T > Class Template Reference + + + + +
+ +
+
+ +
+

CProgram< T > Class Template Reference

#include <cprogram.h> +

+ +

+List of all members. + + + + + + + + + + + + + + + + + +

Public Member Functions

 CProgram ()
 Default ctor.
 ~CProgram ()
 Default dtor.
const std::map
+< std::string,
+ unsigned > & 		getLabels () const
 get reference to labels map
unsigned findLabel (const std::string &label) const
 search for label
void compile (std::istream &in)
 create instructions from parsing stream
+

Detailed Description

+

template<class T>
+ class CProgram< T >

+ +CProgram extends std::vector and adds a method for parsing programfile. This adds instances of CInstruction to CProgram itself.

Constructor & Destructor Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
CProgram< T >::CProgram (  )  [inline]
+
+
+ +

+Default ctor. +

+

Methodname:
CProgram
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + +
CProgram< T >::~CProgram (  )  [inline]
+
+
+ +

+Default dtor. +

+

Methodname:
~CProgram
+
Parameters:
+ + +
- 
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

Member Function Documentation

+ +
+
+
+template<class T>
+ + + + + + + + +
const std::map<std::string, unsigned>& CProgram< T >::getLabels (  )  const [inline]
+
+
+ +

+get reference to labels map +

+

Methodname:
getLabels
+
Parameters:
+ + +
- 
+
+
Returns:
reference to labels map
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
unsigned CProgram< T >::findLabel (const std::string &  label  )  const [inline]
+
+
+ +

+search for label +

+

Methodname:
findLabel
+
Parameters:
+ + +
label name of label to search for
+
+
Returns:
index of found label in program
+
Global variables used:
none
+
Exceptions:
+ + +
CProgramError 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+ +

+
+
+template<class T>
+ + + + + + + + + +
void CProgram< T >::compile (std::istream &  in  )  [inline]
+
+
+ +

+create instructions from parsing stream +

+

Methodname:
compile
+
Parameters:
+ + +
in inputstream to read from
+
+
Returns:
void
+
Global variables used:
none
+
Exceptions:
+ + +
CProgramError 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCProgramError-members.html b/ue4/doxygen/classCProgramError-members.html new file mode 100644 index 0000000..7839775 --- /dev/null +++ b/ue4/doxygen/classCProgramError-members.html @@ -0,0 +1,28 @@ + + +mycpu: Member List + + + + +
+ +
+
+ +
+

CProgramError Member List

This is the complete list of members for CProgramError, including all inherited members.

+ +
CProgramError(const std::string &what)CProgramError [inline]

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/classCProgramError.html b/ue4/doxygen/classCProgramError.html new file mode 100644 index 0000000..7f982b5 --- /dev/null +++ b/ue4/doxygen/classCProgramError.html @@ -0,0 +1,78 @@ + + +mycpu: CProgramError Class Reference + + + + +
+ +
+
+ +
+

CProgramError Class Reference

#include <cprogram.h> +

+ +

+List of all members. + + + + + +

Public Member Functions

 CProgramError (const std::string &what)
 Default exception ctor.
+

Detailed Description

+Exception thrown by implemententations of CProgram

Constructor & Destructor Documentation

+ +
+
+ + + + + + + + + +
CProgramError::CProgramError (const std::string &  what  )  [inline]
+
+
+ +

+Default exception ctor. +

+

Methodname:
CProgramError
+
Parameters:
+ + +
what message to pass along
+
+
Returns:
-
+
Global variables used:
none
+
Exceptions:
+ + +
none 
+
+
Precondition:
none
+
Postcondition:
none
+ +
+

+

The documentation for this class was generated from the following file: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/cmem_8h-source.html b/ue4/doxygen/cmem_8h-source.html new file mode 100644 index 0000000..d50894b --- /dev/null +++ b/ue4/doxygen/cmem_8h-source.html @@ -0,0 +1,104 @@ + + +mycpu: mycpu/cmem.h Source File + + + + +
+ +
+

mycpu/cmem.h

00001 
+00008 #ifndef CMEM_H
+00009 #define CMEM_H 1
+00010 
+00011 #include <vector>
+00012 #include <istream>
+00013 #include <sstream>
+00014 #include <stdexcept>
+00015 #ifdef DEBUG
+00016 # include <iostream>
+00017 # include <iomanip>
+00018 #endif
+00019 
+00025 class CMemError
+00026  : public std::invalid_argument
+00027 {
+00028   public:
+00039     CMemError(const std::string& what)
+00040       : std::invalid_argument(what)
+00041     {}
+00042 };
+00043 
+00049 template <class T>
+00050 class CMem
+00051   : public std::vector<T>
+00052 {
+00053   typedef std::vector<T> super;
+00054   typedef typename super::iterator iterator;
+00055   using super::size;
+00056   using super::begin;
+00057   using super::end;
+00058 
+00059   public:
+00072     void initialize(std::istream& in, T& datatype)
+00073     {
+00074       if (!in.good())
+00075         return;
+00076 
+00077       std::string line;
+00078       unsigned i = 0;
+00079       while (!in.eof() && in.good())
+00080       {
+00081         ++i;
+00082         std::getline(in, line);
+00083 
+00084         /* skip last line if it's empty */
+00085         if (line.empty() && in.eof())
+00086           break;
+00087 
+00088         T value(datatype);
+00089         if (!line.empty())
+00090         {
+00091           /* simple boost::lexical_cast replacement */
+00092           std::stringstream interpreter;
+00093           if(!(interpreter << line && interpreter >> value && interpreter.get() == std::char_traits<char>::eof()))
+00094           {
+00095             std::stringstream sstr;
+00096             sstr << "Unable to convert input (line " << i << ") to datatype";
+00097             throw CMemError(sstr.str());
+00098           }
+00099         }
+00100 
+00101         push_back(value);
+00102       }
+00103     }
+00104 
+00105 #if DEBUG
+00106 
+00116     void dump(std::ostream& out)
+00117     {
+00118       out << "[MEMORY DUMP]" << std::endl;
+00119       unsigned i = 0;
+00120       for(iterator it = begin(); it != end(); ++it)
+00121       {
+00122         out << "[" << std::setw(4) << std::setfill('0') << i << "]  "
+00123             << *it << std::endl;
+00124         ++i;
+00125       }
+00126     }
+00127 #endif
+00128 };
+00129 
+00130 #endif
+00131 
+00132 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/cprogram_8h-source.html b/ue4/doxygen/cprogram_8h-source.html new file mode 100644 index 0000000..610ba9a --- /dev/null +++ b/ue4/doxygen/cprogram_8h-source.html @@ -0,0 +1,237 @@ + + +mycpu: mycpu/cprogram.h Source File + + + + +
+ +
+

mycpu/cprogram.h

00001 
+00008 #ifndef CPROGRAM_H
+00009 #define CPROGRAM_H 1
+00010 
+00011 #include <vector>
+00012 #include <set>
+00013 #include <map>
+00014 #include <stdexcept>
+00015 #include <boost/algorithm/string.hpp>
+00016 #include <boost/algorithm/string/split.hpp>
+00017 #ifdef DEBUG
+00018 # include <iostream>
+00019 # include <iomanip>
+00020 #endif
+00021 
+00027 class CProgramError
+00028  : public std::invalid_argument
+00029 {
+00030   public:
+00041     CProgramError(const std::string& what)
+00042       : std::invalid_argument(what)
+00043     {}
+00044 };
+00045 
+00046 #include "cinstruction.h"
+00047 #include "instructions.h"
+00048 
+00049 /* forward declare CInstruction */
+00050 template <class T>
+00051 class CInstruction;
+00052 
+00059 template <class T>
+00060 class CProgram
+00061   : public std::vector<CInstruction<T> *>
+00062 {
+00063   typedef typename std::set<CInstruction<T> *>::iterator setiterator;
+00064   typedef std::vector<CInstruction<T> *> super;
+00065   typedef typename super::iterator iterator;
+00066   using super::begin;
+00067   using super::end;
+00068   using super::size;
+00069 
+00070   public:
+00081     CProgram();
+00082 
+00093     ~CProgram();
+00094 
+00105     const std::map<std::string, unsigned>& getLabels() const
+00106     {
+00107       return m_labels;
+00108     }
+00109 
+00120     unsigned findLabel(const std::string& label) const;
+00121 
+00132     void compile(std::istream& in);
+00133 
+00134 #if DEBUG
+00135 
+00145     void dump(std::ostream& out);
+00146 #endif
+00147 
+00148   private:
+00149     /* members */
+00151     std::set<CInstruction<T> *> m_instrset;
+00152     std::map<std::string, unsigned> m_labels;
+00153 };
+00154 
+00155 /*----------------------------------------------------------------------------*/
+00156 
+00157 template <class T>
+00158 CProgram<T>::CProgram()
+00159 {
+00160   m_instrset.insert(new CInstructionInc<T>);
+00161   m_instrset.insert(new CInstructionDec<T>);
+00162   m_instrset.insert(new CInstructionAdd<T>);
+00163   m_instrset.insert(new CInstructionSub<T>);
+00164   m_instrset.insert(new CInstructionMul<T>);
+00165   m_instrset.insert(new CInstructionDiv<T>);
+00166   m_instrset.insert(new CInstructionLoad<T>);
+00167   m_instrset.insert(new CInstructionStore<T>);
+00168   m_instrset.insert(new CInstructionTest<T>);
+00169   m_instrset.insert(new CInstructionLabel<T>);
+00170   m_instrset.insert(new CInstructionJumpA<T>);
+00171   m_instrset.insert(new CInstructionJumpZ<T>);
+00172   m_instrset.insert(new CInstructionJumpS<T>);
+00173   m_instrset.insert(new CInstructionWrite<T>);
+00174 }
+00175 
+00176 /*----------------------------------------------------------------------------*/
+00177 
+00178 template <class T>
+00179 CProgram<T>::~CProgram()
+00180 {
+00181   /* free instruction set */
+00182   for (setiterator it = m_instrset.begin(); it != m_instrset.end(); ++it)
+00183     delete *it;
+00184 
+00185   /* free instruction */
+00186   for (iterator it2 = begin(); it2 != end(); ++it2)
+00187     delete *it2;
+00188 }
+00189 
+00190 /*----------------------------------------------------------------------------*/
+00191 
+00192 template <class T>
+00193 void CProgram<T>::compile(std::istream& in)
+00194 {
+00195   if (!in.good())
+00196     return;
+00197 
+00198   std::string line;
+00199   unsigned i = 0;
+00200   while (!in.eof() && in.good())
+00201   {
+00202     ++i;
+00203 
+00204     /* read stream per line */
+00205     std::getline(in, line);
+00206     if (line.empty())
+00207       continue;
+00208 
+00209     boost::trim(line);
+00210     boost::to_lower(line);
+00211 
+00212     /* ignore comments */
+00213     if (line.find_first_of('#') == 0)
+00214       continue;
+00215 
+00216     /* get instruction name */
+00217     size_t pos = line.find_first_of(' ');
+00218     std::string instrname(line.substr(0, pos));
+00219 
+00220     /* search and create instruction */
+00221     CInstruction<T> *instrptr = NULL;
+00222     setiterator it;
+00223     for (it = m_instrset.begin(); it != m_instrset.end(); ++it)
+00224     {
+00225       if (*(*it) == instrname)
+00226       {
+00227         instrptr = *it;
+00228         break;
+00229       }
+00230     }
+00231     if (instrptr == NULL)
+00232     {
+00233       std::stringstream sstr;
+00234       sstr << "Unknown instruction '" << instrname << "' on line " << i << ".";
+00235       throw CProgramError(sstr.str());
+00236     }
+00237 
+00238     /* create instruction */
+00239     CInstruction<T> *instr = instrptr->factory();
+00240 
+00241     /* parse instruction parameters */
+00242     std::string params = (pos == std::string::npos) ? "" : line.substr(pos + 1);
+00243     boost::trim(params);
+00244     std::list<std::string> instrparams;
+00245     boost::split(instrparams, params, boost::is_any_of(", \t"), boost::token_compress_on);
+00246 
+00247     /* let instruction parse the parameters. catch+throw exception */
+00248     try
+00249     {
+00250       /* handle label instruction ourself, but still add a dummy instruction */
+00251       if (instrname == "label")
+00252       {
+00253         if (instrparams.size() != 1)
+00254           throw CInstructionError("Invalid paramater count - must be 1");
+00255         std::string label(instrparams.front());
+00256         if (label.length() < 2 || label[ label.length() - 1] != ':')
+00257           throw CInstructionError("Label has invalid syntax");
+00258         m_labels[ label.substr(0, label.length() - 1) ] = size();
+00259       }
+00260       instr->compile(instrparams);
+00261     }
+00262     catch(CInstructionError& ex)
+00263     {
+00264       std::stringstream sstr;
+00265       sstr << "Unable to compile instruction '" << instrname
+00266            << "' (line " << i << "): " << ex.what();
+00267       throw CProgramError(sstr.str());
+00268     }
+00269 
+00270     push_back(instr);
+00271   }
+00272 }
+00273 
+00274 /*----------------------------------------------------------------------------*/
+00275 
+00276 template <class T>
+00277 unsigned CProgram<T>::findLabel(const std::string& label) const
+00278 {
+00279   std::map<std::string, unsigned>::const_iterator it;
+00280   it = m_labels.find(label);
+00281   if (it == m_labels.end())
+00282     throw CProgramError("Unknown label '" + label + "'");
+00283   return it->second;
+00284 }
+00285 
+00286 /*----------------------------------------------------------------------------*/
+00287 
+00288 #if DEBUG
+00289 template <class T>
+00290 void CProgram<T>::dump(std::ostream& out)
+00291 {
+00292   out << "[PROGRAM DUMP]" << std::endl;
+00293   unsigned i = 0;
+00294   for(iterator it = begin(); it != end(); ++it)
+00295   {
+00296     out << "[" << std::setw(4) << std::setfill('0') << i << "]  "
+00297         << *(*it) << std::endl;
+00298     ++i;
+00299   }
+00300 }
+00301 #endif
+00302 
+00303 #endif
+00304 
+00305 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/displays_8h-source.html b/ue4/doxygen/displays_8h-source.html new file mode 100644 index 0000000..8e9f56f --- /dev/null +++ b/ue4/doxygen/displays_8h-source.html @@ -0,0 +1,61 @@ + + +mycpu: mycpu/displays.h Source File + + + + +
+ +
+

mycpu/displays.h

00001 
+00008 #ifndef DISPLAYS_H
+00009 #define DISPLAYS_H 1
+00010 
+00011 #include <iomanip>
+00012 #include "cdisplay.h"
+00013 
+00020 template <class T>
+00021 class CDisplayWDEZ
+00022   : public CDisplay<T>
+00023 {
+00024   public:
+00025     CDisplayWDEZ()
+00026       : CDisplay<T>("wdez")
+00027     {}
+00028 
+00039     void display(const T &value)
+00040     {
+00041       std::cout << std::dec << value << std::endl;
+00042     }
+00043 };
+00044 
+00045 /*============================================================================*/
+00046 
+00053 template <class T>
+00054 class CDisplayWHEX
+00055   : public CDisplay<T>
+00056 {
+00057   public:
+00058     CDisplayWHEX()
+00059       : CDisplay<T>("whex")
+00060     {}
+00061 
+00072     void display(const T &value)
+00073     {
+00074       std::cout << std::hex << value << std::endl;
+00075     }
+00076 };
+00077 
+00078 #endif
+00079 
+00080 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/doxygen.css b/ue4/doxygen/doxygen.css new file mode 100644 index 0000000..c7db1a8 --- /dev/null +++ b/ue4/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/ue4/doxygen/doxygen.png b/ue4/doxygen/doxygen.png new file mode 100644 index 0000000..f0a274b Binary files /dev/null and b/ue4/doxygen/doxygen.png differ diff --git a/ue4/doxygen/files.html b/ue4/doxygen/files.html new file mode 100644 index 0000000..ab29e73 --- /dev/null +++ b/ue4/doxygen/files.html @@ -0,0 +1,31 @@ + + +mycpu: File Index + + + + +
+ +
+

mycpu File List

Here is a list of all documented files with brief descriptions: + + + + + + + + + + +
mycpu/ccpu.h [code]
mycpu/cdat.h [code]
mycpu/cdatn.h [code]
mycpu/cdatset.h [code]
mycpu/cdisplay.h [code]
mycpu/cinstruction.h [code]
mycpu/cmem.h [code]
mycpu/cprogram.h [code]
mycpu/displays.h [code]
mycpu/instructions.h [code]
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/functions.html b/ue4/doxygen/functions.html new file mode 100644 index 0000000..23a1d2f --- /dev/null +++ b/ue4/doxygen/functions.html @@ -0,0 +1,297 @@ + + +mycpu: Class Members + + + + +
+ +
+
+ +
+
+ +
+
+ +
+ +

+Here is a list of all documented class members with links to the class documentation for each member: +

+

- c -

+

- d -

+

- e -

+

- f -

+

- g -

+

- i -

+

- m -

+

- o -

+

- p -

+

- r -

+

- s -

+

- ~ -

+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/functions_func.html b/ue4/doxygen/functions_func.html new file mode 100644 index 0000000..1becc4f --- /dev/null +++ b/ue4/doxygen/functions_func.html @@ -0,0 +1,249 @@ + + +mycpu: Class Members - Functions + + + + +
+ +
+
+ +
+
+ +
+
+ +
+ +

+  +

+

- c -

+

- d -

+

- e -

+

- f -

+

- g -

+

- i -

+

- o -

+

- p -

+

- r -

+

- s -

+

- ~ -

+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/functions_rela.html b/ue4/doxygen/functions_rela.html new file mode 100644 index 0000000..a917b8d --- /dev/null +++ b/ue4/doxygen/functions_rela.html @@ -0,0 +1,46 @@ + + +mycpu: Class Members - Related Functions + + + + +
+ +
+
+ +
+
+ +
+  +

+

+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/functions_vars.html b/ue4/doxygen/functions_vars.html new file mode 100644 index 0000000..e6dc3d5 --- /dev/null +++ b/ue4/doxygen/functions_vars.html @@ -0,0 +1,75 @@ + + +mycpu: Class Members - Variables + + + + +
+ +
+
+ +
+
+ +
+  +

+

+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/hierarchy.html b/ue4/doxygen/hierarchy.html new file mode 100644 index 0000000..e14a36e --- /dev/null +++ b/ue4/doxygen/hierarchy.html @@ -0,0 +1,65 @@ + + +mycpu: Hierarchical Index + + + + +
+ +
+
+ +
+

mycpu Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically: +
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/index.html b/ue4/doxygen/index.html new file mode 100644 index 0000000..6b04e84 --- /dev/null +++ b/ue4/doxygen/index.html @@ -0,0 +1,21 @@ + + +mycpu: Main Page + + + + +
+ +
+

mycpu Documentation

+

+

Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/instructions_8h-source.html b/ue4/doxygen/instructions_8h-source.html new file mode 100644 index 0000000..e92a004 --- /dev/null +++ b/ue4/doxygen/instructions_8h-source.html @@ -0,0 +1,752 @@ + + +mycpu: mycpu/instructions.h Source File + + + + +
+ +
+

mycpu/instructions.h

00001 
+00008 #ifndef INSTRUCTIONS_H
+00009 #define INSTRUCTIONS_H 1
+00010 
+00011 #include "cinstruction.h"
+00012 #include "ccpu.h"
+00013 #include "cprogram.h"
+00014 
+00022 template <class T>
+00023 class CInstructionInc
+00024   : public CInstruction<T>
+00025 {
+00026   typedef CInstruction<T> super;
+00027 
+00028   public:
+00029     CInstructionInc()
+00030       : CInstruction<T>("inc")
+00031     {}
+00032 
+00033     CInstructionInc *factory()
+00034     {
+00035       return new CInstructionInc;
+00036     }
+00037 
+00038     void compile(std::list<std::string>& params);
+00039     void execute(CCPU<T> *cpu);
+00040 
+00041   protected:
+00043     unsigned m_regidx1;
+00044 };
+00045 
+00046 /*----------------------------------------------------------------------------*/
+00047 
+00048 template <class T>
+00049 void CInstructionInc<T>::compile(std::list<std::string>& params)
+00050 {
+00051   if (params.size() != 1)
+00052     throw CInstructionError("Invalid paramater count - must be 1");
+00053   m_regidx1 = super::parseRegister(params.front());
+00054   params.pop_front();
+00055 }
+00056 
+00057 /*----------------------------------------------------------------------------*/
+00058 
+00059 template <class T>
+00060 void CInstructionInc<T>::execute(CCPU<T> *cpu)
+00061 {
+00062   assert(cpu != NULL);
+00063   super::checkRegister(cpu, m_regidx1);
+00064   cpu->getRegisters()[ m_regidx1 ]++;
+00065 }
+00066 
+00067 /*============================================================================*/
+00068 
+00076 template <class T>
+00077 class CInstructionDec
+00078  : public CInstruction<T>
+00079 {
+00080   typedef CInstruction<T> super;
+00081 
+00082   public:
+00083     CInstructionDec()
+00084       : CInstruction<T>("dec")
+00085     {}
+00086 
+00087     CInstructionDec *factory()
+00088     {
+00089       return new CInstructionDec;
+00090     }
+00091 
+00092     void compile(std::list<std::string>& params);
+00093     void execute(CCPU<T> *cpu);
+00094 
+00095   protected:
+00097     unsigned m_regidx1;
+00098 };
+00099 
+00100 /*----------------------------------------------------------------------------*/
+00101 
+00102 template <class T>
+00103 void CInstructionDec<T>::compile(std::list<std::string>& params)
+00104 {
+00105   if (params.size() != 1)
+00106     throw CInstructionError("Invalid paramater count - must be 1");
+00107   m_regidx1 = super::parseRegister(params.front());
+00108   params.pop_front();
+00109 }
+00110 
+00111 /*----------------------------------------------------------------------------*/
+00112 
+00113 template <class T>
+00114 void CInstructionDec<T>::execute(CCPU<T> *cpu)
+00115 {
+00116   assert(cpu != NULL);
+00117   super::checkRegister(cpu, m_regidx1);
+00118   cpu->getRegisters()[ m_regidx1 ]--;
+00119 }
+00120 
+00121 /*============================================================================*/
+00122 
+00130 template <class T>
+00131 class CInstructionAdd
+00132  : public CInstruction<T>
+00133 {
+00134   typedef CInstruction<T> super;
+00135 
+00136   public:
+00137     CInstructionAdd()
+00138       : CInstruction<T>("add")
+00139     {}
+00140 
+00141     CInstructionAdd *factory()
+00142     {
+00143       return new CInstructionAdd;
+00144     }
+00145 
+00146     void compile(std::list<std::string>& params);
+00147     void execute(CCPU<T> *cpu);
+00148 
+00149   protected:
+00151     unsigned m_regidx1;
+00153     unsigned m_regidx2;
+00155     unsigned m_regidx3;
+00156 };
+00157 
+00158 /*----------------------------------------------------------------------------*/
+00159 
+00160 template <class T>
+00161 void CInstructionAdd<T>::compile(std::list<std::string>& params)
+00162 {
+00163   if (params.size() != 3)
+00164     throw CInstructionError("Invalid paramater count - must be 3");
+00165   m_regidx1 = super::parseRegister(params.front());
+00166   params.pop_front();
+00167   m_regidx2 = super::parseRegister(params.front());
+00168   params.pop_front();
+00169   m_regidx3 = super::parseRegister(params.front());
+00170   params.pop_front();
+00171 }
+00172 
+00173 /*----------------------------------------------------------------------------*/
+00174 
+00175 template <class T>
+00176 void CInstructionAdd<T>::execute(CCPU<T> *cpu)
+00177 {
+00178   assert(cpu != NULL);
+00179   super::checkRegister(cpu, m_regidx1);
+00180   super::checkRegister(cpu, m_regidx2);
+00181   super::checkRegister(cpu, m_regidx3);
+00182   cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+00183     + cpu->getRegisters()[ m_regidx3 ];
+00184 }
+00185 
+00186 /*============================================================================*/
+00187 
+00195 template <class T>
+00196 class CInstructionSub
+00197  : public CInstruction<T>
+00198 {
+00199   typedef CInstruction<T> super;
+00200 
+00201   public:
+00202     CInstructionSub()
+00203       : CInstruction<T>("sub")
+00204     {}
+00205 
+00206     CInstructionSub *factory()
+00207     {
+00208       return new CInstructionSub;
+00209     }
+00210 
+00211     void compile(std::list<std::string>& params);
+00212     void execute(CCPU<T> *cpu);
+00213 
+00214   protected:
+00216     unsigned m_regidx1;
+00218     unsigned m_regidx2;
+00220     unsigned m_regidx3;
+00221 };
+00222 
+00223 /*----------------------------------------------------------------------------*/
+00224 
+00225 template <class T>
+00226 void CInstructionSub<T>::compile(std::list<std::string>& params)
+00227 {
+00228   if (params.size() != 3)
+00229     throw CInstructionError("Invalid paramater count - must be 3");
+00230   m_regidx1 = super::parseRegister(params.front());
+00231   params.pop_front();
+00232   m_regidx2 = super::parseRegister(params.front());
+00233   params.pop_front();
+00234   m_regidx3 = super::parseRegister(params.front());
+00235   params.pop_front();
+00236 }
+00237 
+00238 /*----------------------------------------------------------------------------*/
+00239 
+00240 template <class T>
+00241 void CInstructionSub<T>::execute(CCPU<T> *cpu)
+00242 {
+00243   assert(cpu != NULL);
+00244   super::checkRegister(cpu, m_regidx1);
+00245   super::checkRegister(cpu, m_regidx2);
+00246   super::checkRegister(cpu, m_regidx3);
+00247   cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+00248     - cpu->getRegisters()[ m_regidx3 ];
+00249 }
+00250 
+00251 /*============================================================================*/
+00252 
+00260 template <class T>
+00261 class CInstructionMul
+00262  : public CInstruction<T>
+00263 {
+00264   typedef CInstruction<T> super;
+00265 
+00266   public:
+00267     CInstructionMul()
+00268       : CInstruction<T>("mul")
+00269     {}
+00270 
+00271     CInstructionMul *factory()
+00272     {
+00273       return new CInstructionMul;
+00274     }
+00275 
+00276     void compile(std::list<std::string>& params);
+00277     void execute(CCPU<T> *cpu);
+00278 
+00279   protected:
+00281     unsigned m_regidx1;
+00283     unsigned m_regidx2;
+00285     unsigned m_regidx3;
+00286 };
+00287 
+00288 /*----------------------------------------------------------------------------*/
+00289 
+00290 template <class T>
+00291 void CInstructionMul<T>::compile(std::list<std::string>& params)
+00292 {
+00293   if (params.size() != 3)
+00294     throw CInstructionError("Invalid paramater count - must be 3");
+00295   m_regidx1 = super::parseRegister(params.front());
+00296   params.pop_front();
+00297   m_regidx2 = super::parseRegister(params.front());
+00298   params.pop_front();
+00299   m_regidx3 = super::parseRegister(params.front());
+00300   params.pop_front();
+00301 }
+00302 
+00303 /*----------------------------------------------------------------------------*/
+00304 
+00305 template <class T>
+00306 void CInstructionMul<T>::execute(CCPU<T> *cpu)
+00307 {
+00308   super::checkRegister(cpu, m_regidx1);
+00309   super::checkRegister(cpu, m_regidx2);
+00310   super::checkRegister(cpu, m_regidx3);
+00311   cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+00312     * cpu->getRegisters()[ m_regidx3 ];
+00313 }
+00314 
+00315 /*============================================================================*/
+00316 
+00324 template <class T>
+00325 class CInstructionDiv
+00326  : public CInstruction<T>
+00327 {
+00328   typedef CInstruction<T> super;
+00329 
+00330   public:
+00331     CInstructionDiv()
+00332       : CInstruction<T>("div")
+00333     {}
+00334 
+00335     CInstructionDiv *factory()
+00336     {
+00337       return new CInstructionDiv;
+00338     }
+00339 
+00340     void compile(std::list<std::string>& params);
+00341     void execute(CCPU<T> *cpu);
+00342 
+00343   protected:
+00345     unsigned m_regidx1;
+00347     unsigned m_regidx2;
+00349     unsigned m_regidx3;
+00350 };
+00351 
+00352 /*----------------------------------------------------------------------------*/
+00353 
+00354 template <class T>
+00355 void CInstructionDiv<T>::compile(std::list<std::string>& params)
+00356 {
+00357   if (params.size() != 3)
+00358     throw CInstructionError("Invalid paramater count - must be 3");
+00359   m_regidx1 = super::parseRegister(params.front());
+00360   params.pop_front();
+00361   m_regidx2 = super::parseRegister(params.front());
+00362   params.pop_front();
+00363   m_regidx3 = super::parseRegister(params.front());
+00364   params.pop_front();
+00365 }
+00366 
+00367 /*----------------------------------------------------------------------------*/
+00368 
+00369 template <class T>
+00370 void CInstructionDiv<T>::execute(CCPU<T> *cpu)
+00371 {
+00372   assert(cpu != NULL);
+00373   super::checkRegister(cpu, m_regidx1);
+00374   super::checkRegister(cpu, m_regidx2);
+00375   super::checkRegister(cpu, m_regidx3);
+00376   cpu->getRegisters()[ m_regidx1 ] = cpu->getRegisters()[ m_regidx2 ]
+00377     / cpu->getRegisters()[ m_regidx3 ];
+00378 }
+00379 
+00380 /*============================================================================*/
+00381 
+00389 template <class T>
+00390 class CInstructionLoad
+00391  : public CInstruction<T>
+00392 {
+00393   typedef CInstruction<T> super;
+00394 
+00395   public:
+00396     CInstructionLoad()
+00397       : CInstruction<T>("load")
+00398     {}
+00399 
+00400     CInstructionLoad *factory()
+00401     {
+00402       return new CInstructionLoad;
+00403     }
+00404 
+00405     void compile(std::list<std::string>& params);
+00406     void execute(CCPU<T> *cpu);
+00407 
+00408   protected:
+00410     unsigned m_regidx1;
+00412     unsigned m_regidx2;
+00413 };
+00414 
+00415 /*----------------------------------------------------------------------------*/
+00416 
+00417 template <class T>
+00418 void CInstructionLoad<T>::compile(std::list<std::string>& params)
+00419 {
+00420   if (params.size() != 2)
+00421     throw CInstructionError("Invalid paramater count - must be 2");
+00422   m_regidx1 = super::parseRegister(params.front());
+00423   params.pop_front();
+00424   m_regidx2 = super::parseRegister(params.front());
+00425   params.pop_front();
+00426 }
+00427 
+00428 /*----------------------------------------------------------------------------*/
+00429 
+00430 template <class T>
+00431 void CInstructionLoad<T>::execute(CCPU<T> *cpu)
+00432 {
+00433   assert(cpu != NULL);
+00434   assert(cpu->getMemory() != NULL);
+00435   super::checkRegister(cpu, m_regidx1);
+00436   super::checkRegister(cpu, m_regidx2);
+00437   T val(cpu->getRegisters()[ m_regidx2 ]);
+00438   cpu->getRegisters()[ m_regidx1 ] = (*cpu->getMemory())[ val ];
+00439 }
+00440 
+00441 /*============================================================================*/
+00442 
+00450 template <class T>
+00451 class CInstructionStore
+00452  : public CInstruction<T>
+00453 {
+00454   typedef CInstruction<T> super;
+00455 
+00456   public:
+00457     CInstructionStore()
+00458       : CInstruction<T>("store")
+00459     {}
+00460 
+00461     CInstructionStore *factory()
+00462     {
+00463       return new CInstructionStore;
+00464     }
+00465 
+00466     void compile(std::list<std::string>& params);
+00467     void execute(CCPU<T> *cpu);
+00468 
+00469   protected:
+00471     unsigned m_regidx1;
+00473     unsigned m_regidx2;
+00474 };
+00475 
+00476 /*----------------------------------------------------------------------------*/
+00477 
+00478 template <class T>
+00479 void CInstructionStore<T>::compile(std::list<std::string>& params)
+00480 {
+00481   if (params.size() != 2)
+00482     throw CInstructionError("Invalid paramater count - must be 2");
+00483   m_regidx1 = super::parseRegister(params.front());
+00484   params.pop_front();
+00485   m_regidx2 = super::parseRegister(params.front());
+00486   params.pop_front();
+00487 }
+00488 
+00489 /*----------------------------------------------------------------------------*/
+00490 
+00491 template <class T>
+00492 void CInstructionStore<T>::execute(CCPU<T> *cpu)
+00493 {
+00494   assert(cpu != NULL);
+00495   assert(cpu->getMemory() != NULL);
+00496   super::checkRegister(cpu, m_regidx1);
+00497   super::checkRegister(cpu, m_regidx2);
+00498   T val(cpu->getRegisters()[ m_regidx2 ]);
+00499   (*cpu->getMemory())[ val ] = cpu->getRegisters()[ m_regidx1 ];
+00500 }
+00501 
+00502 /*============================================================================*/
+00503 
+00511 template <class T>
+00512 class CInstructionTest
+00513  : public CInstruction<T>
+00514 {
+00515   typedef CInstruction<T> super;
+00516 
+00517   public:
+00518     CInstructionTest()
+00519       : CInstruction<T>("test")
+00520     {}
+00521 
+00522     CInstructionTest *factory()
+00523     {
+00524       return new CInstructionTest;
+00525     }
+00526 
+00527     void compile(std::list<std::string>& params);
+00528     void execute(CCPU<T> *cpu);
+00529 
+00530   protected:
+00532     unsigned m_regidx1;
+00533 };
+00534 
+00535 /*----------------------------------------------------------------------------*/
+00536 
+00537 template <class T>
+00538 void CInstructionTest<T>::compile(std::list<std::string>& params)
+00539 {
+00540   if (params.size() != 1)
+00541     throw CInstructionError("Invalid paramater count - must be 1");
+00542   m_regidx1 = super::parseRegister(params.front());
+00543   params.pop_front();
+00544 }
+00545 
+00546 /*----------------------------------------------------------------------------*/
+00547 
+00548 template <class T>
+00549 void CInstructionTest<T>::execute(CCPU<T> *cpu)
+00550 {
+00551   assert(cpu != NULL);
+00552   super::checkRegister(cpu, m_regidx1);
+00553   if (cpu->getRegisters()[ m_regidx1 ] == T(0))
+00554     cpu->setFlagZero(true);
+00555   if (cpu->getRegisters()[ m_regidx1 ] < T(0))
+00556     cpu->setFlagSign(true);
+00557 }
+00558 
+00559 /*============================================================================*/
+00560 
+00567 template <class T>
+00568 class CInstructionLabel
+00569  : public CInstruction<T>
+00570 {
+00571   typedef CInstruction<T> super;
+00572 
+00573   public:
+00574     CInstructionLabel()
+00575       : CInstruction<T>("label")
+00576     {}
+00577 
+00578     CInstructionLabel *factory()
+00579     {
+00580       return new CInstructionLabel;
+00581     }
+00582 
+00583     void compile(std::list<std::string>& params)
+00584     {}
+00585 
+00586     void execute(CCPU<T> *cpu)
+00587     {}
+00588 };
+00589 
+00590 /*============================================================================*/
+00591 
+00599 template <class T>
+00600 class CInstructionJumpA
+00601  : public CInstruction<T>
+00602 {
+00603   typedef CInstruction<T> super;
+00604 
+00605   public:
+00606     CInstructionJumpA()
+00607       : CInstruction<T>("jumpa"), m_addr("")
+00608     {}
+00609 
+00610     CInstructionJumpA *factory()
+00611     {
+00612       return new CInstructionJumpA;
+00613     }
+00614 
+00615     void compile(std::list<std::string>& params);
+00616     void execute(CCPU<T> *cpu);
+00617 
+00618   protected:
+00620     std::string m_addr;
+00621 };
+00622 
+00623 /*----------------------------------------------------------------------------*/
+00624 
+00625 template <class T>
+00626 void CInstructionJumpA<T>::compile(std::list<std::string>& params)
+00627 {
+00628   if (params.size() != 1)
+00629     throw CInstructionError("Invalid paramater count - must be 1");
+00630   m_addr = params.front();
+00631   params.pop_front();
+00632 }
+00633 
+00634 /*----------------------------------------------------------------------------*/
+00635 
+00636 template <class T>
+00637 void CInstructionJumpA<T>::execute(CCPU<T> *cpu)
+00638 {
+00639   assert(cpu != NULL);
+00640   assert(cpu->getProgram() != NULL);
+00641   if (m_addr.empty())
+00642     throw CInstructionError("Empty address");
+00643   try
+00644   {
+00645     cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
+00646   }
+00647   catch(CProgramError& ex)
+00648   {
+00649     throw CInstructionError(ex.what());
+00650   }
+00651 }
+00652 
+00653 /*============================================================================*/
+00654 
+00662 template <class T>
+00663 class CInstructionJumpZ
+00664  : public CInstruction<T>
+00665 {
+00666   typedef CInstruction<T> super;
+00667 
+00668   public:
+00669     CInstructionJumpZ()
+00670       : CInstruction<T>("jumpz"), m_addr("")
+00671     {}
+00672 
+00673     CInstructionJumpZ *factory()
+00674     {
+00675       return new CInstructionJumpZ;
+00676     }
+00677 
+00678     void compile(std::list<std::string>& params);
+00679     void execute(CCPU<T> *cpu);
+00680 
+00681   protected:
+00683     std::string m_addr;
+00684 };
+00685 
+00686 /*----------------------------------------------------------------------------*/
+00687 
+00688 template <class T>
+00689 void CInstructionJumpZ<T>::compile(std::list<std::string>& params)
+00690 {
+00691   if (params.size() != 1)
+00692     throw CInstructionError("Invalid paramater count - must be 1");
+00693   m_addr = params.front();
+00694   params.pop_front();
+00695 }
+00696 
+00697 /*----------------------------------------------------------------------------*/
+00698 
+00699 template <class T>
+00700 void CInstructionJumpZ<T>::execute(CCPU<T> *cpu)
+00701 {
+00702   assert(cpu != NULL);
+00703   assert(cpu->getProgram() != NULL);
+00704   if (!cpu->getFlagZero())
+00705     return;
+00706   if (m_addr.empty())
+00707     throw CInstructionError("Empty address");
+00708   try
+00709   {
+00710     cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
+00711   }
+00712   catch(CProgramError& ex)
+00713   {
+00714     throw CInstructionError(ex.what());
+00715   }
+00716 }
+00717 
+00718 /*============================================================================*/
+00719 
+00727 template <class T>
+00728 class CInstructionJumpS
+00729  : public CInstruction<T>
+00730 {
+00731   typedef CInstruction<T> super;
+00732 
+00733   public:
+00734     CInstructionJumpS()
+00735       : CInstruction<T>("jumps"), m_addr("")
+00736     {}
+00737 
+00738     CInstructionJumpS *factory()
+00739     {
+00740       return new CInstructionJumpS;
+00741     }
+00742 
+00743     void compile(std::list<std::string>& params);
+00744     void execute(CCPU<T> *cpu);
+00745 
+00746   protected:
+00748     std::string m_addr;
+00749 };
+00750 
+00751 /*----------------------------------------------------------------------------*/
+00752 
+00753 template <class T>
+00754 void CInstructionJumpS<T>::compile(std::list<std::string>& params)
+00755 {
+00756   if (params.size() != 1)
+00757     throw CInstructionError("Invalid paramater count - must be 1");
+00758   m_addr = params.front();
+00759   params.pop_front();
+00760 }
+00761 
+00762 /*----------------------------------------------------------------------------*/
+00763 
+00764 template <class T>
+00765 void CInstructionJumpS<T>::execute(CCPU<T> *cpu)
+00766 {
+00767   assert(cpu != NULL);
+00768   assert(cpu->getProgram() != NULL);
+00769   if (!cpu->getFlagSign())
+00770     return;
+00771   if (m_addr.empty())
+00772     throw CInstructionError("Empty address");
+00773   try
+00774   {
+00775     cpu->getRegisters()[ 0 ] = cpu->getProgram()->findLabel(m_addr);
+00776   }
+00777   catch(CProgramError& ex)
+00778   {
+00779     throw CInstructionError(ex.what());
+00780   }
+00781 }
+00782 
+00783 /*============================================================================*/
+00784 
+00792 template <class T>
+00793 class CInstructionWrite
+00794  : public CInstruction<T>
+00795 {
+00796   typedef CInstruction<T> super;
+00797   typedef typename std::set<CDisplay<T> *>::iterator setiterator;
+00798 
+00799   public:
+00800     CInstructionWrite()
+00801       : CInstruction<T>("write"), m_dev("")
+00802     {}
+00803 
+00804     CInstructionWrite *factory()
+00805     {
+00806       return new CInstructionWrite;
+00807     }
+00808 
+00809     void compile(std::list<std::string>& params);
+00810     void execute(CCPU<T> *cpu);
+00811 
+00812   protected:
+00814     unsigned m_regidx1;
+00816     std::string m_dev;
+00817 };
+00818 
+00819 /*----------------------------------------------------------------------------*/
+00820 
+00821 template <class T>
+00822 void CInstructionWrite<T>::compile(std::list<std::string>& params)
+00823 {
+00824   if (params.size() != 2)
+00825     throw CInstructionError("Invalid paramater count - must be 2");
+00826   m_dev = params.front();
+00827   params.pop_front();
+00828   m_regidx1 = super::parseRegister(params.front());
+00829   params.pop_front();
+00830 }
+00831 
+00832 /*----------------------------------------------------------------------------*/
+00833 
+00834 template <class T>
+00835 void CInstructionWrite<T>::execute(CCPU<T> *cpu)
+00836 {
+00837   assert(cpu != NULL);
+00838   super::checkRegister(cpu, m_regidx1);
+00839   if (m_dev.empty())
+00840     throw CInstructionError("Empty device");
+00841 
+00842   CDisplay<T> *display = NULL;
+00843   std::set<CDisplay<T> *> displays = cpu->getDisplays();
+00844   for(setiterator it = displays.begin(); it != displays.end(); ++it)
+00845   {
+00846     if ((*it)->getName() == m_dev)
+00847     {
+00848       display = *it;
+00849       break;
+00850     }
+00851   }
+00852   if (display == NULL)
+00853     throw CInstructionError("Unknown display");
+00854 
+00855   display->display(cpu->getRegisters()[ m_regidx1 ]);
+00856 }
+00857 
+00858 #endif
+00859 
+00860 /* vim: set et sw=2 ts=2: */
+
Generated on Sat May 30 16:32:35 2009 for mycpu by  + +doxygen 1.5.3
+ + diff --git a/ue4/doxygen/tab_b.gif b/ue4/doxygen/tab_b.gif new file mode 100644 index 0000000..0d62348 Binary files /dev/null and b/ue4/doxygen/tab_b.gif differ diff --git a/ue4/doxygen/tab_l.gif b/ue4/doxygen/tab_l.gif new file mode 100644 index 0000000..9b1e633 Binary files /dev/null and b/ue4/doxygen/tab_l.gif differ diff --git a/ue4/doxygen/tab_r.gif b/ue4/doxygen/tab_r.gif new file mode 100644 index 0000000..ce9dd9f Binary files /dev/null and b/ue4/doxygen/tab_r.gif differ diff --git a/ue4/doxygen/tabs.css b/ue4/doxygen/tabs.css new file mode 100644 index 0000000..c37faaf --- /dev/null +++ b/ue4/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; +} -- cgit v1.2.3