syntaxparser.java

编译器

import java.util.*;

public class SyntaxParser 
{
	private Word[] tokens;
	private int tokenIndex;
	private int tokenNum;
	public SyntaxParser(ArrayList<Word> list)
	{
		tokens = list.toArray(new Word[0]);
		tokenIndex = 0;
		tokenNum = tokens.length;
	}
	public void indent(int spaces)
	{
		for(int i=0;i<spaces;i++)
			System.out.print(" ");
	}
	public void match(String token)
	{
		try
		{
			if(tokens[tokenIndex].getSymbol().equals(token))
				tokenIndex++;
			else
				System.out.println(token+" needed in line "+tokens[tokenIndex-1].getLine());
		}
		catch(ArrayIndexOutOfBoundsException exp)
		{
			System.out.println(tokens[tokenIndex-1].getSymbol()+" needed in line "+tokens[tokenIndex-1].getLine());
		}
	}

	public SyntaxNode stmts(String name)
	{
		SyntaxNode stmts = new SyntaxNode(name,"");
		//while中保证没有到达终点
		while(tokenIndex<tokenNum&&
				!(tokens[tokenIndex].getSymbol().equals("RIGHT}")||//到达}则语句序列结束
				  tokens[tokenIndex].getSymbol().equals("#")))//把tokenIndex<tokenNum写到前面，保证后面的不越界
		{
			String tempToken = tokens[tokenIndex].getSymbol();
			if(tempToken.equals("read")) stmts.addChild(read());
			else if(tempToken.equals("if")) stmts.addChild(ifStmt());
			else if(tempToken.equals("while")) stmts.addChild(whileStmt());
			else if(tempToken.equals("ID")) stmts.addChild(assign());
			else if(tempToken.equals("do")) stmts.addChild(dowhile());
			else if(tempToken.equals("write")) stmts.addChild(write());
			else
			{
				System.out.println("wrong sentenses in line "+tokens[tokenIndex].getLine());
				break;
			}
		}
		return stmts;
	}
	
	public SyntaxNode read()
	{
		SyntaxNode stmt = new SyntaxNode("read","");
		try
		{
			match("read");
			match("ID");
			SyntaxNode node = new SyntaxNode(tokens[tokenIndex-1].getWord(),"ID");
			stmt.addChild(node);
			match("SEMICOLON");
		}
		catch(ArrayIndexOutOfBoundsException exp)
		{
			System.out.println("uncompleted stmts.");
		}
		return stmt;
	}
	
	public SyntaxNode ifStmt()
	{
		match("if");
		SyntaxNode node = new SyntaxNode("if","");
		match("LEFT(");
		SyntaxNode exp = exp();
		node.addChild(exp);
		match("RIGHT)");
		match("LEFT{");
		SyntaxNode thenStmt = stmts("then");
		node.addChild(thenStmt);
		match("RIGHT}");
		if(tokenIndex<tokenNum&&tokens[tokenIndex].getSymbol().equals("else"))
		{
			match("else");
			SyntaxNode elseNode = new SyntaxNode("else","");
			match("LEFT{");
			SyntaxNode elseStmt = stmts("else");
			elseNode.addChild(elseStmt);
			node.addChild(elseStmt);
			match("RIGHT}");
		}
		return node;
	}
	
	public SyntaxNode whileStmt()
	{
		SyntaxNode whileNode = new SyntaxNode("while","");
		match("while");
		match("LEFT(");
		whileNode.addChild(exp());
		match("RIGHT)");
		match("LEFT{");
		whileNode.addChild(stmts("body"));
		match("RIGHT}");
		return whileNode;
	}
	
	public SyntaxNode dowhile()
	{
		SyntaxNode doNode = new SyntaxNode("do","");
		match("do");
		match("LEFT{");
		doNode.addChild(stmts("do_body"));
		match("RIGHT}");
		match("while");
		SyntaxNode whileNode = new SyntaxNode("while_body","");
		doNode.addChild(whileNode);
		match("LEFT(");
		whileNode.addChild(exp());
		match("RIGHT)");
		match("SEMICOLON");
		return doNode;
	}
	
