parseb.java

编译原理实验

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import globle.*;
import globle.Error;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
import parsell1.*;

import javax.swing.JOptionPane;
import javax.swing.border.TitledBorder;
public class ParseB implements ActionListener{

	private Iterator<Token> tokenList = null;
	private TreeNode root = null; // 保存语法树根节点
	  /*当前单词*/
	  Token  currentToken;
	  /*当前单词行号，用于给出错误提示信息*/
	  int  lineno;
	  /*LL1分析表*/
	  int LL1Table[][]=new int[104][104];
	  /*纪录当前语法树节点*/
	  TreeNode  currentP;

	  /*为保存类型需要的临时变量*/
	  DecKind  temp;
	  /*保存当前指针，以便修改后，将其恢复*/
	  TreeNode  saveP;

	  /*纪录表达式中，未匹配的左括号数目*/
	  int  expflag ;

	  /*判断简单表达式处理结束，整个表达式是否处理结束标识*/
	  /*当是条件表达式时，取假值，简单表达式时，取真值*/
	  /*用于函数preocess84*/
	  boolean  getExpResult ; 

	  /*仅用于数组变量，故初始化为假，遇到数组变量时，将其
	    改变为真，以便在函数process84中，即算术表达式结束时，
	    从语法树栈中弹出相应指针，将数组下标表达式的结构链入
	    节点中*/
	  boolean  getExpResult2 ;


	  /*符号栈顶指针*/
	   StackNode  stackTop;
	  /*栈空标志*/
	  boolean STACKEMPTY; 

	  /*语法树栈顶指针*/
	  StackNodePA  stackTopPA;
	  /*栈空标志*/
	  boolean  paSTACKEMPTY;

	  /*操作符栈的栈顶指针*/
	  StackNodeP  OpStackTop ;
	  /*操作符栈空标志*/
	  boolean OpSTACKEMPTY ;  

	  /*操作数栈的栈顶指针*/
	  StackNodeP NumStackTop ;
	  /*操作数栈空标志*/
	  boolean NumSTACKEMPTY ;
	  /* 静态变量indentno在函数printTree中	*/
	  int  indentno = 0;
	  protected static boolean isError = false; // 判断是否词法分析有错
	  protected static List<Error> error = new ArrayList<Error>();
	  
	  //保存非终极符数组
	  NontmlType nontmlType[];
	  //保存单词类别字符
	  LexType lexType[];
	  public ParseB()
	  {
		//初始化操作：


			/*纪录当前语法树节点*/
			currentP=null;

			/*为保存类型需要的临时变量*/
			temp=null;
			/*保存当前指针，以便修改后，将其恢复*/
			saveP =	null;

			/*纪录表达式中，未匹配的左括号数目*/
			expflag = 0;

			/*判断简单表达式处理结束，整个表达式是否处理结束标识*/
			/*当是条件表达式时，取假值，简单表达式时，取真值*/
			/*用于函数preocess84*/
			getExpResult =true; 

			/*仅用于数组变量，故初始化为假，遇到数组变量时，将其
			  改变为真，以便在函数process84中，即算术表达式结束时，
			  从语法树栈中弹出相应指针，将数组下标表达式的结构链入
			  节点中*/
			 getExpResult2 =false;

			 /*符号栈顶指针*/
			 stackTop=null;
			/*栈空标志*/
			 STACKEMPTY=true; 

			/*语法树栈顶指针*/
			 stackTopPA=null;
			/*栈空标志*/
			 paSTACKEMPTY=true;

			/*操作符栈的栈顶指针*/
			 OpStackTop=null;
			/*操作符栈空标志*/
			 OpSTACKEMPTY = true;  

			/*操作数栈的栈顶指针*/
			 NumStackTop=null;
			/*操作数栈空标志*/	
			 NumSTACKEMPTY = true;
			 
			 nontmlType=NontmlType.values();
			 lexType=LexType.values();
			 
	  
	  }

	public void actionPerformed(ActionEvent e)
	{
		if (Scanner.isError) {
			JOptionPane.showMessageDialog(null, "词法分析有错，请改正再输入");
		} else {
			// 把词法分析的token序列保存到tokenList中
			tokenList = Scanner.list.iterator();
			root = parseLL1();
			Translate.parseArea.setText("");
			Translate.parsePane.setBorder(new TitledBorder("LL1语法分析输出"));
			this.printTree(root);
			outisError();
			Translate.parse[1].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");
			}
		}

	}

	/**************实用函数********************/

	/********************************************************
	 *********以下是创建语法树所用的各类节点的申请***********
	 ********************************************************/

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

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

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

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

		/* 初始化新语法树节点t兄弟节点sibling为null */
		t.sibling = null;
	    
		/* 指定新语法树节点t成员:结点类型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									*/	
	/* 功  能 创建程序头类型语法树节点函数					*/
	/* 说  明 该函数为语法树创建一个新的程序头类型结点		*/
	/*        并将语法树节点成员初始化						*/
	/********************************************************/
	TreeNode  newPheadNode()

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

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

		/* 初始化新语法树节点t各子节点child[i]为null */
	    for (i=0;i<3;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									*/	
	/* 功  能 创建声明语法树节点函数,没有指明具体的节点声明 */
	/*        类型,在语法树的第二层			                */
	/* 说  明 该函数为语法树创建一个新的结点      	     	*/
	/*        并将语法树节点成员初始化						*/
	/********************************************************/
	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 error at line %d\n"));
		  isError = true;
	  }
	  /* 语法树节点指针t不是null,成功分配内存单元 */
	  else {

		/* 初始化新语法树节点t各子节点child[i]为null */
	    for (i=0;i<3;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									*/
	/* 功  能 类型标志语法树节点创建函数					*/
	/* 说  明 该函数为语法树创建一个新的类型标志结点，      */
	/*        表示在它之下的声明都为类型声明，        		*/
	/*        并将语法树节点的成员初始化					*/
	/********************************************************/
	TreeNode newTypeNode()

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

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

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

		/* 初始化新语法树节点t各子节点child[i]为null */
	    for (i=0;i<3;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									*/
	/* 功  能 变量声明标志语法树节点创建函数				*/
	/* 说  明 该函数为语法树创建一个新的变量声明标志结点，
	/*         表示在它之下的声明都为变量声明，           	*/
	/*        并将语法树节点的成员初始化					*/
	/********************************************************/
	TreeNode  newVarNode()

	{ 
	  /* 内存中动态申请分配单元，返回指向该单元的语法树节点类型指针t */
	  TreeNode t = new TreeNode();
	  
	
	  /* 语法树节点指针t为null,未能成功分配内存单元		*
	   * 将出错信息及行号lineno写入列表文件listing		*/
	  if (t==null)
	   error.add(new Error(lineno,"out of memory error at line "));

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

		/* 初始化新语法树节点t各子节点child[i]为null */
	    for (int i=0;i<3;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 (int i=0;i<10;i++)
		   t.table[i] = null;
	  }

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

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

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