interpreter.java

一个C语言子集的编译器

		InfoPane.write(ConstSet.INTECOMPLETE);
		HandoutFrame.tb10.setEnabled(false);
		HandoutFrame.tb11.setEnabled(false);
		thr.stop();
	}

	/**
	 * 复制当前栈顶元素
	 */
	private void lstInstr() {
		try {
			StackUnit tmp = stack.pop();
			stack.push(tmp);
			stack.push(tmp);
		} catch (Exception e) {
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 根据栈顶与caseReg的值进行动作的方法 用于case语句处理
	 * 
	 * @see #Parser
	 */
	private void crjInstr() {
		try {
			StackUnit unit = stack.pop();
			// 相等
			if (Integer.parseInt(unit.value) == 1) {
				if (caseReg == 0) {
					caseReg = 1;
					stack.push(new StackUnit(ConstSet.INTEGER, "1"));
				} else {
					stack.push(new StackUnit(ConstSet.INTEGER, "1"));
				}
			}
			// 不相等
			else {
				if (caseReg == 0) {
					stack.push(new StackUnit(ConstSet.INTEGER, "0"));
				} else {
					stack.push(new StackUnit(ConstSet.INTEGER, "1"));
				}
			}
		} catch (Exception e) {
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * caseReg置零方法
	 */
	private void crcInstr() {
		caseReg = 0;
	}

	/**
	 * 强制栈顶类型转换方法
	 * 
	 * @param i
	 *            当前指令
	 */
	private void tpcInstr(Instruction i) {
		try {
			StackUnit unit = stack.pop();
			stack.push(new StackUnit(i.level, unit.value));
		} catch (Exception e) {
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 操作指令解释方法
	 * 
	 * @param i
	 *            当前指令
	 */
	private void oprInstr(Instruction i) {
		try {
			int instrNum = Integer.parseInt(i.value);
			switch (instrNum) {
			case ConstSet.OPR_INTADD:
				intAddInstr();
				break;
			case ConstSet.OPR_FLTADD:
				fltAddInstr();
				break;
			case ConstSet.OPR_INTSUB:
				intSubInstr();
				break;
			case ConstSet.OPR_FLTSUB:
				fltSubInstr();
				break;
			case ConstSet.OPR_INTMUL:
				intMulInstr();
				break;
			case ConstSet.OPR_FLTMUL:
				fltMulInstr();
				break;
			case ConstSet.OPR_INTDIV:
				intDivInstr();
				break;
			case ConstSet.OPR_FLTDIV:
				fltDivInstr();
				break;
			case ConstSet.OPR_MUNZERO:
				munZeroInstr();
				break;
			case ConstSet.OPR_LESS:
				jgLessInstr();
				break;
			case ConstSet.OPR_NGREAT:
				jgNGreatInstr();
				break;
			case ConstSet.OPR_EAQ:
				jgEqualInstr();
				break;
			case ConstSet.OPR_GREAT:
				jgGreatInstr();
				break;
			case ConstSet.OPR_NLESS:
				jgNLessInstr();
				break;
			case ConstSet.OPR_NEQU:
				jgNEquInstr();
				break;
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相加，默认为整型不做类型检查
	 */
	private void intAddInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			int tmp = Integer.parseInt(unit1.value)
					+ Integer.parseInt(unit2.value);
			stack.push(new StackUnit(ConstSet.INTEGER, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相加，默认为浮点型不做类型检查
	 */
	private void fltAddInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			float tmp = Float.parseFloat(unit1.value)
					+ Float.parseFloat(unit2.value);
			stack.push(new StackUnit(ConstSet.REAL, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相减，默认为整型不做类型检查
	 */
	private void intSubInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			int tmp = Integer.parseInt(unit2.value)
					- Integer.parseInt(unit1.value);
			stack.push(new StackUnit(ConstSet.INTEGER, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相减，默认为浮点型不做类型检查
	 */
	private void fltSubInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			float tmp = Float.parseFloat(unit2.value)
					- Float.parseFloat(unit1.value);
			stack.push(new StackUnit(ConstSet.REAL, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相乘，默认为整型不做类型检查
	 */
	private void intMulInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			int tmp = Integer.parseInt(unit1.value)
					* Integer.parseInt(unit2.value);
			stack.push(new StackUnit(ConstSet.INTEGER, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相乘，默认为浮点型不做类型检查
	 */
	private void fltMulInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			float tmp = Float.parseFloat(unit1.value)
					* Float.parseFloat(unit2.value);
			stack.push(new StackUnit(ConstSet.REAL, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相除，默认为整型不做类型检查
	 */
	private void intDivInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			if (Integer.parseInt(unit1.value) == 0) {
				ProblemPane.write("Fetal error! Zero divide!" + '\n');
				halt();
			}
			int tmp = Integer.parseInt(unit2.value)
					/ Integer.parseInt(unit1.value);
			stack.push(new StackUnit(ConstSet.INTEGER, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 将栈顶与次栈顶相除，默认为浮点型不做类型检查
	 */
	private void fltDivInstr() {
		try {
			StackUnit unit1 = stack.pop();
			StackUnit unit2 = stack.pop();
			if (Float.parseFloat(unit1.value) == 0.0) {
				ProblemPane.write("Fetal error! Zero divide!" + '\n');
				halt();
			}
			float tmp = Float.parseFloat(unit2.value)
					/ Float.parseFloat(unit1.value);
			stack.push(new StackUnit(ConstSet.REAL, tmp + ""));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 栈顶取相反数方法
	 */
	private void munZeroInstr() {
		try {
			StackUnit unit = stack.pop();
			if (unit.type == ConstSet.REAL) {
				unit.value = (-Float.parseFloat(unit.value)) + "";
			} else
				unit.value = (-Integer.parseInt(unit.value)) + "";
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 栈顶>0，=0，置栈顶为0；否则置为1
	 */
	private void jgLessInstr() {
		try {
			StackUnit unit = stack.pop();
			if (Float.parseFloat(unit.value) < 0.0)
				stack.push(new StackUnit(ConstSet.INTEGER, "1"));
			else
				stack.push(new StackUnit(ConstSet.INTEGER, "0"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 栈顶>0，置栈顶为0；否则置为1
	 */
	private void jgNGreatInstr() {
		try {
			StackUnit unit = stack.pop();
			if (Float.parseFloat(unit.value) <= 0.0)
				stack.push(new StackUnit(ConstSet.INTEGER, "1"));
			else
				stack.push(new StackUnit(ConstSet.INTEGER, "0"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 栈顶<0，>0，置栈顶为0；否则置为1
	 */
	private void jgEqualInstr() {
		try {
			StackUnit unit = stack.pop();
			if (Float.parseFloat(unit.value) == 0.0)
				stack.push(new StackUnit(ConstSet.INTEGER, "1"));
			else
				stack.push(new StackUnit(ConstSet.INTEGER, "0"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 栈顶<0，=0，置栈顶为0；否则置为1
	 */
	private void jgGreatInstr() {
		try {
			StackUnit unit = stack.pop();
			if (Float.parseFloat(unit.value) > 0.0)
				stack.push(new StackUnit(ConstSet.INTEGER, "1"));
			else
				stack.push(new StackUnit(ConstSet.INTEGER, "0"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 栈顶<0，置栈顶为0；否则置为1
	 */
	private void jgNLessInstr() {
		try {
			StackUnit unit = stack.pop();
			if (Float.parseFloat(unit.value) >= 0.0)
				stack.push(new StackUnit(ConstSet.INTEGER, "1"));
			else
				stack.push(new StackUnit(ConstSet.INTEGER, "0"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}
	private void jgNEquInstr(){
		try {
			StackUnit unit = stack.pop();
			if (Float.parseFloat(unit.value) == 0.0)
				stack.push(new StackUnit(ConstSet.INTEGER, "0"));
			else
				stack.push(new StackUnit(ConstSet.INTEGER, "1"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ProblemPane.write(e.toString() + '\n');
			halt();
		}
	}

	/**
	 * 解释执行异常停机方法
	 */
	@SuppressWarnings("deprecation")
	private void halt() {
		ProblemPane.write(ConstSet.INTEINTRUPT);
		ConsolePane.write(ConstSet.INTEINTRUPT);
		InfoPane.write(ConstSet.INTEINTRUPT);
		HandoutFrame.tb11.setEnabled(false);
		thr.stop();

	}

	/**
	 * 当前活动线程
	 */
	static Thread thr;

	/**
	 * 调试方式标志变量
	 */
	public static boolean isDebug = false;

	/**
	 * 当前执行指令
	 */
	private static Instruction crtInstr;

	/**
	 * 指令地址寄存器
	 */
	private static int px;

	/**
	 * 参数个数栈
	 */
	private static Stack<StackUnit> pCountStack = new Stack<StackUnit>();

	/**
	 * 返回值寄存器
	 */
	private static StackUnit retReg;

	/**
	 * 情况寄存器
	 */
	private static int caseReg = 0;

	/**
	 * 当前基地址指针
	 */
	private static int bx = 0;

	/**
	 * 数据运行栈
	 */
	private static StackVM stack = new StackVM();

	/**
	 * 代码栈
	 */
	private static ArrayList<Instruction> codeBuf = new ArrayList<Instruction>();
}