📄 vmachine.cpp

📁 编译原理一本关于编译原理的经典教材
💻 CPP
字号:
#include "VMachine.h"
#include <assert.h>

TVMachine::TVMachine()
{
	m_PC = 0;
	m_SP = 0;
	m_Stack = new BYTE[MAX_STACK_SIZE];
}

TVMachine::~TVMachine()
{
	delete[] m_Stack;
}

EErrorType TVMachine::Run(BYTE *pCode)
{
	m_PC = (DWORD)pCode;
	this->m_PC = (DWORD)pCode;
	try
	{
		while(1)
		{
			BYTE temp = *(BYTE*)m_PC;
			EInstruct instruct = (EInstruct)temp;
			m_PC++;
			//=========================================
			switch (instruct)
			{
			case E_MOV:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = ((int*)m_Stack)[adrSrc];
				}
				break;

			case E_SET:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					DWORD num = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = num;
				}
				break;

			case E_ADD:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc1 = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc2 = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = ((int*)m_Stack)[adrSrc1] + ((int*)m_Stack)[adrSrc2];
					
				}
				break;

			case E_SUB:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc1 = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc2 = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = ((int*)m_Stack)[adrSrc1] - ((int*)m_Stack)[adrSrc2];
				}
				break;

			case E_MUL:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc1 = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc2 = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = ((int*)m_Stack)[adrSrc1] * ((int*)m_Stack)[adrSrc2];
				}
				break;	

			case E_DIV:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc1 = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc2 = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = ((int*)m_Stack)[adrSrc1] / ((int*)m_Stack)[adrSrc2];
				}
				break;

			case E_AND:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc1 = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc2 = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = ((int*)m_Stack)[adrSrc1] & ((int*)m_Stack)[adrSrc2];
				}
				break;

			case E_OR:
				{
					int adrDes = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc1 = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrSrc2 = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrDes] = ((int*)m_Stack)[adrSrc1] | ((int*)m_Stack)[adrSrc2];
				}
				break;

			case E_MOVF:
				{
					int adrDes = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc = *((float*)m_PC);
					m_PC += sizeof(float);
					((float*)m_Stack)[adrDes] = ((float*)m_Stack)[adrSrc];
				}
				break;

			case E_SETF:
				{
					int adrDes = *((float*)m_PC);
					m_PC += sizeof(float);
					DWORD num = *((float*)m_PC);
					m_PC += sizeof(float);
					((float*)m_Stack)[adrDes] = num;
				}
				break;

			case E_ADDF:
				{
					int adrDes = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc1 = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc2 = *((float*)m_PC);
					m_PC += sizeof(float);
					((float*)m_Stack)[adrDes] = ((float*)m_Stack)[adrSrc1] + ((float*)m_Stack)[adrSrc2];
					
				}
				break;

			case E_SUBF:
				{
					int adrDes = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc1 = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc2 = *((float*)m_PC);
					m_PC += sizeof(float);
					((float*)m_Stack)[adrDes] = ((float*)m_Stack)[adrSrc1] - ((float*)m_Stack)[adrSrc2];
				}
				break;

			case E_MULF:
				{
					int adrDes = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc1 = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc2 = *((float*)m_PC);
					m_PC += sizeof(float);
					((float*)m_Stack)[adrDes] = ((float*)m_Stack)[adrSrc1] * ((float*)m_Stack)[adrSrc2];
				}
				break;	

			case E_DIVF:
				{
					int adrDes = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc1 = *((float*)m_PC);
					m_PC += sizeof(float);
					int adrSrc2 = *((float*)m_PC);
					m_PC += sizeof(float);
					((float*)m_Stack)[adrDes] = ((float*)m_Stack)[adrSrc1] / ((float*)m_Stack)[adrSrc2];
				}
				break;

			case E_INC:
				{
					int adr = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adr]++;
				}
				break;

			case E_DEC:
				{
					int adr = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adr]--;
				}
				break;

			case E_NEG:
				{
					int adr = *((int*)m_PC);
					m_PC += sizeof(int);
					int a = ((int*)m_Stack)[adr];
					((int*)m_Stack)[adr] = -a;
				}
				break;

			case E_TEQ:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((int*)m_Stack)[adrA] == ((int*)m_Stack)[adrB];
				}
				break;

			case E_TBG:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((int*)m_Stack)[adrA] > ((int*)m_Stack)[adrB];
				}
				break;

			case E_TLG:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((int*)m_Stack)[adrA] < ((int*)m_Stack)[adrB];
				}
				break;

			case E_TBEG:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((int*)m_Stack)[adrA] >= ((int*)m_Stack)[adrB];
				}
				break;

			case E_TLEG:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((int*)m_Stack)[adrA] <= ((int*)m_Stack)[adrB];
				}
				break;

			case E_TEQF:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((float*)m_Stack)[adrA] == ((float*)m_Stack)[adrB];
				}
				break;

			case E_TBGF:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((float*)m_Stack)[adrA] > ((float*)m_Stack)[adrB];
				}
				break;

			case E_TLGF:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((float*)m_Stack)[adrA] < ((float*)m_Stack)[adrB];
				}
				break;

			case E_TBEGF:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((float*)m_Stack)[adrA] >= ((float*)m_Stack)[adrB];
				}
				break;

			case E_TLEGF:
				{
					int adrA = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrB = *((int*)m_PC);
					m_PC += sizeof(int);
					int adrFlag = *((int*)m_PC);
					m_PC += sizeof(int);
					((int*)m_Stack)[adrFlag] = ((float*)m_Stack)[adrA] <= ((float*)m_Stack)[adrB];
				}
				break;

			case E_JMP: //绝对偏移地址
				{
					int adr = *((int*)m_PC);
					m_PC = (int)pCode + adr;
				}
				break;

			case E_JZ:
				{
					int adr = *((int*)m_PC);
					m_PC += sizeof(int);
					int flag = *((int*)m_PC);
					m_PC += sizeof(int);
					if(flag == 0)
						m_PC = (int)pCode + adr;

				}
				break;

			case E_JNZ:
				{
					int adr = *((int*)m_PC);
					m_PC += sizeof(int);
					int flag = *((int*)m_PC);
					m_PC += sizeof(int);
					if(flag != 0)
						m_PC = (int)pCode + adr;

				}
				break;

			case E_RET://(stack top)PC,SP
				{
					this->Pop(m_PC);
					this->Pop(m_SP);
				}
				break;

			case E_END:
				{
					return E_OK;
				}
				break;

			case E_CALL: //相对偏移地址
				{
					int adr = *((int*)m_PC);
					m_PC = (int)pCode + adr;
				}
				break;

			case E_NOP:
				{
					
				}
				break;

			case E_PUSH:
				{
					int adr = *((int*)m_PC);
					m_PC += sizeof(int);
					Push(((DWORD*)m_Stack)[adr]);
				}
				break;
			
			case E_POP:
				{
					int adr = *((int*)m_PC);
					m_PC += sizeof(int);
					Pop(((DWORD*)m_Stack)[adr]);
				}
				break;

			case E_PUSHA:
				{
					Push(m_SP);
					Push(m_PC);
				}
				break;

			default:
				{
					assert(false);
				}
			}

		}
	}
	catch(...)
	{
		assert(false);
	}

}


inline void TVMachine::Push(DWORD n)
{
	((DWORD*)m_Stack)[m_SP] = n;
	m_SP += sizeof(DWORD);
}

inline void TVMachine::Pop(DWORD& n)
{
	m_SP -= sizeof(DWORD);
	n = ((DWORD*)m_Stack)[m_SP];
}
💿 文件大小 7448 K
👤 上传用户 ying_min
📂 所属分类 VC书籍
🏷️ 相关标签

#编译原理 #教材
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -