parsea.java

编译原理实验

//递归下降法  语法分析
import globle.DecKind;
import globle.Error;
import globle.ExpKind;
import globle.ExpType;
import globle.LexType;
import globle.NodeKind;
import globle.ParamType;
import globle.StmtKind;
import globle.Token;
import globle.TreeNode;
import globle.VarKind;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.swing.JOptionPane;
import javax.swing.border.TitledBorder;

public class ParseA implements ActionListener {
	private Iterator<Token> tokenList = null;
	private Token token = null; // 保存读的当前token
	private TreeNode root = null; // 保存语法树根节点
	private int indentno = 0; // 格式输出时应该输出的空格数
	private int lineno = 0; // 保存token的行号
	protected static boolean isError = false; // 判断是否词法分析有错
	private String temp_name; // 临时变量，保存token的语意信息
	protected static List<Error> error = new ArrayList<Error>();

	public void actionPerformed(ActionEvent e) {
		if (Scanner.isError) {
			JOptionPane.showMessageDialog(null, "词法分析有错，请改正再输入");
		} else {
			// 把词法分析的token序列保存到tokenList中
			tokenList = Scanner.list.iterator();
			root = parse();
			Translate.parseArea.setText("");
			Translate.parsePane.setBorder(new TitledBorder("递归下降法语法分析输出"));
			this.printTree(root);
			outIsError();
			Translate.parse[0].setEnabled(false);
	     	Translate.analyse.setEnabled(true);
		}
	}

	public void outIsError() {
		if (isError == true)
			Translate.parseArea.append("语法分析有错");
		else {
			Translate.parseArea.append("语法分析无错");
			return;
		}
		if (!error.isEmpty()) {
			Iterator iterator = error.iterator();
			while (iterator.hasNext()) {
				Error str = (Error) iterator.next();
				Translate.parseArea.append(str + "\n");
			}
		}

	}

	private TreeNode newRootNode()

	{
		// 在内存中动态申请分配单元，返回指向该单元的语法树结点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null) {
			error.add(new Error(lineno, "Out of memory isError"));
			isError = true;
		}
		// 语法树节点指针t不是null,成功分配内存单元 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null /
			t.sibling = null;

			// 指定新语法树节点t成员:结点类型nodekind为语句类型NodeKind.Prok /
			t.nodekind = NodeKind.ProK;

