Commit: 91405797e5e196fc099684f5813141e98537b96d - chncpu (git)

Commit MetaInfo

• Revision: 91405797e5e196fc099684f5813141e98537b96d (tree)
• Time: 2014-07-08 15:39:41
• Author: hikarupsp <hikarupsp@user...>
• Commiter: hikarupsp

Log Message

エラー表示機能のリファクタリング。

Change Summary

• modified: chncpu/bios.c
• modified: chncpu/chncpu.c
• modified: chncpu/chncpu.h
• modified: chncpu/opcode.c
• modified: debug.c

Incremental Difference

--- a/chncpu/bios.c
+++ b/chncpu/bios.c
@@ -62,11 +62,11 @@ int CHNCPU_BIOS_Op_putcReg_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_Op
     opCache->r = CH4Reader_ReadNextAsUINT(env->appbinReader);
     
     if(opCache->r >= CHNCPU_NUMBER_OF_IREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;

--- a/chncpu/chncpu.c
+++ b/chncpu/chncpu.c
@@ -228,7 +228,7 @@ int CHNCPU_PrepareBinaryForExecution(CHNCPU_RuntimeEnvironment *env)
 				printf("Prefix-%X\n", opcode);
 #endif
 				if(opcode > CHNCPU_PREFIX_MAX){
-					env->errFlags |= CHNCPU_ERR_C_PREFIX;
+					env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
 					break;
 				}
 				prefix |= (0x01 << opcode);
@@ -241,7 +241,7 @@ int CHNCPU_PrepareBinaryForExecution(CHNCPU_RuntimeEnvironment *env)
                 if(opcode <= CHNCPU_OPECODE_MAX && opSet->bindFuncTable[opcode]){
 					opSet->bindFuncTable[opcode](env, op, prefix);
                 } else{
-                    env->errFlags |= CHNCPU_ERR_C_OPCODE;
+                    env->errFlags |= CHNCPU_ERR_INVALID_OPCODE;
                 }
 #if DEBUG_PRINT_OP_BINDING
 				if(op->opCode <= CHNCPU_OPECODE_MAX && opSet->printFuncTable[op->opCode]){
@@ -254,42 +254,18 @@ int CHNCPU_PrepareBinaryForExecution(CHNCPU_RuntimeEnvironment *env)
                 break;
         }
 		if(env->appbinReader->errorFlags){
-			env->errFlags |= CHNCPU_ERR_C_INVALID_BIN;
+			env->errFlags |= CHNCPU_ERR_INVALID_BINARY;
 		}
         if(env->errFlags){
             break;
         }
     }
     if(env->currentIndex >= CHNCPU_LENGTH_OF_MAIN_MEMORY && !CH4Reader_IsEndOfBinary(env->appbinReader)){
-        env->errFlags |= CHNCPU_ERR_C_INTERNAL;
+        env->errFlags |= CHNCPU_ERR_INTERNAL;
         puts("INVALID-C: Internal error (low on memory).");
     }
     if(env->errFlags){
-		printf(">>> Compile error in label:%d\n", env->currentLabel);
-        if(env->errFlags & CHNCPU_ERR_C_REGNUM){
-            puts("INVALID-C: Invalid register number.");
-        }
-        if(env->errFlags & CHNCPU_ERR_C_BITS){
-            puts("INVALID-C: Not supported bit width.");
-        }
-        if(env->errFlags & CHNCPU_ERR_C_OPCODE){
-            printf("INVALID-C: Unknown opCode 0x%X\n", opcode);
-        }
-        if(env->errFlags & CHNCPU_ERR_C_EXPRESSION){
-            puts("INVALID-C: Invalid expression.");
-        }
-		if(env->errFlags & CHNCPU_ERR_C_INVALID_BIN){
-            puts("INVALID-C: Invalid binary.");
-        }
-		if(env->errFlags & CHNCPU_ERR_C_PREFIX){
-			puts("INVALID-C: Invalid prefix.");
-		}
-		if(env->errFlags & CHNCPU_ERR_C_DUPLICATED_LB){
-			puts("INVALID-C: Duplicated LabelID.");
-		}
-		if(env->errFlags & CHNCPU_ERR_C_UNAVAILABLE_PTYPE){
-			puts("INVALID-C: Unavailable pointer type.");
-		}
+		CHNCPU_PrintErrorMessage(env);
     }
 	env->currentIndex = 0;
 	env->currentLabel = 0;
