executor.java

一种CMM语言的词法分析

/*
*  吕渊 200532580144
*  使用工具：eclipse
*  Java SE 6
*  
*  完成日期：2007-11-15
*  最后修改：2007-12-12
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;

public class Executor extends Analyzer{
	//图标
	ImageIcon ExecuteIcon = new ImageIcon("Icon/Execute.png");
	
	//菜单项
	private JMenuItem jmiExecute = new JMenuItem("执行代码", ExecuteIcon);
	private JMenuItem jmiExplain = new JMenuItem("更新及使用说明");
	private JMenuItem jmiAboutExe = new JMenuItem("关于执行代码");
	
	private ArrayList<Variable> intList = new ArrayList<Variable>();//当前可用普通变量
	private ArrayList<ArrayVariable> arrList = new ArrayList<ArrayVariable>();//当前可用数组变量
	
	public Executor() {
		//菜单
		jMenuExe.removeAll();
		jMenuExe.add(lexicalAnalyzer);
		jMenuExe.add(syntaxAnalyzer);
		jMenuExe.add(jmiExecute);
		jMenuExe.addSeparator();
		jMenuExe.add(jMenuClean);
		
		JMenu jmiAbout = new JMenu("关于(A)");
		jmiAbout.setMnemonic('A');
		jmiAbout.add(jmiExplain);
		jmiAbout.addSeparator();
		jmiAbout.add(jmiAboutExe);
		
		jMenuBar.add(jmiAbout);
		
		//操作快捷键
		jmiExecute.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_E, ActionEvent.CTRL_MASK));
		
		/** 执行*/
		jmiExecute.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent evt) {
				//输入为空
				if (jta.getText().trim().equals(""))
					JOptionPane.showMessageDialog (null, "请输入!", 
							"Notice", JOptionPane.INFORMATION_MESSAGE);
				else {
					SyntaxAnalyze syntax = new SyntaxAnalyze(jta.getText());
					
					//语法分析发现错误
					if (syntax.syntaxError == true) {
						center.setLeftComponent(new JScrollPane(
								new JTree(new DefaultMutableTreeNode("Syntax Tree"))));
						for(String value: syntax.toArrayList())
							listModel.addElement(value);
						change = false;
						if (syntax.lexicalError == true) {
							JOptionPane.showMessageDialog (null, "词法分析发现错误!", 
									"Notice", JOptionPane.INFORMATION_MESSAGE);
							tokenStart = syntax.tokenStart;
							tokenEnd = syntax.tokenEnd;
						}
						else if (syntax.syntaxError == true) {
							JOptionPane.showMessageDialog (null, "含有语法错误!", 
									"Notice", JOptionPane.INFORMATION_MESSAGE);
							tokenStart = syntax.tokenErrorStart;
							tokenEnd = syntax.tokenErrorEnd;
						}
					}
					//语法分析正确
					else {
						center.setLeftComponent(new JScrollPane(
								new JTree(new DefaultTreeModel(syntax.syntaxTree))));
						Execute(syntax);
					}
					change = false;
				}
			}
		});
		
		//更新及使用说明
		jmiExplain.addActionListener(new DialogAdapter(1));
		
		//关于执行代码
		jmiAboutExe.addActionListener(new DialogAdapter(2));
	}	
	
	public static void main(String[] args) {
		Executor applet = new Executor();
		
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(3);
		frame.setTitle("CMM Executor Beta2");
		frame.getContentPane().add(applet, BorderLayout.CENTER);
		applet.init();
		applet.start();
		Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
		frame.setSize(d.width*4/5,d.height*9/10);
		frame.setLocation(d.width / 10, d.height / 20);
		frame.setVisible(true);
	}
	
	/** 执行代码*/
	public void Execute(SyntaxAnalyze syntax) {
		//执行代码
		try {
			intList.clear();
			arrList.clear();
			tokenStart.clear();
			tokenEnd.clear();
			listModel.clear();
			execute(purify(syntax.syntaxTree), syntax.deep, syntax.tokenRightStart, syntax.tokenRightEnd);
		}
		//执行过程中发现错误
		catch (MyRuntimeException e) {
			listModel.addElement("执行过程发现错误!");
			tokenStart.add(e.start);
			tokenEnd.add(e.end);
			listModel.addElement("    " + e);
			tokenStart.add(e.start);
			tokenEnd.add(e.end);
			JOptionPane.showMessageDialog (null, "执行过程发现错误!", 
					"Notice", JOptionPane.INFORMATION_MESSAGE);
		}
	}
		
	/** 使用语法分析生成的tree图形(syntaxTree属性)生成程序可运行代码部分
	 *结合同时生成的代码属性即可执行*/
	private LinkedList<String> purify (DefaultMutableTreeNode tree) {
		LinkedList<String> listT = new LinkedList<String>();
			
		//遍历语法树，添加每个节点到listT中(除数组声明时若指定长度则添加时保留":"外其他含有":"的全部只保留":"之后的部分)
		Enumeration preorder = tree.preorderEnumeration();
		while(preorder.hasMoreElements()) {
			String str = preorder.nextElement().toString();
				
			if (str.indexOf(':')!=-1) {
				if (str.substring(0, str.indexOf(':')).endsWith("长度")) 
					str = str.substring(str.indexOf(':'));
				else 
					str = str.substring(str.indexOf(':')+1);
			}
				
			listT.add(str.trim());
		}
		
		listT.removeFirst();//移除无用内容:"Tree"
			
		return listT;
	}
	
	/** 执行语句块(参数含义以下函数中相同)
	 * @param listT 经过滤后的生成的本函数可识别的执行语句
	 * @param deepT 语句的嵌套层次
	 * @param startIndex 输入中的开始位置
	 * @param endIndex 输入中的结束位置
	 * @throws MyRuntimeException
	 */
	private void execute(LinkedList<String> listT, LinkedList<Integer> deepT, 
			ArrayList<Integer> startIndex, ArrayList<Integer> endIndex) 
		throws MyRuntimeException{
		//进入block时将当前可用变量的个数备份
		int length1 = intList.size();
		int length2 = arrList.size();
		
		//进行语句的顺序执行
		matchingExecute(listT, deepT, startIndex, endIndex);
			
		//block结束时将当前可用变量的线性表还原
		intList = new ArrayList<Variable>(intList.subList(0, length1));
		arrList = new ArrayList<ArrayVariable>(arrList.subList(0, length2));
	}
		
	/** 语句的顺序执行*/
	private void matchingExecute(LinkedList<String> listT, LinkedList<Integer> deepT, 
		ArrayList<Integer> startIndex, ArrayList<Integer> endIndex) throws MyRuntimeException{
		//含有待执行语句
		while (listT.size()!=0) {
			//第一个待执行语句的嵌套层次
			int startDeep = deepT.getFirst();
			/** int型变量声明*/
			if (listT.getFirst().equals("int型变量声明")) {
				//错误：变量已声明
				if (isDeclared(listT.get(1))) 
					throw new MyRuntimeException("变量 “" + listT.get(1) + "” 已声明",
						startIndex.get(1), endIndex.get(1));
					
				//声明int型变量而不初始化
				if (listT.size()==2) {
					//向当前变量数据集添加变量
					intList.add(new Variable(listT.get(1)));
						
					//剩余待执行语句
					listT.clear();
				}
				//声明int型变量而不初始化
				else if (deepT.get(2) == startDeep) {
					//向当前变量数据集添加变量
					intList.add(new Variable(listT.get(1)));
						
					//剩余待执行语句
					listT.removeFirst();listT.removeFirst();
					deepT = new LinkedList<Integer>(deepT.subList(2, deepT.size()));
					startIndex = new ArrayList<Integer>(startIndex.subList(2, startIndex.size()));
					endIndex = new ArrayList<Integer>(endIndex.subList(2, endIndex.size()));
				}
				//声明int型变量并进行初始化
				else {
					//向当前变量数据集添加变量(含有变量值)
					intList.add(new Variable(listT.get(1), 
							computeArithmetic(listT.get(2), startIndex.get(2), endIndex.get(2))));
						
					//剩余待执行语句
					listT.removeFirst();listT.removeFirst();listT.removeFirst();
					if (deepT.size() != 3) {
						deepT = new LinkedList<Integer>(deepT.subList(3, deepT.size()));
						startIndex = new ArrayList<Integer>(startIndex.subList(3, startIndex.size()));
						endIndex = new ArrayList<Integer>(endIndex.subList(3, endIndex.size()));
					}
				}
			}
			/** array型变量声明*/
			else if (listT.getFirst().equals("array型变量声明")) {
				//错误：变量已声明
				if (isDeclared(listT.get(1))) 
					throw new MyRuntimeException("变量 “" + listT.get(1) + "” 已声明",
							startIndex.get(1), endIndex.get(1));
				
				String value = listT.get(2);
				//根据指定长度创建数组变量
				if (value.charAt(0)==':') {
					int length = computeArithmetic(value.substring(1).trim(), 
								startIndex.get(2), endIndex.get(2));
					if (length <= 0) throw new MyRuntimeException("不能声明长度为" + length + "的数组变量",
								startIndex.get(2), endIndex.get(2));
					arrList.add(new ArrayVariable(listT.get(1), length));
				}
					
				//根据指定值创建数组变量
				else if (value.charAt(0)=='{') 
					arrList.add(new ArrayVariable(listT.get(1), computeArrayData("", 
								listT.get(2).substring(1, listT.get(2).length()-1), false, 
								startIndex.get(2), endIndex.get(2))) );
				//其他：使用现有变量创建数组变量
				//错误：变量未声明
				else if (!isDeclared(value)) 
					throw new MyRuntimeException("变量 “" + value + "” 使用前未声明", 
							startIndex.get(2), endIndex.get(2));
				//错误：变量类型不同
				else if (!isArrDeclared(value)) 
					throw new MyRuntimeException("将int型变量 “" + value + "” 赋值给array型变量", 
							startIndex.get(2), endIndex.get(2));
				//创建数组变量
				else arrList.add(new ArrayVariable(listT.get(1), getArrVar(value)));
				
				//剩余待执行语句
				
				listT.removeFirst();listT.removeFirst();listT.removeFirst();
				if (deepT.size() != 3) {
					deepT = new LinkedList<Integer>(deepT.subList(3, deepT.size()));
					startIndex = new ArrayList<Integer>(startIndex.subList(3, startIndex.size()));
					endIndex = new ArrayList<Integer>(endIndex.subList(3, endIndex.size()));
				}
			}
			/** 赋值语句*/
			else if (listT.getFirst().equals("赋值语句")) {
				//执行赋值语句
				evaluateExe(new LinkedList<String>(listT.subList(0, 3)), 
						startIndex.get(1), endIndex.get(1), startIndex.get(2), endIndex.get(2));
				
				//剩余待执行语句
				listT.removeFirst();listT.removeFirst();listT.removeFirst();
				if (deepT.size() != 3) {
					deepT = new LinkedList<Integer>(deepT.subList(3, deepT.size()));
					startIndex = new ArrayList<Integer>(startIndex.subList(3, startIndex.size()));
					endIndex = new ArrayList<Integer>(endIndex.subList(3, endIndex.size()));
				}
			}
			/** 输出语句*/
			else if (listT.getFirst().equals("输出")) {
				//分别进行数组的完整输出与表达式的输出
				String ouput = (isArrDeclared(listT.get(1))) ? 
						getArrVar(listT.get(1)).toString() : 
						computeArithmetic(listT.get(1), startIndex.get(1), endIndex.get(1)) + "";
				tokenStart.add(startIndex.get(1));
				tokenEnd.add(endIndex.get(1));
				listModel.addElement(ouput);
				//剩余待执行语句
				listT.removeFirst();listT.removeFirst();
				if (deepT.size() != 2) {
					deepT = new LinkedList<Integer>(deepT.subList(2, deepT.size()));
					startIndex = new ArrayList<Integer>(startIndex.subList(2, startIndex.size()));
					endIndex = new ArrayList<Integer>(endIndex.subList(2, endIndex.size()));
				}
			}
			/** 读入语句*/
			else if (listT.getFirst().equals("读入")) {
				//执行读入语句
				readExe(new LinkedList<String>(listT.subList(0, 2)), startIndex.get(1), endIndex.get(1));
				
				//剩余待执行语句
				listT.removeFirst();listT.removeFirst();
				if (deepT.size() != 2) {
					deepT = new LinkedList<Integer>(deepT.subList(2, deepT.size()));
					startIndex = new ArrayList<Integer>(startIndex.subList(2, startIndex.size()));
					endIndex = new ArrayList<Integer>(endIndex.subList(2, endIndex.size()));
				}
			}
			/** 循环语句*/
			else if (listT.getFirst().equals("循环语句")) {
				//计算语句体结束位置
				int end = new LinkedList<Integer>(
						deepT.subList(1, deepT.size())).indexOf(startDeep);
				if (end == -1) end = deepT.size();
				else end += 1;
				
				boolean booleanT = computeRelation (listT.get(1), startIndex.get(1), endIndex.get(1));
				//错误：布尔值为true而无执行语句，进入死循环
				if (end==2 && booleanT) 
					throw new MyRuntimeException("没有执行语句，循环无法结束",
							startIndex.get(0), endIndex.get(0));
				//错误：布尔值为true而表达式不含有变量，进入死循环
				if (booleanT && !containVar(listT.get(1))) 
					throw new MyRuntimeException("不含有变量，布尔表达式的值永远为真，循环无法结束",
							startIndex.get(0), endIndex.get(0));
				
				//执行循环语句
				while(computeRelation (listT.get(1), startIndex.get(1), endIndex.get(1))) 
					execute(new LinkedList<String>(listT.subList(2, end)), 
							new LinkedList<Integer>(deepT.subList(2, end)),
							new ArrayList<Integer>(startIndex.subList(2, end)),
							new ArrayList<Integer>(endIndex.subList(2, end)));
				
				//剩余待执行语句
				if (end==deepT.size())	listT.clear();
				else {
					listT = new LinkedList<String>(listT.subList(end, listT.size()));
					deepT = new LinkedList<Integer>(deepT.subList(end, deepT.size()));
					startIndex = new ArrayList<Integer>(startIndex.subList(end, startIndex.size()));
					endIndex = new ArrayList<Integer>(endIndex.subList(end, endIndex.size()));
				}
			}
			/** 条件语句*/
			else {
				//计算语句块结束位置
				int end = new LinkedList<Integer>(deepT.subList(1, deepT.size())).indexOf(startDeep);
				if (end == -1) end = deepT.size();
				else end += 1;

				//执行条件语句
				ifClauseExe(new LinkedList<String>(listT.subList(1, end)), 
						new LinkedList<Integer>(deepT.subList(1, end)),
						new ArrayList<Integer>(startIndex.subList(1, end)),
						new ArrayList<Integer>(endIndex.subList(1, end)));
				
				//剩余待执行语句
				if (end==deepT.size())
					listT.clear();
				else {
					listT = new LinkedList<String>(listT.subList(end, listT.size()));
					deepT = new LinkedList<Integer>(deepT.subList(end, deepT.size()));
					startIndex = new ArrayList<Integer>(startIndex.subList(end, startIndex.size()));
					endIndex = new ArrayList<Integer>(endIndex.subList(end, endIndex.size()));
				}
			}
		}
	}
		
	/** 检查布尔表达式是否含有变量*/
	private boolean containVar (String str) {
		for (Variable value:intList) if (str.contains(value.name)) return true;
		for (ArrayVariable value:arrList) if (str.contains(value.name)) return true;
			
		return false;
	}
		
		
	/** 条件语句的执行*/
	private void ifClauseExe (LinkedList<String> ifClause, LinkedList<Integer> deepT, 
			ArrayList<Integer> startIndex, ArrayList<Integer> endIndex) throws MyRuntimeException{
		//第一个待执行语句的嵌套层次
		int startDeep = deepT.getFirst();
			
		//一次遍历布尔表达式