1 files changed, 40 insertions, 40 deletions

diff --git a/ue4/mycpu/instructions.h b/ue4/mycpu/instructions.h
index fcff3e7..3f2fd51 100644
--- a/ue4/mycpu/instructions.h
+++ b/ue4/mycpu/instructions.h
@@ -19,7 +19,7 @@
  * Syntax: inc R1
  *   (R1++)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionInc
  : public CInstruction<T>
 {
@@ -45,7 +45,7 @@ class CInstructionInc
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionInc<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -56,7 +56,7 @@ void CInstructionInc<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionInc<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -74,7 +74,7 @@ void CInstructionInc<T>::execute(CCPU<T> *cpu)
  * Syntax: dec R1
  *   (R1--)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionDec
  : public CInstruction<T>
 {
@@ -100,7 +100,7 @@ class CInstructionDec
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDec<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -111,7 +111,7 @@ void CInstructionDec<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDec<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -129,7 +129,7 @@ void CInstructionDec<T>::execute(CCPU<T> *cpu)
  * Syntax: add R1, R2, R3
  *   (R1 = R2 + R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionAdd
  : public CInstruction<T>
 {
@@ -159,7 +159,7 @@ class CInstructionAdd
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionAdd<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -174,7 +174,7 @@ void CInstructionAdd<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionAdd<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -195,7 +195,7 @@ void CInstructionAdd<T>::execute(CCPU<T> *cpu)
  * Syntax: sub R1, R2, R3
  *   (R1 = R2 - R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionSub
  : public CInstruction<T>
 {
@@ -225,7 +225,7 @@ class CInstructionSub
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionSub<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -240,7 +240,7 @@ void CInstructionSub<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionSub<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -261,7 +261,7 @@ void CInstructionSub<T>::execute(CCPU<T> *cpu)
  * Syntax: mul R1, R2, R3
  *   (R1 = R2 * R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionMul
  : public CInstruction<T>
 {
@@ -291,7 +291,7 @@ class CInstructionMul
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionMul<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -306,7 +306,7 @@ void CInstructionMul<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionMul<T>::execute(CCPU<T> *cpu)
 {
   super::checkRegister(cpu, m_regidx1);
@@ -325,7 +325,7 @@ void CInstructionMul<T>::execute(CCPU<T> *cpu)
  * Syntax: div R1, R2, R3
  *   (R1 = R2 / R3)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionDiv
  : public CInstruction<T>
 {
@@ -355,7 +355,7 @@ class CInstructionDiv
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDiv<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 3)
@@ -370,7 +370,7 @@ void CInstructionDiv<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionDiv<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -391,7 +391,7 @@ void CInstructionDiv<T>::execute(CCPU<T> *cpu)
  * Syntax: load R1, R2
  *   (R1 = memory[R2])
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionLoad
  : public CInstruction<T>
 {
@@ -419,7 +419,7 @@ class CInstructionLoad
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionLoad<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 2)
@@ -432,7 +432,7 @@ void CInstructionLoad<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionLoad<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -453,7 +453,7 @@ void CInstructionLoad<T>::execute(CCPU<T> *cpu)
  * Syntax: store R1, R2
  *   (memory[R2] = R1)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionStore
  : public CInstruction<T>
 {
@@ -481,7 +481,7 @@ class CInstructionStore
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionStore<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 2)
@@ -494,7 +494,7 @@ void CInstructionStore<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionStore<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -515,7 +515,7 @@ void CInstructionStore<T>::execute(CCPU<T> *cpu)
  * Syntax: test R1
  *   (R1 == 0: zeroflag: true, R1 < 0: signflag: true)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionTest
  : public CInstruction<T>
 {
@@ -541,7 +541,7 @@ class CInstructionTest
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionTest<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -552,7 +552,7 @@ void CInstructionTest<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionTest<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -572,7 +572,7 @@ void CInstructionTest<T>::execute(CCPU<T> *cpu)
  * Implementation of assembler command "label"
  * Syntax: label name:
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionLabel
  : public CInstruction<T>
 {
@@ -604,7 +604,7 @@ class CInstructionLabel
  * Syntax: jumpa labelname
  *   (jump to labelname)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionJumpA
  : public CInstruction<T>
 {
@@ -630,7 +630,7 @@ class CInstructionJumpA
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpA<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -641,7 +641,7 @@ void CInstructionJumpA<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpA<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -661,7 +661,7 @@ void CInstructionJumpA<T>::execute(CCPU<T> *cpu)
  * Syntax: jumpz labelname
  *   (jump to labelname if zeroflag)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionJumpZ
  : public CInstruction<T>
 {
@@ -687,7 +687,7 @@ class CInstructionJumpZ
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpZ<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -698,7 +698,7 @@ void CInstructionJumpZ<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpZ<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -720,7 +720,7 @@ void CInstructionJumpZ<T>::execute(CCPU<T> *cpu)
  * Syntax: jumps labelname
  *   (jump to labelname if signflag)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionJumpS
  : public CInstruction<T>
 {
@@ -746,7 +746,7 @@ class CInstructionJumpS
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpS<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 1)
@@ -757,7 +757,7 @@ void CInstructionJumpS<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionJumpS<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);
@@ -779,7 +779,7 @@ void CInstructionJumpS<T>::execute(CCPU<T> *cpu)
  * Syntax: write DEV, R1
  *   (write R1 to DEV, which is a name of a display)
  */
-template <class T>
+template<class T=CDat<int>, int width=0>
 class CInstructionWrite
  : public CInstruction<T>
 {
@@ -808,7 +808,7 @@ class CInstructionWrite
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionWrite<T>::compile(std::list<std::string>& params)
 {
   if (params.size() != 2)
@@ -821,7 +821,7 @@ void CInstructionWrite<T>::compile(std::list<std::string>& params)
 
 /*----------------------------------------------------------------------------*/
 
-template <class T>
+template<class T=CDat<int>, int width=0>
 void CInstructionWrite<T>::execute(CCPU<T> *cpu)
 {
   assert(cpu != NULL);