@@ -329,29 +305,12 @@ int CHNCPU_Execute(CHNCPU_RuntimeEnvironment *env)
 			}
         } else{
             // ロード時にチェックしたはずなのに不明な命令が来た
-            env->errFlags |= CHNCPU_ERR_X_INTERNAL;
+            env->errFlags |= CHNCPU_ERR_INTERNAL;
             break;
         }
     }
     if(env->errFlags){
-        if(env->errFlags & CHNCPU_ERR_X_INTERNAL){
-            puts("INVALID-X: Internal error.");
-        }
-		if(env->errFlags & CHNCPU_ERR_X_TRUNCATED_VALUE){
-			puts("INVALID-X: Truncated value without prefix 2F-0.");
-		}
-		if(env->errFlags & CHNCPU_ERR_X_LABEL_NOT_FOUND){
-			puts("INVALID-X: Label not found.");
-		}
-		if(env->errFlags & CHNCPU_ERR_X_PTYPE_NOT_MATCHED){
-			puts("INVALID-X: Pointer type not matched.");
-		}
-		if(env->errFlags & CHNCPU_ERR_X_BAD_ACCESS){
-			puts("INVALID-X: Bad access.");
-		}
-		if(env->errFlags & CHNCPU_ERR_X_INVALID_PTYPE){
-			puts("INVALID-X: Invalid pointer type.");
-		}
+        CHNCPU_PrintErrorMessage(env);
     }
 	
 #if (DEBUG_PRINT_IREG_AFTER_EXECUTION || DEBUG_PRINT_PREG_AFTER_EXECUTION)
