expressionparser.java

SkipOOMiniJOOL教学语言的编译器前端

package edu.ustc.cs.minijool.parser;

import edu.ustc.cs.minijool.lexer.*;
import org.eclipse.jdt.core.dom.*;

/**<p>
 * 分析赋值表达式语句序列的语法分析器
 * </p>
 */
public class ExpressionParser extends RDParser{
	private ASTNode root = null;
	private boolean success = false;
	
	public ExpressionParser(Lexer lexer) {
		super(lexer);
	}
	
	public ASTNode parse() {
		success = sequence();
		if (success){
			return root;
		} else {
			System.out.println("Parsing Error!");
			return null;
		}
	}
	
	private boolean sequence() {
		int isave = next;
		int stackSize = getStackSize();
		if (sequence1()) {
			return true;
		}
		next = isave;
		setStackSize(stackSize);
		if (sequence2()) {
			return true;
		}
		return false;
	}
	
	private boolean sequence1() {
		return assignment() && sequence();
	}
	
	private boolean sequence2() {
		return token(Symbol.EOF);
	}
	
	private boolean assignment() {
		return assignment1();
	}
	
	private boolean assignment1() {
		return token(Symbol.IDENTIFIER) && token(Symbol.EQ)
					&& expression() && token(Symbol.SEMICOLON);
	}
	
	private boolean expression() {
		return expression1();
	}
	
	private boolean expression1() {
		return term() && expression_1();
	}
	
	private boolean expression_1() {
		int isave = next;
		int stackSize = getStackSize();
		if (expression_11()) {
			return true;
		}
		next = isave;
		setStackSize(stackSize);
		if (expression_12()) {
			return true;
		}
		next = isave;
		setStackSize(stackSize);
		if (expression_13()) {
			return true;
		}
		return false;
	}
	
	private boolean expression_11() {
		return token(Symbol.PLUS) && term() && expression_1();
	}
	
	private boolean expression_12() {
		return token(Symbol.MINUS) && term() && expression_1();
	}
	
	private boolean expression_13() {
		return tokenEpsilon();
	}
	
	private boolean term() {
		return term1();
	}
	
	private boolean term1() {
		return factor() && term_1();
	}
	
	private boolean term_1() {
		int isave = next;
		int stackSize = getStackSize();
		if (term_11()) {
			return true;
		}
		next = isave;
		setStackSize(stackSize);
		if (term_12()) {
			return true;
		}
		next = isave;
		setStackSize(stackSize);
		if (term_13()) {
			return true;
		}
		return false;
	}
	
	private boolean term_11() {
		return token(Symbol.MULT) && factor() && term_1();
	}
	
	private boolean term_12() {
		return token(Symbol.DIV) && factor() && term_1();
	}
	
	private boolean term_13() {
		return tokenEpsilon();
	}
	
	private boolean factor() {
		int isave = next;
		int stackSize = getStackSize();
		if (factor1()) {
			return true;
		}
		next = isave;
		setStackSize(stackSize);
		if (factor2()) {
			return true;
		}
		next = isave;
		setStackSize(stackSize);
		if (factor3()) {
			return true;
		}
		return false;
	}
	
	private boolean factor1() {
		return token(Symbol.LPAREN) && expression() && token(Symbol.RPAREN);
	}
	
	private boolean factor2() {
		return token(Symbol.IDENTIFIER);
	}
	
	private boolean factor3() {
		return token(Symbol.INTEGER_LITERAL);
	}
}