// 基于堆栈的虚拟机实现
#include <iostream>
#include <string>
#include <vector>
#include <stack>
using namespace std;// 虚拟机的二进制指令集
enum Command
{HALT, IN, OUT, ADD, SUB, MUL, DIV,INMEMORY, /* 存放内存 */OUTMEMORY, /* 读取内存 */DUP,LD, ST, LDC, JLT, JLE, JGT, JGE, JEQ, JNE, JMP,INVALID
};// 指令结构体
struct Instruction
{Command com;   // 指令码int     opd;   // 操作数
};// 堆栈
stack<int> stk;// 指令内存
vector<Instruction> insMemory;// 数据内存
vector<int> datMemory(101);// 状态码
enum StateCode
{scHALT, scOK,errDIVBYZERO, errDATMEMORY, errINSMEMORY,errSTACKOVERFLOW, errSTACKEMPTY, errPOP,errUNKNOWNOP
};// 输出错误信息
void Error(const string& err)
{cerr << err << endl;
}// 根据指令码返回指令码需要的操作数个数
int GetOperandCount(Command com)
{int ret = 0;switch (com){case INMEMORY:case OUTMEMORY:case LDC:case JLT:case JLE:case JGT:case JGE:case JEQ:case JNE:case JMP:ret = 1;break;default:ret = 0;break;}return ret;
}// 读取指令
// 从字符串中读取指令码和操作数
// 这里读取的是文本，而非二进制
// 所以指令码占2位，操作数占4位
void ReadInstruction(const string& strCodes)
{int idx = 0;Instruction ins;Command com;int     opd;while (idx < strCodes.size()){string strCod = strCodes.substr(idx, 2);idx += 2;cout << strCod;com = static_cast<Command>(atoi(strCod.c_str())); // 字符转换为指令码，不检测com是否合法int cnt = GetOperandCount(com);if (cnt > 0){string strOpd = strCodes.substr(idx, 4);idx += 4;opd = atoi(strOpd.c_str());cout << '\t' << strOpd;}else{opd = 0;}cout << endl;ins.com = com;ins.opd = opd;insMemory.push_back(ins);}
}// 执行指令
void ExecuteInstructions()
{for (auto idx = 0; idx < insMemory.size() && insMemory[idx].com != HALT; /*++idx*/){bool idxChg  = false;int  idxJump = 0;switch (insMemory[idx].com){case HALT: // 终止break;case IN:   // 输入
            {int tmp;cout << "输入：" << endl;cin >> tmp;stk.push(tmp);}break;case OUT:   // 输出
            {int tmp = stk.top();stk.pop();cout << tmp << endl;}break;case ADD:   // 加法
            {int a = stk.top();stk.pop();int b = stk.top();stk.pop();int c = b + a;stk.push(c);}break;case SUB:   // 减法
            {int a = stk.top();stk.pop();int b = stk.top();stk.pop();int c = b - a;stk.push(c);}break;case MUL:    // 乘法
            {int a = stk.top();stk.pop();int b = stk.top();stk.pop();int c = b * a;stk.push(c);}break;case DIV:    // 除法
            {int a = stk.top();stk.pop();int b = stk.top();stk.pop();if (a == 0){Error("除数为0");// 忽略
                }else{int c = b / a;stk.push(c);}}break;case INMEMORY:{int addr = insMemory[idx].opd;if (addr < 0 || addr >= datMemory.size()){Error("数据地址错误");// 忽略处理
                }else{datMemory[addr] = stk.top();stk.pop();}}break;case OUTMEMORY:{int addr = insMemory[idx].opd;if (addr < 0 || addr >= datMemory.size()){Error("数据地址错误");// 忽略处理
                }else{stk.push(datMemory[addr]);}}break;case DUP:    // 将栈顶元素的值重复压栈
            {stk.push(stk.top());}break;case LD:     // 弹出栈顶元素值，以值为地址，将该地址上的值压栈
            {int addr = stk.top();stk.pop();if (addr < 0 || addr >= datMemory.size()){Error("地址错误");// 忽略错误
                }else{stk.push(datMemory[addr]);}}break;case ST:     // 弹出值，再弹出地址，将值赋予该地址
            {int val = stk.top();stk.pop();int addr = stk.top();stk.pop();if (addr < 0 || addr >= datMemory.size()){Error("地址错误");// 忽略错误
                }else{datMemory[addr] = val;}}break;case LDC:    // 该指令有参数，将该参数压入栈中
            {stk.push(insMemory[idx].opd);}break;case JLT:    // 该指令有参数，如果从栈中弹出的值小于0，则指令指针寄存器跳转到操作数
            {int tmp = stk.top();stk.pop();if (tmp < 0){idxChg  = true;idxJump = insMemory[idx].opd;}}break;case JLE:    // <=
            {int tmp = stk.top();stk.pop();if (tmp <= 0){idxChg  = true;idxJump = insMemory[idx].opd;}}break;case JGT:    // >
            {int tmp = stk.top();stk.pop();if (tmp > 0){idxChg  = true;idxJump = insMemory[idx].opd;}}break;case JGE:    // >=
            {int tmp = stk.top();stk.pop();if (tmp >= 0){idxChg  = true;idxJump = insMemory[idx].opd;}break;}case JEQ:    // ==
            {int tmp = stk.top();stk.pop();if (tmp == 0){idxChg  = true;idxJump = insMemory[idx].opd;}}break;case JNE:    // !=
            {int tmp = stk.top();stk.pop();if (tmp != 0){idxChg  = true;idxJump = insMemory[idx].opd;}}break;case JMP:    // 无条件
            {idxChg  = true;idxJump = insMemory[idx].opd;}break;default:{Error("未知指令码");}break;}if (idxChg){idx = idxJump;}else{++idx;}}
}// 复位虚拟机
void Reset()
{insMemory.clear();datMemory.clear();datMemory.resize(101);while (!stk.empty()){stk.pop();}
}int main()
{// 测试虚拟机// 测试：// 输入两个数，并将其比较，将较大者输出//00 01      #输入第一个数                                          IN//01 01      #输入第二个数                                          IN//02 07 0001 #将数2存入到内存1中                                    INMEMORY//03 07 0000 #将数1存入到内存0中                                    INMEMORY//04 08 0000 #重新将内存0数入栈                                     OUTMEMORY//05 08 0001 #重新将内存1数入栈                                     OUTMEMORY//06 04      #将数1减去数2，数1和数2都弹栈，并将结果入栈            SUB//07 15 0011 #检测栈顶元素是否大于0，如果大于0进行跳转              JGT//08 08 0001 #如果不大于0，则将内存1输出，首先还是将内存1数入栈     OUTMEMORY//09 02      #将数1输出                                             OUT//10 19 0013 #无条件跳转到终止                                      JMP//11 08 0000 #如果大于0，则将内存0输出，首先还是将内存0数入栈       OUTMEMORY//12 02      #将数0输出                                             OUT//13 00      #终止                                                  HALT// 输入指令为：// 010107000107000008000008000104150011080001021900130800000200while (true){string strCodes;cin >> strCodes;ReadInstruction(strCodes);ExecuteInstructions();Reset();}return 0;
}

00 01      #输入第一个数                                         IN
01 01      #输入第二个数                                         IN
02 07 0001 #将数2存入到内存1中                                    INMEMORY
03 07 0000 #将数1存入到内存0中                                    INMEMORY
04 08 0000 #重新将内存0数入栈                                     OUTMEMORY
05 08 0001 #重新将内存1数入栈                                     OUTMEMORY
06 04      #将数1减去数2，数1和数2都弹栈，并将结果入栈                SUB
07 15 0011 #检测栈顶元素是否大于0，如果大于0进行跳转                  JGT
08 08 0001 #如果不大于0，则将内存1输出，首先还是将内存1数入栈          OUTMEMORY
09 02      #将数1输出                                           OUT
10 19 0013 #无条件跳转到终止                                      JMP
11 08 0000 #如果大于0，则将内存0输出，首先还是将内存0数入栈            OUTMEMORY
12 02      #将数0输出                                            OUT
13 00      #终止                                                HALT输入指令为：
010107000107000008000008000104150011080001021900130800000200