@@ -371,7 +330,7 @@ int CHNCPU_Execute(CHNCPU_RuntimeEnvironment *env)
 int CHNCPU_CHK_IsAvailableBits(CHNCPU_RuntimeEnvironment *env, ch4_uint bits)
 {
     if(bits > 32){
-        env->errFlags |= CHNCPU_ERR_C_BITS;
+        env->errFlags |= CHNCPU_ERR_INVALID_BITS;
         return 0;
     }
     return 1;
@@ -390,7 +349,7 @@ int CHNCPU_AdjustValueForBit(CHNCPU_RuntimeEnvironment *env, int *value, ch4_uin
 		return 0;
 	}
 	if(!(prefix & CHNCPU_PREFIX_ALLOW_TRUNCATE)){
-		env->errFlags |= CHNCPU_ERR_X_TRUNCATED_VALUE;
+		env->errFlags |= CHNCPU_ERR_TRUNCATED_VALUE;
 		return 1;
 	}
 	

--- a/chncpu/chncpu.h
+++ b/chncpu/chncpu.h
@@ -39,24 +39,21 @@
 #define CHNCPU_MemoryIndex_INVALID      (-1)
 #define CHNCPU_PREFIX_MAX               31
 
-// ErrorCode at compile
-#define CHNCPU_ERR_C_REGNUM             0x0001
-#define CHNCPU_ERR_C_BITS               0x0002
-#define CHNCPU_ERR_C_OPCODE             0x0004
-#define CHNCPU_ERR_C_EXPRESSION         0x0008
-#define CHNCPU_ERR_C_INTERNAL           0x0010
-#define CHNCPU_ERR_C_INVALID_BIN        0x0020
-#define CHNCPU_ERR_C_PREFIX             0x0040
-#define CHNCPU_ERR_C_DUPLICATED_LB      0x0080
-#define CHNCPU_ERR_C_UNAVAILABLE_PTYPE	0x0100
-
-// ErrorCode in execution
-#define CHNCPU_ERR_X_INTERNAL           0x01
-#define CHNCPU_ERR_X_TRUNCATED_VALUE    0x02
-#define CHNCPU_ERR_X_LABEL_NOT_FOUND		0x04
-#define CHNCPU_ERR_X_PTYPE_NOT_MATCHED	0x08
-#define CHNCPU_ERR_X_BAD_ACCESS			0x10
-#define CHNCPU_ERR_X_INVALID_PTYPE		0x20
+// Common ErrorCode
+#define CHNCPU_ERR_INTERNAL                 0x0001
+#define CHNCPU_ERR_INVALID_BITS             0x0002
+#define CHNCPU_ERR_INVALID_OPCODE           0x0004
+#define CHNCPU_ERR_INVALID_REGNUM           0x0008
+#define CHNCPU_ERR_INVALID_PTYPE            0x0010
+#define CHNCPU_ERR_INVALID_BINARY			0x0020
+#define CHNCPU_ERR_INVALID_PREFIX           0x0040
+#define CHNCPU_ERR_INVALID_EXPRESSION       0x0080
+#define CHNCPU_ERR_INVALID_BIOS_FUNC_ID     0x0100
+#define CHNCPU_ERR_DUPLICATED_LABEL_ID		0x0200
+#define CHNCPU_ERR_NOT_FOUND_LABEL			0x0400
+#define CHNCPU_ERR_NOT_MATCHED_PTYPE			0x0800
+#define CHNCPU_ERR_TRUNCATED_VALUE			0x1000
+#define CHNCPU_ERR_BAD_ACCESS				0x2000
 
 // (2F)Prefix
 #define CHNCPU_PREFIX_ALLOW_TRUNCATE    0x01
@@ -224,7 +221,7 @@ int CHNCPU_Op_DATA_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
 int CHNCPU_Op_DATA_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op);
 int CHNCPU_Op_DATA_PrintCode(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, FILE *file);
 CHNCPU_OpTag *CHNCPU_Op_DATA_CreateEmptyData(void);
-int CHNCPU_Op_DATA_AllocateRawDataMemory(CHNCPU_OpTag *op, ch4_sint dataType, ch4_uint dataCount);
+int CHNCPU_Op_DATA_AllocateRawDataMemory(CHNCPU_OpTag *op, ch4_sint dataType, ch4_uint dataCount, unsigned int *errFlags);
 CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch4_sint pType);
 int CHNCPU_Op_DATA_AssignDataTagToPReg(CHNCPU_RuntimeEnvironment *env, ch4_uint p, CHNCPU_OpTag *op);
 int CHNCPU_Op_DATA_WriteRawDataToFile(CHNCPU_OpTag *op, const char dataPath[], int dataCount, int dataType);
