reformat.c

< 虚拟机设计与实现> 的source code, linux版本

			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", Rd_STR[RAM[current_byte]]);

			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", Rd_STR[RAM[current_byte]]);
				
			current_byte = current_byte++;
			break;
			
		case JE:	/*JE $r1, $r2, $r3	BBBB */
		case JNE:
		case SLT:
		case AND:	/*AND $r1, $r2, $r3	BBBB*/
		case OR:
		case XOR:
		case BT:
		case SRA:	/*SRA  $r1, $r2, $r3  BBBB */
		case SRL:
		case SL:
		case ADD:	/* ADD $r1, $r2, $r3  BBBB*/
		case SUB:
		case MULT:
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", R_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", R_STR[RAM[current_byte]]);

			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", R_STR[RAM[current_byte]]);

			current_byte = current_byte++;
			break;

		case INT: /* INT #vector	BB */
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			DBG_FMT1("vector %d\n\n", RAM[current_byte]);

			current_byte = current_byte++;
			break;
			
		case EI:	/* EI	B */
		case DI:
		case HALT:
		case NOP:
			DBG_FMT1("opcode %s\n\n", I_Set[RAM[current_byte]]);

			current_byte = current_byte++;
			break;

		case DIV:  /* DIV $r1, $r2, $r3, $r4  BBBBB */
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", R_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", R_STR[RAM[current_byte]]);

			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", R_STR[RAM[current_byte]]);

			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", R_STR[RAM[current_byte]]);

			current_byte = current_byte++;
			break;
			
		case CAST_IF:	/* CAST_IF  $r, $f  BBB */
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", R_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badFltReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", Rf_STR[RAM[current_byte]]);
				
			current_byte = current_byte++;
			break;
			
		case CAST_ID:	/* CAST_ID  $r, $d  BBB */
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badIntReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", R_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", Rd_STR[RAM[current_byte]]);
				
			current_byte = current_byte++;
			break;

		case CAST_FD: /* CAST_FD  $f, $d  BBB */
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badFltReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", Rf_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", Rd_STR[RAM[current_byte]]);
				
			current_byte = current_byte++;
			break;
			
		case CAST_DF: /* CAST_DF  $d, $f  BBB */
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", Rd_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badFltReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", Rf_STR[RAM[current_byte]]);
				
			current_byte = current_byte++;
			break;
			
		case FADD: /* FADD $f1, $f2, $f3    BBBB */
		case FSUB:
		case FMULT:
		case FDIV:
		case FSLT:
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badFltReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", Rf_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badFltReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", Rf_STR[RAM[current_byte]]);

			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badFltReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", Rf_STR[RAM[current_byte]]);
				
			current_byte = current_byte++;
			break;
			
		case DADD: /* DADD $d1, $d2, $d3    BBBB */
		case DSUB:
		case DMULT:
		case DDIV:
		case DSLT:
			DBG_FMT1("opcode %s\n", I_Set[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", Rd_STR[RAM[current_byte]]);
				
			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n", Rd_STR[RAM[current_byte]]);

			checkCurrentByte(current_byte + 1, stop);
			if (nErrors > 0)
				return FALSE;
			current_byte++;
			badDblReg(RAM[current_byte], current_byte);
			if (nErrors > 0)
				return FALSE;
			DBG_FMT1("operand %s\n\n", Rd_STR[RAM[current_byte]]);
				
			current_byte = current_byte++;
			break;
			
		default:
			ERROR1("reformat(): bad opcode %d", RAM[current_byte]);
			return FALSE;

		} /*end switch*/
	}/*end while*/

	DBG_FMT0("reformatting complete\n");
	return TRUE;

}/*end reformat*/

/* 
don't want incomplete instruction (hit end bytecode before end 
of instruction) 
*/

void checkCurrentByte(U8 cb, U8 end)
{
	if (cb >= end)
	{ 
		ERROR0("checkCurrentByte(): incomplete instruction"); 

		xmlBegin(); 
		fprintf(errPtr, "checkCurrentByte(): ");
		fprintf(errPtr, "incomplete instruction at address "); 
		fpU8(errPtr, cb); 
		xmlEnd();

		return; 
	}
	return;

}/*end checkCurrentByte*/

void badIntReg(U1 arg, U8 currentbyte)
{
	if (arg > $R24)
	{ 
		ERROR1("badIntReg(): (%d) not integer register", arg);
		
		xmlBegin();
		fprintf(errPtr, "badIntReg(): bad register at address "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();

		return;
	}
	return;

}/*end badIntReg*/

void badFltReg(U1 arg, U8 currentbyte)		
{
	//U1 arg must bigger than $F1
	if (arg > $F10) 
	{ 
		ERROR1("badFltReg(): (%d) not float register", arg);

		xmlBegin();
		fprintf(errPtr, "badFltReg(): bad register at address "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();
		
		return;
	} 
	return;

}/*end badFltReg*/

void badDblReg(U1 arg, U8 currentbyte)		
{
	//U1 arg must bigger than $D1
	if (arg > $D10)
	{ 
		ERROR1("badDblReg(): (%d) not double register", arg);

		xmlBegin();
		fprintf(errPtr, "badDblReg(): bad register at address "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();
		
		return;
	} 
	return;

}/*end badDblReg*/

void checkAddress(U1 * arr, U8 cb)
{
	U8 * addr;
	
	addr = (U8 *)&arr[cb]; 
	if (*addr > R[$TOP])
	{ 
		ERROR0("checkAddress(): address out of bounds");

		xmlBegin(); 
		fprintf(errPtr, "checkAddress(): invalid address literal ");
		fpU8(errPtr, *addr);
		fprintf(errPtr, " at memory location "); 
		fpU8(errPtr, cb); 
		xmlEnd();

		return;
	}
	return;

}/*end checkAddress*/