executor.java

一种CMM语言的词法分析

				str = str.substring(2);
				strT = (str.length()==1)? "" : str.substring(1);
			}
			//以'-'号开始
			else {
				//计算第一个加减运算符号位置
				int location = -1;
				for (int i = 1; i < str.length(); i++) {
					if ("+-".indexOf(str.charAt(i))!=-1) {
						location = i;
						break;
					}
				}
				
				//获得第一个操作数的值
				String value1 = str.substring(0, location);
				int number1 = getNumber(value1, startIndex, endIndex);
				
				//计算第二个操作数的开始位置
				int end = str.length();
				for (int i = location+2; i < end; i++) {
					if ("+-".indexOf(str.charAt(i))!=-1) {
						end = i;
						break;
					}
				}
				//获得第二个操作数的值
				String value2 = str.substring(location+1, end);
				int number2 = getNumber(value2, startIndex, endIndex);
				
				//计算加减法
				int number = (str.charAt(location) == '+') ? number1 + number2 : number1 - number2;
				
				//生成进行一次加减法后的串
				str = (end==str.length()) ? number + "": number + str.substring(end);
				strT = (str.length()==1)? "" : str.substring(1);
			}
		}
		
		return getNumber(str, startIndex, endIndex);
	}
		
	/** 计算关系表达式的值
	 * 语法分析已保证格式正确
	 * String str 为关系表达式字符串*/
	private boolean computeRelation (String str, int startIndex, 
			int endIndex) throws MyRuntimeException {
		//将real替换为"#"
		str = str.replace("real", "#");
		
		/** 循环消去括号*/
		while (str.indexOf('[')+str.indexOf('(') != -2) {
			//查找第一个括号开的位置
			for (int i = 0; i <str.length(); i++) {
				if (str.charAt(i)=='[' || str.charAt(i)=='(') {
					/** 第一个括号开为中括号*/
					if (str.charAt(i)=='[') {
						//存储数组变量名开始位置
						int start = -1;
						for (int j = i; j >=0; j--) {
							//查找变量开始位置
							if ("+-*/<>=".indexOf(str.charAt(j))!=-1) {
								start = j;
								break;
							}
						}
						
						//获得的数组变量名
						String var = str.substring(start+1, i);
						
						//错误：变量未声明
						if (!isDeclared(var)) throw new MyRuntimeException(
								"变量 “" + var + "” 使用前未声明", startIndex, endIndex);
						
						//错误：变量声明为int型
						if (!isArrDeclared(var)) throw new MyRuntimeException(
								"对int型变量 “" + var + "” 使用索引", startIndex, endIndex);
						
						//计算对应括号闭位置
						int endBracket = SyntaxAnalyze.analyzeBracket(str, '[', ']', i);
						//递归计算索引值
						int index = computeArithmetic(
								str.substring(i+1, endBracket), startIndex, endIndex);
						
						//错误：索引值越界
						if (index < 0 || index >= getArrVar(var).length) 
							throw new MyRuntimeException("数组索引越界:    " + 
									"数组变量 “" + var + "”的长度：" + getArrVar(var).length + 
									"    错误的索引：" + index, startIndex, endIndex);
						
						//获取变量的值
						int value = getArrVar(var).getValue(index);
						
						//生成进行一次消括号后的串
						String strT1 = (start==-1) ? "" : str.substring(0, start+1);
						String strT2 = (endBracket==str.length()-1) ? 
								"" : str.substring(endBracket + 1, str.length());
						str = strT1 + value + strT2;
					}
					/** 第一个括号开为小括号*/
					else {
						//计算对应括号闭位置
						int endBracket = SyntaxAnalyze.analyzeBracket(str, '(', ')', i);
						String strT = str.substring(i+1, endBracket);
						String value = ""; 
						//小括号内返回值为布尔类型
						if (strT.indexOf('>')+strT.indexOf('<')+
								strT.indexOf('=')+strT.indexOf('#') != -4 ) 
							//获取小括号内布尔值，分别使用"#"、"!"表示返回值的true或false
							value += (computeRelation(strT, startIndex, endIndex)) ? "#" : "!";
						//小括号内返回值为数字
						else 
							//计算小括号内的值
							value += computeArithmetic(
									str.substring(i+1, endBracket), startIndex, endIndex);
						
						
						//生成进行一次消括号后的串
						String strT1 = (i==0) ? "" : str.substring(0, i);
						String strT2 = (endBracket==str.length()-1) ? 
								"" : str.substring(endBracket+1, str.length());
						str = strT1 + value + strT2;
					}
					break;
				}
			}
		}
		
		if (str.equals("!") || str.equals("!==#") || str.equals("#==!") || 
				str.equals("!<>!") || str.equals("#<>#")) return false;
		else if (str.equals("#") || str.equals("!<>#")||str.equals("#<>!") || 
				str.equals("!==!") || str.equals("#==#")) return true;
		/** 不含有"#"和"!"的情况*/
		else if (str.contains("==") || str.contains("<>")) {
			//计算关系运算符所在位置
			int locationT = str.indexOf('<');
			int location = (locationT > 0) ? locationT : str.indexOf('=');
				
			//获取两个用于比较的值
			int number1 = computeArithmetic(str.substring(0, location), startIndex, endIndex);
			int number2 = computeArithmetic(
					str.substring(location+2, str.length()), startIndex, endIndex);
				
			//进行比较
			switch (str.charAt(location)) {
				case '<': return number1 != number2;
				case '=': return number1 == number2;
			}
		}
		else {
			//计算关系运算符所在位置
			int locationT = str.indexOf('<');
			int location = (locationT > 0) ? locationT : str.indexOf('>');
				
			//获取两个用于比较的值
			int number1 = computeArithmetic (str.substring(0, location), startIndex, endIndex);
			int number2 = computeArithmetic (
					str.substring(location+1, str.length()), startIndex, endIndex);
				
			//进行比较
			switch (str.charAt(location)) {
				case '>': return number1 > number2;
				case '<': return number1 < number2;
			}
		}
		
		return false;
	}
		
	/** 获取数值
	 * @param str 变量名(可能含有负号)或数字的字符串
	 * @param startIndex 输入中的开始位置
	 * @param endIndex 输入中的结束位置
	 * @return 字符串表示的数字
	 * @throws MyRuntimeException
	 */
	private int getNumber (String str, int startIndex, int endIndex) throws MyRuntimeException {
		int value = 0;
		
		//检查是否数字
		try {
			value = Integer.parseInt(str);
		}
		//待获取为变量
		catch (Exception e) {
			//是否以'-'开头
			String strT = (str.charAt(0)=='-') ? str.substring(1) : str;
			//检查变量是否已声明
			if (!isDeclared(strT)) 
				throw new MyRuntimeException("变量 “" + strT + "” 使用前未声明", startIndex, endIndex);
			//检查变量是否声明为int型
			if (isIntDeclared(strT)) {
				//检查变量是否已初始化
				if (isEvaluated (strT)) 
					value = (str.charAt(0)=='-') ? -getIntVar(strT) : getIntVar(strT);
				else throw new MyRuntimeException(
						"变量 “" + strT + "” 使用前未初始化", startIndex, endIndex);
			}
			//变量声明为数组型
			else throw new MyRuntimeException(
					"在运算表达式中直接使用了数组变量 “" + strT + "”", startIndex, endIndex);
		}
		
		return value;
	}
		
	/** 使用具体值对数组进行赋值
	 * String str 为数组赋值(或初始化)使用的值*/
	private ArrayList<Integer> computeArrayData(String variable, String str, boolean evaluate,
			int startIndex, int endIndex) 
		throws MyRuntimeException {
		ArrayList<Integer> arrayData = new ArrayList<Integer>();
		
		while (str.indexOf(',')!=-1) {
			int end = str.indexOf(',');
			if (end == 0) {
				if (evaluate){
					arrayData.add(getArrVar(variable).value[arrayData.size()]);
				}
				else arrayData.add(0);
			}
			else arrayData.add(computeArithmetic(str.substring(0, end), startIndex, endIndex));
			str = str.substring(end+1);
		}
		arrayData.add(computeArithmetic(str, startIndex, endIndex));
		
		return arrayData;
	}
	
	/** 检查变量是否已声明*/
	//String variable 为变量名，以下所有方法中相同
	private boolean isDeclared (String variable) {
		if (isIntDeclared(variable) || isArrDeclared(variable)) return true;

		return false;
	}
	
	/** 检查int型变量是否已声明*/
	private boolean isIntDeclared (String variable) {
		for (Variable value:intList) 
			if (value.name.equals(variable)) return true;
		
		return false;
	}
	
	/** 检查数组变量是否已声明*/
	private boolean isArrDeclared (String variable) {
		for (ArrayVariable value:arrList) 
			if (value.name.equals(variable)) return true;
		
		return false;
	}
	
	/** 获取数组变量对象*/
	private ArrayVariable getArrVar (String variable) {
		for (ArrayVariable value:arrList) 
			if (value.name.equals(variable)) return value;
		
		return new ArrayVariable(variable, -1);
	}
	
	/** 获取int变量对象*/
	private int getIntVar (String variable) {
		for (Variable value:intList) 
			if (value.name.equals(variable)) return value.value;
		
		return 0;
	}
	
	/** 检查int型变量是否已初始化*/
	private boolean isEvaluated (String variable) {
		for (Variable value:intList) 
			if (value.name.equals(variable)) return value.evaluated;

		return false;
	}
	
	/** 设置int型变量值
	 * int value 为新变量值*/
	private void setIntVarValue (String variable, int value) {
		for (Variable var:intList) 
			if (var.name.equals(variable)) {
				var.setValue(value);
				break;
			}
	}
	
	/** 设置array型变量值
	 * 将以ArrayList<Integer>类型保存的数组变量值赋值与变量名为variable的数组变量*/
	private void setArrVarValue (String variable, ArrayList<Integer> valueList) {
		for (ArrayVariable var:arrList) 
			if (var.name.equals(variable)) {
				var.setValue(valueList);
				break;
			}
	}
	
	/** 设置array型变量值
	 * 将ArrayVariable型对象arrayVar赋值与变量名为variable的数组变量*/
	private void setArrVarValue (String variable, ArrayVariable arrayVar) {
		for (ArrayVariable var:arrList) 
			if (var.name.equals(variable)) {
				var.setValue(arrayVar);
				break;
			}
	}
	
	/** 设置array型变索引index处的值
	 * int indexValue索引index处新的值*/
	private void setArrIndexValue (String variable, int index, int indexValue) {
		for (ArrayVariable var:arrList) 
			if (var.name.equals(variable)) {
				var.setIndexValue(index, indexValue);
				break;
			}
	}
	
	/** 信息窗口
	 * 继承JDialog并将属性设为模式的以保证打开此窗口时只有关闭后才能进行其他操作
	 * 实现ActionListener接口以响应事件*/
	class DialogAdapter extends JDialog implements ActionListener {
		//提供信息的文件名
		private String fileName = "";
		
		//构造方法
		public DialogAdapter(int index) {
			this(null, index);
		}
		
		//构造方法
		public DialogAdapter(JFrame parent, int index) {
			//调用JDialog构造方法，设置此窗口为模式的
			super(parent, true);
			
			String frameName = (index==1) ? "更新及使用说明" : "关于执行代码";
			fileName = (index==1) ? "更新及使用说明.txt": "关于执行代码.txt";
			
			//窗口属性
			setTitle(frameName);
			setSize(550, 600);
			Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
			setLocation((d.width - getSize().width) / 2,
					(d.height - getSize().height) / 2);
		}
		
		/** 响应事件*/
		public void actionPerformed(ActionEvent evt) {
			//文本属性
			JTextArea jtaExplain = new JTextArea();
			jtaExplain.setWrapStyleWord(true);
			jtaExplain.setLineWrap(true);
			jtaExplain.setEditable(false);
			jtaExplain.setTabSize(2);
			JScrollPane jspExplain = new JScrollPane(jtaExplain);
			add(jspExplain);
			
			//读入信息文件内容
			try {
				BufferedReader input = new BufferedReader(new FileReader(fileName));
				String line;
				while ((line = input.readLine()) != null) 
					jtaExplain.append(line + "\n");
				input.close();
			}
			catch (IOException ex) {
				jtaExplain.setText("文件不在指定位置！\n    请检查文件的位置！");
			}
			
			//显示信息窗口
			setVisible(true);
		}
	}
	
	/** 运行时发现错误的异常类*/
	class MyRuntimeException extends Exception{
		//产生错误的类型
		private String reason = "";
		public int start = -1;
		public int end = -1;
		
		//构造方法
		public MyRuntimeException(String reason, int start, int end) {
			this.reason = reason;
			this.start = start;
			this.end = end;
		}
		
		//错误输出
		public String toString() {
			return reason;
		}
	}
}