	public SyntaxNode assign()
	{
		SyntaxNode assign = new SyntaxNode("assign","");
		match("ID");
		SyntaxNode idNode = new SyntaxNode(tokens[tokenIndex-1].getWord(),"ID");
		assign.addChild(idNode);
		match("ASSIGN");
		assign.addChild(exp());
		match("SEMICOLON");
		return assign;
	}
	
	public SyntaxNode write()
	{
		SyntaxNode write = new SyntaxNode("write","");
		match("write");
		write.addChild(exp());
		match("SEMICOLON");
		return write;
	}
	
	public SyntaxNode exp()
	{
		SyntaxNode exp = new SyntaxNode("exp","");
		exp.addChild(simpleExp());
		while(tokens[tokenIndex].getSymbol().equals("LESS")
				||tokens[tokenIndex].getSymbol().equals("EQUAL")
				||tokens[tokenIndex].getSymbol().equals("LARGER"))
		{
			if(tokens[tokenIndex].getSymbol().equals("LESS"))
				match("LESS");
			else if(tokens[tokenIndex].getSymbol().equals("EQUAL"))
				match("EQUAL");
			else if(tokens[tokenIndex].getSymbol().equals("LARGER"))
				match("LARGER");
			else
				match("Comparison operator.");
			exp.addChild(new SyntaxNode(tokens[tokenIndex-1].getWord(),"Op"));
			exp.addChild(simpleExp());
		}
		return exp;
	}
	
	public SyntaxNode simpleExp()
	{
		SyntaxNode simpleExp = term();
		while(tokens[tokenIndex].getSymbol().equals("ADD")
				||tokens[tokenIndex].getSymbol().equals("MINUS"))
		{
			if(tokens[tokenIndex].getSymbol().equals("ADD"))
				match("ADD");
			else if(tokens[tokenIndex].getSymbol().equals("MINUS"))
				match("MINUS");
			simpleExp.addSible(new SyntaxNode(tokens[tokenIndex-1].getWord(),"Op"));
			simpleExp.addSible(term());
		}
		return simpleExp;
	}
	
	public SyntaxNode term()
	{
		SyntaxNode factor = factor();
		while(tokens[tokenIndex].getSymbol().equals("MULTYPLY")
				||tokens[tokenIndex].getSymbol().equals("DIVISION"))
		{
			if(tokens[tokenIndex].getSymbol().equals("MULTYPLY"))
				match("MULTYPLY");
			else if(tokens[tokenIndex].getSymbol().equals("DIVISION"))
				match("DIVISION");
			factor.addSible(new SyntaxNode(tokens[tokenIndex-1].getWord(),"Op"));
			factor.addSible(factor());
		}
		return factor;
	}
	
	public SyntaxNode factor()
	{
		String name = tokens[tokenIndex].getWord();
		String attr = tokens[tokenIndex].getSymbol();
		SyntaxNode node = null;
		if(attr.equals("ID")||attr.equals("NUMBER"))
		{
			node = new SyntaxNode(name,attr);
			tokenIndex++;
		}
		else if(attr.equals("LEFT("))
		{
			tokenIndex++;
			node = exp();
			match("RIGHT)");
		}
		else
			System.out.println("wrong exp in line "+tokens[tokenIndex-1].getLine());
		return node;
	}
	
	public void printTree(SyntaxNode stmts,int level)
	{
		if(stmts==null)
			return;
		else
		{
			indent(2*level);
			int childrenNum = stmts.getChildrenNum();
			int sibleNum = stmts.getSibleNum();
			String name = stmts.getName();
			String attr = stmts.getAttribute();
			System.out.println(attr+" "+name);
			for(int i=0;i<childrenNum;i++)
			{
				printTree(stmts.getChild(i),level+1);
			}
			for(int i=0;i<sibleNum;i++)
			{
				printTree(stmts.getSible(i),level);
			}
		}
	}
}