Add tokenizer, parser and support for certain operations

1 files changed, 171 insertions, 0 deletions

diff --git a/main/core/parser/Parser.java b/main/core/parser/Parser.java
new file mode 100644
index 0000000..af62f7e
--- /dev/null
+++ b/main/core/parser/Parser.java
@@ -0,0 +1,171 @@
+package com.jantuomi.interpreter.main.core.parser;
+
+import com.jantuomi.interpreter.main.core.parser.ast.*;
+import com.jantuomi.interpreter.main.core.tokenizer.token.Token;
+import com.jantuomi.interpreter.main.utils.Counter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by jan on 11.6.2016.
+ */
+public class Parser {
+    private static final Parser instance = new Parser();
+
+    private List<Token> tokens;
+    private List<ASTNode> statementSequence;
+
+    public static Parser getInstance() {
+        return instance;
+    }
+
+    private Parser() {
+
+    }
+
+    public List<ASTNode> parse(List<Token> tokens) {
+        this.tokens = tokens;
+        this.statementSequence = new ArrayList<>();
+
+        Counter c = new Counter();
+        while (c.getValue() < tokens.size()) {
+            AssignmentNode asn = expectAssignmentRoutine(c);
+            if (asn != null) {
+                statementSequence.add(asn);
+                continue;
+            }
+            AdditionNode adn = expectAdditionRoutine(c);
+            if (adn != null) {
+                statementSequence.add(adn);
+                continue;
+            }
+        }
+
+        return statementSequence;
+    }
+
+    public AssignmentNode expectAssignmentRoutine(Counter c) {
+        Counter d = c.clone();
+
+        SymbolNode lhs = expectLHS(d);
+        if (lhs == null) {
+            return null;
+        }
+        boolean isAssign = expectAssignmentAndAdvance(d);
+        if (!isAssign) {
+            return null;
+        }
+        ExpressionNode rhs = expectRHS(d);
+        if (rhs == null) {
+            return null;
+        }
+
+        AssignmentNode an = new AssignmentNode(lhs, rhs);
+        c.setValue(d.getValue());
+        return an;
+    }
+
+    public SymbolNode expectLHS(Counter c) {
+        SymbolNode sn = parseSymbolAndAdvance(c);
+        if (sn != null) {
+            return sn;
+        }
+        return null;
+    }
+
+    public ExpressionNode expectRHS(Counter c) {
+        ExpressionNode en = expectExpression(c);
+        if (en != null) {
+            return en;
+        }
+        return null;
+    }
+
+    private ExpressionNode expectExpression(Counter c) {
+        Counter d = c.clone();
+
+        AdditionNode an = expectAdditionRoutine(d);
+        if (an != null) {
+            c.setValue(d.getValue());
+            return an;
+        }
+        IntegerLiteralNode in = parseIntegerLiteralAndAdvance(d);
+        if (in != null) {
+            c.setValue(d.getValue());
+            return in;
+        }
+        SymbolNode sn = parseSymbolAndAdvance(d);
+        if (sn != null) {
+            c.setValue(d.getValue());
+            return sn;
+        }
+
+        return null;
+    }
+
+    private AdditionNode expectAdditionRoutine(Counter c) {
+        Counter d = c.clone();
+
+        ExpressionNode lhs = expectLHS(d);
+        if (lhs == null) {
+            return null;
+        }
+        boolean isAddition = expectAdditionAndAdvance(d);
+        if (!isAddition) {
+            return null;
+        }
+        ExpressionNode rhs = expectRHS(d);
+        if (rhs == null) {
+            return null;
+        }
+
+        AdditionNode an = new AdditionNode(lhs, rhs);
+        c.setValue(d.getValue());
+        return an;
+    }
+
+    private boolean expectAdditionAndAdvance(Counter c) {
+        if (tokens.get(c.getValue()).is(Token.Type.AdditionToken)) {
+            c.advance();
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private IntegerLiteralNode parseIntegerLiteralAndAdvance(Counter c) {
+        if (tokens.get(c.getValue()).is(Token.Type.IntegerLiteralToken)) {
+            IntegerLiteralNode in = new IntegerLiteralNode(tokens.get(c.getValue()));
+            c.advance();
+            return in;
+        } else {
+            return null;
+        }
+    }
+
+    public boolean expectAssignmentAndAdvance(Counter c) {
+        if (tokens.get(c.getValue()).is(Token.Type.AssignmentToken)) {
+            c.advance();
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public SymbolNode parseSymbolAndAdvance(Counter c) {
+        if (tokens.get(c.getValue()).is(Token.Type.SymbolToken)) {
+            SymbolNode sn = new SymbolNode(tokens.get(c.getValue()));
+            c.advance();
+            return sn;
+        } else {
+            return null;
+        }
+    }
+
+    public void printTree(ASTNode e) {
+        System.out.println("### Tree begin ###");
+        e.print(0);
+        System.out.println("### Tree end ###");
+    }
+}