Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- package com.polymarvelous.script.parser;
- import java.util.ArrayList;
- import java.util.List;
- import com.polymarvelous.script.parser.trees.Expression;
- import com.polymarvelous.script.parser.trees.Factor;
- import com.polymarvelous.script.parser.trees.IdentFactor;
- import com.polymarvelous.script.parser.trees.NumberFactor;
- import com.polymarvelous.script.parser.trees.ParenFactor;
- import com.polymarvelous.script.parser.trees.Program;
- import com.polymarvelous.script.parser.trees.Statement;
- import com.polymarvelous.script.parser.trees.Term;
- import com.polymarvelous.script.parser.trees.Unary;
- import com.polymarvelous.script.parser.trees.VarAssignment;
- import com.polymarvelous.script.parser.trees.VarDeclaration;
- import com.polymarvelous.script.tokenizer.Token;
- import com.polymarvelous.script.tokenizer.TokenType;
- import static com.polymarvelous.script.tokenizer.TokenType.*;
- public class Parser {
- private List<Token> tokens;
- private int index;
- private int tokensSize;
- public Parser(List<Token> tokens) {
- this.tokens = tokens;
- this.tokensSize = tokens.size();
- }
- public SyntaxTree parse() throws ParseException {
- return program();
- }
- private Program program() throws ParseException {
- Program p = new Program();
- p.statements = new ArrayList<Statement>();
- while(!tokenIsNull()) {
- p.statements.add(statement());
- expect(SEMICOLON);
- }
- return p;
- }
- private Statement statement() throws ParseException {
- Statement s = null;
- switch(getTokenType()) {
- case IDENT:
- Token t1 = getToken();
- nextToken();
- if(accept(IDENT)) {
- prevToken();
- VarDeclaration vd = new VarDeclaration();
- vd.typeName = t1.getData();
- nextToken();
- vd.varName = getTokenData();
- nextToken();
- expect(ASSIGN);
- vd.expression = expression();
- s = vd;
- } else {
- expect(ASSIGN);
- VarAssignment va = new VarAssignment();
- va.varName = t1.getData();
- va.expression = expression();
- s = va;
- }
- break;
- case IF:
- s = branch();
- break;
- default:
- break;
- }
- return s;
- }
- private Branch branch() throws ParseException {
- Branch b = new Branch();
- b.ifBranch = ifBranch();
- b.elseIfBranches = new ArrayList<ElseIfBranch>();
- while(accept(ELSE)) {
- nextToken();
- if(accept(IF)) {
- prevToken();
- b.elseIfBranches.add(elseIfBranch());
- } else {
- prevToken();
- b.elseBranch = elseBranch();
- }
- }
- return b;
- }
- private IfBranch ifBranch() throws ParseException {
- IfBranch ib = new IfBranch();
- expect(IF);
- expect(LPAREN);
- ib.condition = expression();
- expect(RPAREN);
- ib.block = block();
- return ib;
- }
- private ElseIfBranch elseIfBranch() throws ParseException {
- ElseIfBranch eib = new ElseIfBranch();
- expect(ELSE);
- expect(IF);
- expect(LPAREN);
- eib.condition = expression();
- expect(RPAREN);
- eib.block = block();
- return eib;
- }
- private ElseBranch elseBranch() throws ParseException {
- ElseBranch eb = new ElseBranch();
- expect(ELSE);
- eb.block = block();
- return eb;
- }
- private Block block() throws ParseException {
- Block b = new Block();
- b.statements = new ArrayList<Statement>();
- expect(LBRACE);
- while(!accept(RBRACE)) {
- b.statements.add(statement());
- expect(SEMICOLON);
- }
- nextToken();
- return b;
- }
- private Expression expression() throws ParseException {
- Expression e = new Expression();
- e.terms = new ArrayList<Term>();
- e.operators = new ArrayList<TokenType>();
- e.terms.add(term());
- while(accept(ADD) || accept(SUB)) {
- e.operators.add(getTokenType());
- nextToken();
- e.terms.add(term());
- }
- return e;
- }
- private Term term() throws ParseException {
- Term t = new Term();
- t.unaries = new ArrayList<Unary>();
- t.operators = new ArrayList<TokenType>();
- t.unaries.add(unary());
- while(accept(MUL) || accept(DIV)) {
- t.operators.add(getTokenType());
- nextToken();
- t.unaries.add(unary());
- }
- return t;
- }
- private Unary unary() throws ParseException {
- Unary u = new Unary();
- u.factors = new ArrayList<Factor>();
- u.operators = new ArrayList<TokenType>();
- while(accept(NOT) || accept(BIT_NOT)) {
- u.operators.add(getTokenType());
- nextToken();
- }
- u.factors.add(factor());
- return u;
- }
- private Factor factor() throws ParseException {
- Factor f = null;
- switch(getTokenType()) {
- case NUMBER:
- NumberFactor nf = new NumberFactor();
- nf.number = getTokenData();
- nextToken();
- f = nf;
- break;
- case IDENT:
- IdentFactor idf = new IdentFactor();
- idf.identName = getTokenData();
- nextToken();
- f = idf;
- break;
- case LPAREN:
- ParenFactor pf = new ParenFactor();
- nextToken();
- pf.expression = expression();
- expect(RPAREN);
- f = pf;
- default:
- break;
- }
- return f;
- }
- public Token getToken() {
- if(index < tokensSize)
- return tokens.get(index);
- else
- return null;
- }
- public TokenType getTokenType() {
- return getToken().getType();
- }
- public String getTokenData() {
- return getToken().getData();
- }
- public void nextToken() {
- index++;
- }
- public void prevToken() {
- index--;
- }
- public boolean tokenIsNull() {
- return getToken() == null;
- }
- public boolean accept(TokenType type) {
- if(!tokenIsNull())
- return getToken().getType() == type;
- else
- return false;
- }
- public boolean consume(TokenType type) {
- Token t = getToken();
- if(t.getType() != type) {
- return false;
- }
- nextToken();
- return true;
- }
- public Token expect(TokenType type) throws ParseException {
- Token t = getToken();
- if(t.getType() != type) {
- throw new ParseException("Expected '" + type + "'. Got '" + t + "'");
- }
- nextToken();
- return t;
- }
- }
Add Comment
Please, Sign In to add comment