grammeranalyer.java

使用Eclipse开发的词法分析器和语法分析器

package com.lxx.compiler;
import java.io.*;
import java.util.*;

class Node
{
	public String left;
	public String right;
	public Node(String left,String right)
	{
		this.left=left;
		this.right=right;
	}
	
}
class TYPE
{
	static int VN=1;
	static int VT=2;
}

class TreeNode
{
	public TreeNode son;
	public TreeNode brother;
	public int type;
	public String value;
}

public class GrammerAnalyer {
	private LexicalAnalyer lexAnalyer;
	private String GrammerFileName;
	public  LinkedList grammer;
	public  LinkedList VNList;
	public  Queue OutPutQueue;
	private TreeNode GrammerSeachTree;
	public LinkedList generateLink;
	
	public GrammerAnalyer(String inputFile,String keyFile,String limitFile,String operatorFile,String GrammerFileName) throws Exception
	{
		lexAnalyer=new LexicalAnalyer(inputFile,keyFile,limitFile,operatorFile);
		VNList=new LinkedList();
		this.GrammerFileName=GrammerFileName;
		this.GrammerSeachTree=new TreeNode();
		this.generateLink=new LinkedList();
		ReadGrammer();	
		this.GenerateTree();
	}
	
	private void ReadGrammer() throws Exception
	{
		BufferedReader reader=new BufferedReader(new FileReader(this.GrammerFileName));
		int countLine=0;
		while(reader.readLine()!=null)
		{
			countLine++;
		}
		grammer=new LinkedList();
		reader.close();
		reader=new BufferedReader(new FileReader(this.GrammerFileName));
		String temp;
		int i=0;
		while((temp=reader.readLine())!=null)
		{
			if(temp.equals(""))
				continue;
			Node node=new Node(temp.substring(0,temp.indexOf("->")).trim(),temp.substring(temp.indexOf("->")+2).trim());
			grammer.add(node);
			if(!VNList.contains(node.left))
				VNList.add(node.left);
		}		
		reader.close();
	}
	
	private boolean IsVN(String symbol)
	{
		for(int i=0;i<VNList.size();i++)
		{
			if(((String)VNList.get(i)).equals(symbol))
				return true;			
		}
		return false;
	}
	
	
	private void GenerateTree()
	{
		String VN;
		Node node;
		String []temp;
		TreeNode currentNode=GrammerSeachTree;
		TreeNode currentVNNode=GrammerSeachTree;
		TreeNode treeNode;
		for(int i=0;i<grammer.size();i++)
		{
			node=(Node)grammer.get(i);
			treeNode=new TreeNode();
			treeNode.type=TYPE.VN;
			treeNode.value=node.left;
			treeNode.son=treeNode.brother=null;
			currentVNNode.son=treeNode;
			currentNode=currentVNNode=treeNode;
			temp=node.right.split("/0");
			for(int j=0;j<temp.length;j++)
			{
				treeNode=new TreeNode();
				treeNode.son=null;
				treeNode.brother=null;
				if(IsVN(temp[j]))
					treeNode.type=TYPE.VN;
				else
					treeNode.type=TYPE.VT;
				treeNode.value=temp[j];
				currentNode.brother=treeNode;
				currentNode=treeNode;
			}
		}
	}

	private boolean Match(Token token,String symbol)
	{
		if(symbol.equals("KEY")&&token.tokenValue==TokenValue.KEY)
			return true;
		if(symbol.equals("OPERATOR")&&token.tokenValue==TokenValue.OPERATOR)
			return true;
		if(symbol.equals("LIMIT")&&token.tokenValue==TokenValue.LIMIT)
			return true;
		if(symbol.equals("CONST")&&token.tokenValue==TokenValue.CONST)
			return true;
		if(symbol.equals("SYMBOL")&&token.tokenValue==TokenValue.SYMBOL)
			return true;
		if(symbol.equals(token.stringValue))
			return true;
		return false;
	}
	
	private TreeNode FindMatchVNNode(Token token)
	{
		for(TreeNode treeNode1=this.GrammerSeachTree.son;treeNode1!=null;treeNode1=treeNode1.son)
		{
			if(Match(token,treeNode1.value))
			{
				return treeNode1;
			}
		}
		return null;
	}
	
	
	private int Recursion(TreeNode treeNode,Token token) throws Exception
	{
		Token token1;
		TreeNode treeNode1;
		int temp;
		if(token==null||treeNode==null)
		{
			if(treeNode==null&&token==null)
				return 1;
			if(treeNode==null)
				return -1;
			return 0;
		}
		if(treeNode.type==TYPE.VT)
		{
			if(Match(token,treeNode.value))
			{
				if(treeNode.brother==null)
					return -1;
				if(Recursion(treeNode.brother,this.lexAnalyer.NextToken())==0)
					return 0;
				return 1;
			}
			/*
			else if(treeNode.brother.value.equals("E"))
			{
				if(Recursion(treeNode.brother,token)==0)
					return 0;	
				return 1;		
			}
			*/
			else
				return 0;
		}
		else
		{
			for(treeNode1=this.GrammerSeachTree.son;treeNode1!=null;treeNode1=treeNode1.son)
			{
				if(treeNode1.value.equals(treeNode.value)&&treeNode1!=treeNode)
				{
					if(Match(token,treeNode1.brother.value))	
				    {
						this.generateLink.addLast(treeNode1);
						if(Recursion(treeNode1.brother,token)==0)
							return 0;
						if(treeNode.brother==null)
							return -1;
						if(Recursion(treeNode.brother,this.lexAnalyer.NextToken())==0)
							return 0;
						return 1;
					}
				}
				/*
				else if(treeNode1.brother.equals("E"))
				{
					this.generateLink.addLast(treeNode1);
					if(Recursion(treeNode.brother,token)==0)
						return 0;
					return 1;
				}
				*/
			}
			if(treeNode1==null)
				return 0;
		}
		return 1;
	}
	
	public void Analyer() throws Exception
	{
		TreeNode treeNode,treeNode1;
		BufferedWriter writer=new BufferedWriter(new FileWriter("g.txt"));
		for(treeNode=this.GrammerSeachTree.son;treeNode!=null;treeNode=treeNode.son)
		{
			if(treeNode.value.equals("S"))
				break;
		}
		treeNode1=treeNode;
		writer.write(treeNode.value);
		writer.write("->");
		while((treeNode=treeNode.brother)!=null)
		{
			writer.write(treeNode.value);
			writer.write(" ");
		}
		writer.write("\r\n");
		int flag=this.Recursion(treeNode1.brother,this.lexAnalyer.NextToken());
		if(flag==1)
		{
			System.out.println("识别成功");
		}
		else
		{
			System.out.println("识别失败");
			System.out.print("错误发生在： ");
			System.out.println(this.lexAnalyer.currentLine);
		}
		System.out.println("推导过程：");
		for(int i=0;i<this.generateLink.size();i++)
		{
			treeNode=(TreeNode)this.generateLink.get(i);
			System.out.print(treeNode.value);
			System.out.print("->");
			writer.write(treeNode.value);
			writer.write("->");
			while((treeNode=treeNode.brother)!=null)
			{
				System.out.print(treeNode.value);
				writer.write(treeNode.value);
				System.out.print(" ");
				writer.write(" ");
			}
			System.out.print("\r\n");
			writer.write("\r\n");
		}
		writer.flush();
		writer.close();
		this.lexAnalyer.inputReader.close();
	}
}