@@ -252,5 +249,6 @@ CHNCPU_LabelTag *CHNCPU_Label_GetTagFromLabelID(CHNCPU_LabelSet *lbSet, int labe
 void CHNCPU_DumpAppBin(CHNCPU_RuntimeEnvironment *env);
 void CHNCPU_DumpIReg(CHNCPU_RuntimeEnvironment *env);
 void CHNCPU_DumpPReg(CHNCPU_RuntimeEnvironment *env);
+void CHNCPU_PrintErrorMessage(CHNCPU_RuntimeEnvironment *env);
 
 #endif

--- a/chncpu/opcode.c
+++ b/chncpu/opcode.c
@@ -112,11 +112,11 @@ int CHNCPU_Op_LB_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, u
 	env->currentLabel = opCache->labelID;
 	
 	if(CHNCPU_Label_Add(env->labelSet, env->currentIndex, opCache->labelID, opCache->opt, CHNCPU_PType_Label)){
-		env->errFlags |= CHNCPU_ERR_C_DUPLICATED_LB;
+		env->errFlags |= CHNCPU_ERR_DUPLICATED_LABEL_ID;
 	}
     
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -157,18 +157,18 @@ int CHNCPU_Op_LIMM_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
     opCache->bit = CH4Reader_ReadNextAsUINT(env->appbinReader);
     
     if(opCache->r >= CHNCPU_NUMBER_OF_IREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
     if(!CHNCPU_CHK_IsAvailableBits(env, opCache->bit)){
         return -1;
     }
     if(opCache->bit == 0 && opCache->imm != 0){
-        env->errFlags |= CHNCPU_ERR_C_EXPRESSION;
+        env->errFlags |= CHNCPU_ERR_INVALID_EXPRESSION;
         return -1;
     }
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
 	CHNCPU_AdjustValueForBit(env, &opCache->imm, opCache->bit, CHNCPU_PREFIX_ALLOW_TRUNCATE);
@@ -214,11 +214,11 @@ int CHNCPU_Op_PLIMM_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op
     opCache->r = CH4Reader_ReadNextAsUINT(env->appbinReader);
     
     if(opCache->r >= CHNCPU_NUMBER_OF_PREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -232,7 +232,7 @@ int CHNCPU_Op_PLIMM_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
     
 	label = CHNCPU_Label_GetTagFromLabelID(env->labelSet, opCache->labelID);
 	if(!label){
-		env->errFlags |= CHNCPU_ERR_X_LABEL_NOT_FOUND;
+		env->errFlags |= CHNCPU_ERR_NOT_FOUND_LABEL;
 		return -1;
 	}
 	
@@ -276,11 +276,11 @@ int CHNCPU_Op_CND_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
     opCache->r = CH4Reader_ReadNextAsUINT(env->appbinReader);
     
     if(opCache->r >= CHNCPU_NUMBER_OF_PREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -326,7 +326,7 @@ int CHNCPU_Op_CALLBIOS_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag
 	if(fid <= CHNCPU_BIOS_OP_MAX && env->bios->bindFuncTable[fid]){
 		env->bios->bindFuncTable[fid](env, opCache, prefix);
 	} else{
-		env->errFlags |= CHNCPU_ERR_C_OPCODE;
+		env->errFlags |= CHNCPU_ERR_INVALID_BIOS_FUNC_ID;
 	}
 	
 	if(env->errFlags){
@@ -346,7 +346,7 @@ int CHNCPU_Op_CALLBIOS_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
 		env->bios->execFuncTable[fid](env, opCache);
 	} else{
 		// ロード時にチェックしたはずなのに不明な命令が来た
-		env->errFlags |= CHNCPU_ERR_X_INTERNAL;
+		env->errFlags |= CHNCPU_ERR_INTERNAL;
 	}
 	
     return 0;
@@ -387,14 +387,14 @@ int CHNCPU_Op_LMEM_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
     
     if(opCache->r >= CHNCPU_NUMBER_OF_IREG ||
 	   opCache->p >= CHNCPU_NUMBER_OF_PREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
     if(!CHNCPU_CHK_IsAvailableBits(env, opCache->bitDst)){
         return -1;
     }
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -409,7 +409,7 @@ int CHNCPU_Op_LMEM_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
     p = &env->pReg[opCache->p];
     
 	if(p->type != opCache->pType){
-		env->errFlags |= CHNCPU_ERR_X_PTYPE_NOT_MATCHED;
+		env->errFlags |= CHNCPU_ERR_NOT_MATCHED_PTYPE;
         return -1;
 	}
 	
@@ -458,14 +458,14 @@ int CHNCPU_Op_TernaryReg_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTa
     if(opCache->r0 >= CHNCPU_NUMBER_OF_IREG ||
 	   opCache->r1 >= CHNCPU_NUMBER_OF_IREG ||
 	   opCache->r2 >= CHNCPU_NUMBER_OF_IREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
     if(!CHNCPU_CHK_IsAvailableBits(env, opCache->bit)){
         return -1;
     }
 	if((prefix | CHNCPU_PREFIX_MASK_Op_TernaryReg) != CHNCPU_PREFIX_MASK_Op_TernaryReg){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -494,13 +494,13 @@ int CHNCPU_Op_TernaryRegBitwise_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_O
 		// AND
 		result = env->iReg[opCache->r1] & env->iReg[opCache->r2];
 	} else{
-		env->errFlags |= CHNCPU_ERR_X_INTERNAL;
+		env->errFlags |= CHNCPU_ERR_INTERNAL;
 		return -1;
 	}
 	// check
 	checked = result & (0xFFFFFFFF >> (32 - opCache->bit));
 	if(!(opCache->prefix & CHNCPU_PREFIX_ALLOW_TRUNCATE) && checked != result){
-		env->errFlags |= CHNCPU_ERR_X_TRUNCATED_VALUE;
+		env->errFlags |= CHNCPU_ERR_TRUNCATED_VALUE;
 		return -1;
 	}
 	// store
@@ -534,7 +534,7 @@ int CHNCPU_Op_TernaryRegArithmetic_Execute(CHNCPU_RuntimeEnvironment *env, CHNCP
 	} else if(opCode == 0x1B){	// MOD
 		result = env->iReg[opCache->r1] % env->iReg[opCache->r2];
 	} else{
-		env->errFlags |= CHNCPU_ERR_X_INTERNAL;
+		env->errFlags |= CHNCPU_ERR_INTERNAL;
 		return -1;
 	}
 	// check
@@ -606,7 +606,7 @@ int CHNCPU_Op_CompareIReg_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpT
     if(opCache->rSrc1 >= CHNCPU_NUMBER_OF_IREG ||
 	   opCache->rSrc2 >= CHNCPU_NUMBER_OF_IREG ||
 	   opCache->rDst >= CHNCPU_NUMBER_OF_IREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
     if(!CHNCPU_CHK_IsAvailableBits(env, opCache->bitDiff) ||
@@ -614,7 +614,7 @@ int CHNCPU_Op_CompareIReg_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpT
         return -1;
     }
 	if((prefix | CHNCPU_PREFIX_MASK_Op_CompareIReg) != CHNCPU_PREFIX_MASK_Op_CompareIReg){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -660,12 +660,12 @@ int CHNCPU_Op_CompareIReg_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *
 	} else if(opCode == 0x27){
 		result = ((r1 & r2) != 0) ? -1 : 0;
 	} else{
-		env->errFlags |= CHNCPU_ERR_X_INTERNAL;
+		env->errFlags |= CHNCPU_ERR_INTERNAL;
 		return -1;
 	}
 	// check with bitDst
 	if(opCache->bitDst == 0){
-		env->errFlags |= CHNCPU_ERR_X_TRUNCATED_VALUE;
+		env->errFlags |= CHNCPU_ERR_TRUNCATED_VALUE;
 		return -1;
 	}
 	// store
@@ -725,12 +725,7 @@ int CHNCPU_Op_DATA_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
 	opCache->filePath = NULL;
 	
 	// Check ptype & Calculate rawDataByteSize
-	if(CHNCPU_Op_DATA_AllocateRawDataMemory(op, opCache->dataType, opCache->dataCount)){
-		if(CHNCPU_Op_DATA_CalculateByteSizeOfRawData(opCache->dataType, opCache->dataCount) <= 0){
-			env->errFlags |= CHNCPU_ERR_C_UNAVAILABLE_PTYPE;
-		} else{
-			env->errFlags |= CHNCPU_ERR_C_INTERNAL;
-		}
+	if(CHNCPU_Op_DATA_AllocateRawDataMemory(op, opCache->dataType, opCache->dataCount, &env->errFlags)){
 		return -1;
 	}
 	
@@ -742,11 +737,11 @@ int CHNCPU_Op_DATA_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
 	}
 	
 	if(CHNCPU_Label_Add(env->labelSet, env->currentIndex, opCache->labelID, opCache->labelOpt, opCache->dataType)){
-		env->errFlags |= CHNCPU_ERR_C_DUPLICATED_LB;
+		env->errFlags |= CHNCPU_ERR_DUPLICATED_LABEL_ID;
 	}
     
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -811,18 +806,24 @@ CHNCPU_OpTag *CHNCPU_Op_DATA_CreateEmptyData(void)
 	
 	return op;
 }
-int CHNCPU_Op_DATA_AllocateRawDataMemory(CHNCPU_OpTag *op, ch4_sint dataType, ch4_uint dataCount)
+int CHNCPU_Op_DATA_AllocateRawDataMemory(CHNCPU_OpTag *op, ch4_sint dataType, ch4_uint dataCount, unsigned int *errFlags)
 {
 	// 生データのメモリを割り当てる。
 	CHNCPU_OpCache_DATA *opCache;
 	
 	if(!op || op->opCode != CHNCPU_OP_DATA || !op->opCache){
+		if(errFlags){
+			*errFlags |= CHNCPU_ERR_INTERNAL;
+		}
         return -1;
 	}
 	opCache = op->opCache;
 	
 	opCache->rawDataByteSize = CHNCPU_Op_DATA_CalculateByteSizeOfRawData(dataType, dataCount);
 	if(opCache->rawDataByteSize <= 0){
+		if(errFlags){
+			*errFlags |= CHNCPU_ERR_INVALID_PTYPE;
+		}
 		return -1;
 	}
 	if(opCache->rawData){
@@ -865,7 +866,7 @@ CHNCPU_OpTag *CHNCPU_Op_DATA_CreateDataFromFileAsPType(const char dataPath[], ch
 	fseek(fp, 0, SEEK_SET);
 	
 	// 現状はUINT8前提なのでopCache->rawDataByteSize==dataCount
-	if(CHNCPU_Op_DATA_AllocateRawDataMemory(op, pType, opCache->rawDataByteSize)){
+	if(CHNCPU_Op_DATA_AllocateRawDataMemory(op, pType, opCache->rawDataByteSize, NULL)){
 		fclose(fp);
 		free(opCache);
 		free(op);
@@ -950,7 +951,7 @@ int CHNCPU_Op_DATA_ReadAtIndex(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
 
 	
 	if(!op || op->opCode != CHNCPU_OP_DATA || index < 0 || index >= ((CHNCPU_OpCache_DATA *)op->opCache)->dataCount){
-		env->errFlags |= CHNCPU_ERR_X_BAD_ACCESS;
+		env->errFlags |= CHNCPU_ERR_BAD_ACCESS;
         return 0;
 	}
 	opCache = op->opCache;
@@ -958,7 +959,7 @@ int CHNCPU_Op_DATA_ReadAtIndex(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
 	if(opCache->dataType == CHNCPU_PType_UINT8){
 	 	retv = ((unsigned char *)opCache->rawData)[index];
 	} else{
-		env->errFlags |= CHNCPU_ERR_X_INVALID_PTYPE;
+		env->errFlags |= CHNCPU_ERR_INVALID_PTYPE;
         return 0;
 	}
 	
@@ -999,7 +1000,7 @@ const char *CHNCPU_Op_DATA_GetFilePath(CHNCPU_OpTag *op)
 //
 // 32 MALLOC
 //
-/*
+
 int CHNCPU_Op_MALLOC_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, unsigned int prefix)
 {
     CHNCPU_OpCache_MALLOC *opCache;
@@ -1016,7 +1017,7 @@ int CHNCPU_Op_MALLOC_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *o
     if(opCache->rType >= CHNCPU_NUMBER_OF_IREG ||
 	   opCache->rCount >= CHNCPU_NUMBER_OF_IREG ||
 	   opCache->p >= CHNCPU_NUMBER_OF_PREG){
-        env->errFlags |= CHNCPU_ERR_C_REGNUM;
+        env->errFlags |= CHNCPU_ERR_INVALID_REGNUM;
         return -1;
     }
     if(!CHNCPU_CHK_IsAvailableBits(env, opCache->bitType) ||
@@ -1024,7 +1025,7 @@ int CHNCPU_Op_MALLOC_BindOperand(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *o
         return -1;
     }
 	if(prefix != 0){
-		env->errFlags |= CHNCPU_ERR_C_PREFIX;
+		env->errFlags |= CHNCPU_ERR_INVALID_PREFIX;
         return -1;
 	}
     return 0;
@@ -1034,7 +1035,6 @@ int CHNCPU_Op_MALLOC_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
 {
 	CHNCPU_OpTag *dataOpTag;
     CHNCPU_OpCache_MALLOC *opCache;
-	int value;
 	ch4_sint type;
 	ch4_uint count;
     
@@ -1044,26 +1044,11 @@ int CHNCPU_Op_MALLOC_Execute(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op)
 	count = env->iReg[opCache->rCount];
 	
 	dataOpTag = CHNCPU_Op_DATA_CreateEmptyData();
-	if(CHNCPU_Op_DATA_AllocateRawDataMemory(dataOpTag, type, count)){
-		
-	}
-	
-	
-	value = CHNCPU_Op_DATA_ReadAtIndex(env, p->opTag, p->pindex);
-	if(env->errFlags){
+	if(CHNCPU_Op_DATA_AllocateRawDataMemory(dataOpTag, type, count, &env->errFlags)){
 		return -1;
 	}
 	
-	CHNCPU_AdjustValueForBit(env, &value, opCache->bitDst, CHNCPU_PREFIX_ALLOW_TRUNCATE);
-	if(env->errFlags){
-		return -1;
-	}
-	env->iReg[opCache->r] = value;
-	env->iRegBits[opCache->r] = opCache->bitDst;
-	
-	p->pindex += opCache->pDiff;
-    
-    return 0;
+	return 0;
 }
 int CHNCPU_Op_MALLOC_PrintCode(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op, FILE *file)
 {
@@ -1073,6 +1058,4 @@ int CHNCPU_Op_MALLOC_PrintCode(CHNCPU_RuntimeEnvironment *env, CHNCPU_OpTag *op,
     fprintf(file, "LMEM(p:0x%02X, pType:0x%X, pDiff:%d, r:%02X, bitDst:%d);\n", opCache->p, opCache->pType, opCache->pDiff, opCache->r, opCache->bitDst);
 	
     return 0;
-}
-
-*/
\ No newline at end of file
+}
\ No newline at end of file

--- a/debug.c
+++ b/debug.c
@@ -62,3 +62,51 @@ void CHNCPU_DumpPReg(CHNCPU_RuntimeEnvironment *env)
         putchar('\n');
     }
 }
+
+void CHNCPU_PrintErrorMessage(CHNCPU_RuntimeEnvironment *env)
+{
+	printf(">>> Error in label:%d\n\t", env->currentLabel);
+	if(env->errFlags & CHNCPU_ERR_INTERNAL){
+		puts("Internal error.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_BITS){
+		puts("Invalid bits.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_OPCODE){
+		puts("Invalid opCode.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_REGNUM){
+		puts("Invalid regNum.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_PTYPE){
+		puts("Invalid pType.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_BINARY){
+		puts("Invalid Binary.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_PREFIX){
+		puts("Invalid prefix.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_EXPRESSION){
+		puts("Invalid expression.");
+	}
+	if(env->errFlags & CHNCPU_ERR_INVALID_EXPRESSION){
+		puts("Invalid BIOSFuncID.");
+	}
+	if(env->errFlags & CHNCPU_ERR_DUPLICATED_LABEL_ID){
+		puts("LabelID duplicated.");
+	}
+	if(env->errFlags & CHNCPU_ERR_NOT_FOUND_LABEL){
+		puts("LabelID not found.");
+	}
+	if(env->errFlags & CHNCPU_ERR_NOT_MATCHED_PTYPE){
+		puts("PType not matched.");
+	}
+	if(env->errFlags & CHNCPU_ERR_TRUNCATED_VALUE){
+		puts("Value truncated without prefix 2F-0.");
+	}
+	if(env->errFlags & CHNCPU_ERR_BAD_ACCESS){
+		puts("Bad access on memory.");
+	}
+	return;
+}