Guest User

Untitled

a guest
Dec 18th, 2018
69
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 5.47 KB | None | 0 0
  1. package com.polymarvelous.script.parser;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. import com.polymarvelous.script.parser.trees.Expression;
  7. import com.polymarvelous.script.parser.trees.Factor;
  8. import com.polymarvelous.script.parser.trees.IdentFactor;
  9. import com.polymarvelous.script.parser.trees.NumberFactor;
  10. import com.polymarvelous.script.parser.trees.ParenFactor;
  11. import com.polymarvelous.script.parser.trees.Program;
  12. import com.polymarvelous.script.parser.trees.Statement;
  13. import com.polymarvelous.script.parser.trees.Term;
  14. import com.polymarvelous.script.parser.trees.Unary;
  15. import com.polymarvelous.script.parser.trees.VarAssignment;
  16. import com.polymarvelous.script.parser.trees.VarDeclaration;
  17. import com.polymarvelous.script.tokenizer.Token;
  18. import com.polymarvelous.script.tokenizer.TokenType;
  19.  
  20. import static com.polymarvelous.script.tokenizer.TokenType.*;
  21.  
  22. public class Parser {
  23.  
  24.     private List<Token> tokens;
  25.     private int index;
  26.     private int tokensSize;
  27.  
  28.     public Parser(List<Token> tokens) {
  29.         this.tokens = tokens;
  30.         this.tokensSize = tokens.size();
  31.     }
  32.  
  33.     public SyntaxTree parse() throws ParseException {
  34.         return program();
  35.     }
  36.  
  37.     private Program program() throws ParseException {
  38.         Program p = new Program();
  39.         p.statements = new ArrayList<Statement>();
  40.         while(!tokenIsNull()) {
  41.             p.statements.add(statement());
  42.             expect(SEMICOLON);
  43.         }
  44.         return p;
  45.     }
  46.  
  47.     private Statement statement() throws ParseException {
  48.         Statement s = null;
  49.         switch(getTokenType()) {
  50.         case IDENT:
  51.             Token t1 = getToken();
  52.             nextToken();
  53.             if(accept(IDENT)) {
  54.                 prevToken();
  55.                 VarDeclaration vd = new VarDeclaration();
  56.                 vd.typeName = t1.getData();
  57.                 nextToken();
  58.                 vd.varName = getTokenData();
  59.                 nextToken();
  60.                 expect(ASSIGN);
  61.                 vd.expression = expression();
  62.                 s = vd;
  63.             } else {
  64.                 expect(ASSIGN);
  65.                 VarAssignment va = new VarAssignment();
  66.                 va.varName = t1.getData();
  67.                 va.expression = expression();
  68.                 s = va;
  69.             }
  70.             break;
  71.         case IF:
  72.             s = branch();
  73.             break;
  74.         default:
  75.             break;
  76.         }
  77.         return s;
  78.     }
  79.  
  80.     private Branch branch() throws ParseException {
  81.         Branch b = new Branch();
  82.         b.ifBranch = ifBranch();
  83.         b.elseIfBranches = new ArrayList<ElseIfBranch>();
  84.         while(accept(ELSE)) {
  85.             nextToken();
  86.             if(accept(IF)) {
  87.                 prevToken();
  88.                 b.elseIfBranches.add(elseIfBranch());
  89.             } else {
  90.                 prevToken();
  91.                 b.elseBranch = elseBranch();
  92.             }
  93.         }
  94.         return b;
  95.     }
  96.  
  97.     private IfBranch ifBranch() throws ParseException {
  98.         IfBranch ib = new IfBranch();
  99.         expect(IF);
  100.         expect(LPAREN);
  101.         ib.condition = expression();
  102.         expect(RPAREN);
  103.         ib.block = block();
  104.         return ib;
  105.     }
  106.  
  107.     private ElseIfBranch elseIfBranch() throws ParseException {
  108.         ElseIfBranch eib = new ElseIfBranch();
  109.         expect(ELSE);
  110.         expect(IF);
  111.         expect(LPAREN);
  112.         eib.condition = expression();
  113.         expect(RPAREN);
  114.         eib.block = block();
  115.         return eib;
  116.     }
  117.  
  118.     private ElseBranch elseBranch() throws ParseException {
  119.         ElseBranch eb = new ElseBranch();
  120.         expect(ELSE);
  121.         eb.block = block();
  122.         return eb;
  123.     }
  124.  
  125.     private Block block() throws ParseException {
  126.         Block b = new Block();
  127.         b.statements = new ArrayList<Statement>();
  128.         expect(LBRACE);
  129.         while(!accept(RBRACE)) {
  130.             b.statements.add(statement());
  131.             expect(SEMICOLON);
  132.         }
  133.         nextToken();
  134.         return b;
  135.     }
  136.  
  137.     private Expression expression() throws ParseException {
  138.         Expression e = new Expression();
  139.         e.terms = new ArrayList<Term>();
  140.         e.operators = new ArrayList<TokenType>();
  141.         e.terms.add(term());
  142.         while(accept(ADD) || accept(SUB)) {
  143.             e.operators.add(getTokenType());
  144.             nextToken();
  145.             e.terms.add(term());
  146.         }
  147.         return e;
  148.     }
  149.  
  150.     private Term term() throws ParseException {
  151.         Term t = new Term();
  152.         t.unaries = new ArrayList<Unary>();
  153.         t.operators = new ArrayList<TokenType>();
  154.         t.unaries.add(unary());
  155.         while(accept(MUL) || accept(DIV)) {
  156.             t.operators.add(getTokenType());
  157.             nextToken();
  158.             t.unaries.add(unary());
  159.         }
  160.         return t;
  161.     }
  162.  
  163.     private Unary unary() throws ParseException {
  164.         Unary u = new Unary();
  165.         u.factors = new ArrayList<Factor>();
  166.         u.operators = new ArrayList<TokenType>();
  167.         while(accept(NOT) || accept(BIT_NOT)) {
  168.             u.operators.add(getTokenType());
  169.             nextToken();
  170.         }
  171.         u.factors.add(factor());
  172.         return u;
  173.     }
  174.  
  175.     private Factor factor() throws ParseException {
  176.         Factor f = null;
  177.         switch(getTokenType()) {
  178.         case NUMBER:
  179.             NumberFactor nf = new NumberFactor();
  180.             nf.number = getTokenData();
  181.             nextToken();
  182.             f = nf;
  183.             break;
  184.         case IDENT:
  185.             IdentFactor idf = new IdentFactor();
  186.             idf.identName = getTokenData();
  187.             nextToken();
  188.             f = idf;
  189.             break;
  190.         case LPAREN:
  191.             ParenFactor pf = new ParenFactor();
  192.             nextToken();
  193.             pf.expression = expression();
  194.             expect(RPAREN);
  195.             f = pf;
  196.         default:
  197.  
  198.             break;
  199.         }
  200.         return f;
  201.     }
  202.  
  203.     public Token getToken() {
  204.         if(index < tokensSize)
  205.             return tokens.get(index);
  206.         else
  207.             return null;
  208.     }
  209.  
  210.     public TokenType getTokenType() {
  211.         return getToken().getType();
  212.     }
  213.  
  214.     public String getTokenData() {
  215.         return getToken().getData();
  216.     }
  217.  
  218.     public void nextToken() {
  219.         index++;
  220.     }
  221.  
  222.     public void prevToken() {
  223.         index--;
  224.     }
  225.  
  226.     public boolean tokenIsNull() {
  227.         return getToken() == null;
  228.     }
  229.  
  230.     public boolean accept(TokenType type) {
  231.         if(!tokenIsNull())
  232.             return getToken().getType() == type;
  233.         else
  234.             return false;
  235.     }
  236.  
  237.     public boolean consume(TokenType type) {
  238.         Token t = getToken();
  239.         if(t.getType() != type) {
  240.             return false;
  241.         }
  242.         nextToken();
  243.         return true;
  244.     }
  245.  
  246.     public Token expect(TokenType type) throws ParseException {
  247.         Token t = getToken();
  248.         if(t.getType() != type) {
  249.             throw new ParseException("Expected '" + type + "'. Got '" + t + "'");
  250.         }
  251.         nextToken();
  252.         return t;
  253.     }
  254.  
  255. }
Add Comment
Please, Sign In to add comment