			// 指定新语法树节点t成员:源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}

		}
		// 函数返回语法树根节点指针t /
		return t;
	}

	// /
	// 函数名 newPheadNode /
	// 功 能 创建程序头类型语法树节点函数 /
	// 说 明 该函数为语法树创建一个新的程序头类型结点 /
	// 并将语法树节点成员初始化 /
	// /
	private TreeNode newPheadNode()

	{
		// 在内存中动态申请分配单元，返回指向该单元的语法树结点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null) {
			error.add(new Error(lineno, "out of memory"));
			isError = true;
		}
		// 语法树节点指针t不是null,成功分配内存单元 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null /
			t.sibling = null;

			// 指定新语法树节点t成员:结点类型nodekind为语句类型PheadK /
			t.nodekind = NodeKind.PheadK;

			// 指定新语法树节点t成员:源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			t.idnum = 0;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}

		}
		// 函数返回程序头类型语法树节点指针t /
		return t;
	}

	// /
	// 函数名 newDecANode /
	// 功 能 创建声明语法树节点函数,没有指明具体的节点声明 /
	// 类型,在语法树的第二层 /
	// 说 明 该函数为语法树创建一个新的结点 /
	// 并将语法树节点成员初始化 /
	// /
	private TreeNode newDecANode(NodeKind kind)

	{
		// 在内存中动态申请分配单元，返回指向该单元的语法树结点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null) {
			error.add(new Error(lineno, "out of memory"));
			isError = true;
		}
		// 语法树节点指针t不是null,成功分配内存单元 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null /
			t.sibling = null;

			// 指定新语法树节点t成员:结点类型nodekind为参数kind /
			t.nodekind = kind;

			// 指定新语法树节点t成员:源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}
		}
		// 函数返回语法树根节点指针t /
		return t;
	}

	// 尝试

	// /
	// 函数名 newTypeNode /
	// 功 能 类型标志语法树节点创建函数 /
	// 说 明 该函数为语法树创建一个新的类型标志结点， /
	// 表示在它之下的声明都为类型声明， /
	// 并将语法树节点的成员初始化 /
	// /
	private TreeNode newTypeNode()

	{
		// 内存中动态申请分配单元，返回指向该单元的语法树节点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null)
			error.add(new Error(lineno, "out of memory"));

		// 语法树节点指针t不是null,内存单元已经成功分配 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null(空) /
			t.sibling = null;

			// 指定新语法树节点t成员: 结点类型nodekind为表达式类型ExpK /
			t.nodekind = NodeKind.TypeK;

			// 指定新语法树节点t成员: 源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			t.idnum = 0;
			// 初始化符号表地址指针 /
			for (i = 0; i < 10; i++)
				t.table[i] = null;

		}

		// 函数返回表达式类型语法树结点指针t /
		return t;
	}

	// /
	// 函数名 newVarNode /
	// 功 能 变量声明标志语法树节点创建函数 /
	// 说 明 该函数为语法树创建一个新的变量声明标志结点，
	// 表示在它之下的声明都为变量声明， /
	// 并将语法树节点的成员初始化 /
	// /
	private TreeNode newVarNode()

	{
		// 内存中动态申请分配单元，返回指向该单元的语法树节点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null)
			error.add(new Error(lineno, "out of memory"));

		// 语法树节点指针t不是null,内存单元已经成功分配 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null(空) /
			t.sibling = null;

			// 指定新语法树节点t成员: 结点类型nodekind为表达式类型ExpK /
			t.nodekind = NodeKind.VarK;

			// 指定新语法树节点t成员: 源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			t.idnum = 0;
			// 初始化符号表地址指针 /
			for (i = 0; i < 10; i++)
				t.table[i] = null;
		}

		// 函数返回表达式类型语法树结点指针t /
		return t;
	}

	// 试试，如果行的话，就把它们合成一个！！！！

	// /
	// 函数名 newDecNode /
	// 功 能 创建声明类型语法树节点函数 /
	// 说 明 该函数为语法树创建一个新的声明类型结点 /
	// 并将语法树节点成员初始化 /
	// /
	private TreeNode newDecNode()

	{
		// 在内存中动态申请分配单元，返回指向该单元的语法树结点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null) {
			error.add(new Error(lineno, "out of memory"));
			isError = true;
		}

		// 语法树节点指针t不是null,成功分配内存单元 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null /
			t.sibling = null;

			// 指定新语法树节点t成员:结点类型nodekind为语句类型DecK /
			t.nodekind = NodeKind.DecK;

			// 指定新语法树节点t成员:源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			t.idnum = 0;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}

		}
		// 函数返回声明类型语法树节点指针t /
		return t;
	}

	// /
	// 函数名 newProcNode /
	// 功 能 创建函数类型语法树节点函数 /
	// 说 明 该函数为语法树创建一个新的函数类型结点 /
	// 并将语法树节点成员初始化 /
	// /
	private TreeNode newProcNode()

	{
		// 在内存中动态申请分配单元，返回指向该单元的语法树结点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null) {
			error.add(new Error(lineno, "out of memory"));
			isError = true;
		}
		// 语法树节点指针t不是null,成功分配内存单元 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null /
			t.sibling = null;

			// 指定新语法树节点t成员:结点类型nodekind为语句类型ProcDecK /
			t.nodekind = NodeKind.ProcDecK;

			// 指定新语法树节点t成员:源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			t.idnum = 0;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}

		}
		// 函数返回语句类型语法树节点指针t /
		return t;
	}

	// /
	// 函数名 newStmlNode /
	// 功 能 创建语句标志类型语法树节点函数 /
	// 说 明 该函数为语法树创建一个新的语句标志类型结点 /
	// 并将语法树节点成员初始化 /
	// /
	private TreeNode newStmlNode()

	{
		// 在内存中动态申请分配单元，返回指向该单元的语法树结点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null) {
			error.add(new Error(lineno, "out of memory"));
			isError = true;
		}
		// 语法树节点指针t不是null,成功分配内存单元 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null /
			t.sibling = null;

			// 指定新语法树节点t成员:结点类型nodekind为语句类型StmLK /
			t.nodekind = NodeKind.StmLK;

			// 指定新语法树节点t成员:源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			t.idnum = 0;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}

		}
		// 函数返回语句类型语法树节点指针t /
		return t;
	}

	TreeNode newStmtNode(StmtKind kind)

	{
		/* 在内存中动态申请分配单元，返回指向该单元的语法树结点类型指针t */
		TreeNode t = new TreeNode();

		int i;

		/***********************************************************************
		 * 语法树节点指针t为NULL,未能成功分配内存单元 将出错信息及行号lineno写入列表文件listing
		 */
		if (t == null) {
			error.add(new Error(lineno, "out of memory"));
			isError = true;
		}
		/* 语法树节点指针t不是NULL,成功分配内存单元 */
		else {

			/* 初始化新语法树节点t各子节点child[i]为NULL */
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			/* 初始化新语法树节点t兄弟节点sibling为NULL */
			t.sibling = null;

			/* 指定新语法树节点t成员:结点类型nodekind为语句类型StmtK */
			t.nodekind = NodeKind.StmtK;

			/* 指定新语法树节点t成员:语句类型kind.stmt为函数给定参数kind */
			t.kind.stmt = kind;