Grammar now uses reverse polish notation

1 files changed, 30 insertions, 215 deletions

diff --git a/main/core/parser/Parser.java b/main/core/parser/Parser.java
index 416c3f0..e8b8813 100644
--- a/main/core/parser/Parser.java
+++ b/main/core/parser/Parser.java
@@ -1,14 +1,13 @@
 package com.jantuomi.interpreter.main.core.parser;
 
-import com.jantuomi.interpreter.main.core.parser.ast.*;
+import com.jantuomi.interpreter.main.core.parser.ast.ASTNode;
+import com.jantuomi.interpreter.main.core.tokenizer.token.ArgumentInfo;
 import com.jantuomi.interpreter.main.core.tokenizer.token.Token;
-import com.jantuomi.interpreter.main.exception.ExceptionManager;
-import com.jantuomi.interpreter.main.exception.InterpreterException;
-import com.jantuomi.interpreter.main.utils.Counter;
 
 import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.Stack;
 
 /**
  * Created by jan on 11.6.2016.
@@ -27,226 +26,42 @@ public class Parser {
 
     }
 
-    private Token getTokenAt(Counter c) {
-        if (c.getValue() >= tokens.size()) {
-            return new Token(Token.Type.NotAToken);
-        }
-
-        return tokens.get(c.getValue());
-    }
-
-    private boolean isTooDeep(Counter c) {
-        return c.getRecursionDepth() > tokens.size();
-    }
+    private Stack<Token> stack;
 
-    public List<ASTNode> parse(List<Token> tokens) {
+    public List<Token> parse(List<Token> tokens) {
         this.tokens = tokens;
-        this.statementSequence = new ArrayList<>();
+        this.stack = new Stack<>();
 
-        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);
+        List<Token> args = new ArrayList<>();
+        List<Token> output = new ArrayList<>();
+        for (Token t : tokens) {
+            if (t.getTokenType() == Token.Type.NewlineToken) {
+//                if (stack.size() > 0) {
+//                    output.add(stack.pop());
+//                }
                 continue;
             }
 
-            Token failed = tokens.get(c.getValue());
-            ExceptionManager.raise(InterpreterException.Exception.SyntaxError, failed.getLine(),
-                    Arrays.asList(failed.toString()));
-            break;
-        }
-
-        return statementSequence;
-    }
-
-    public AssignmentNode expectAssignmentRoutine(Counter c) {
-        Counter d = c.clone();
-        d.deeper();
-
-        if (isTooDeep(d)) {
-            return null;
-        }
-
-        SymbolNode lhs = expectAssignmentLHS(d);
-        if (lhs == null) {
-            return null;
-        }
-        boolean isAssign = expectAssignmentAndAdvance(d);
-        if (!isAssign) {
-            return null;
-        }
-        ExpressionNode rhs = expectAssignmentRHS(d);
-        if (rhs == null) {
-            return null;
-        }
-
-        AssignmentNode an = new AssignmentNode(lhs, rhs);
-        d.shallower();
-        c.assign(d);
-        return an;
-    }
-
-    private AdditionNode expectAdditionRoutine(Counter c) {
-        Counter d = c.clone();
-        d.deeper();
-
-        if (isTooDeep(d)) {
-            return null;
-        }
-
-        ExpressionNode lhs = expectExpression(d);
-        if (lhs == null) {
-            return null;
-        }
-        boolean isAddition = expectAdditionAndAdvance(d);
-        if (!isAddition) {
-            return null;
-        }
-        ExpressionNode rhs = expectExpression(d);
-        if (rhs == null) {
-            return null;
-        }
-
-        AdditionNode an = new AdditionNode(lhs, rhs);
-        d.shallower();
-        c.assign(d);
-        return an;
-    }
-
-//    private ExpressionNode expectAdditionLHS(Counter c) {
-//        Counter d = c.clone();
-//        d.deeper();
-//
-//        if (isTooDeep(d)) {
-//            return null;
-//        }
-//
-//        IntegerLiteralNode in = parseIntegerLiteralAndAdvance(d);
-//        if (in != null) {
-//            d.shallower();
-//            c.assign(d);
-//            return in;
-//        }
-//        SymbolNode sn = parseSymbolAndAdvance(d);
-//        if (sn != null) {
-//            d.shallower();
-//            c.assign(d);
-//            return sn;
-//        }
-//
-//        return null;
-//    }
-
-
-    public SymbolNode expectAssignmentLHS(Counter c) {
-        Counter d = c.clone();
-        d.deeper();
-
-        if (isTooDeep(d)) {
-            return null;
-        }
-
-        SymbolNode sn = parseSymbolAndAdvance(d);
-        if (sn != null) {
-            d.shallower();
-            c.assign(d);
-            return sn;
-        }
-        return null;
-    }
-
-    public ExpressionNode expectAssignmentRHS(Counter c) {
-        Counter d = c.clone();
-        d.deeper();
-
-        if (isTooDeep(d)) {
-            return null;
-        }
-
-        ExpressionNode en = expectExpression(c);
-        if (en != null) {
-            d.shallower();
-            c.assign(d);
-            return en;
-        }
-        return null;
-    }
-
-    private ExpressionNode expectExpression(Counter c) {
-        Counter d = c.clone();
-        d.deeper();
-
-        if (isTooDeep(d)) {
-            return null;
-        }
-
-        AdditionNode an = expectAdditionRoutine(d);
-        if (an != null) {
-            d.shallower();
-            c.assign(d);
-            return an;
-        }
-        IntegerLiteralNode in = parseIntegerLiteralAndAdvance(d);
-        if (in != null) {
-            d.shallower();
-            c.assign(d);
-            return in;
-        }
-        SymbolNode sn = parseSymbolAndAdvance(d);
-        if (sn != null) {
-            d.shallower();
-            c.assign(d);
-            return sn;
-        }
-
-        return null;
-    }
-
-    private boolean expectAdditionAndAdvance(Counter c) {
-        if (getTokenAt(c).is(Token.Type.AdditionToken)) {
-            c.advance();
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    private IntegerLiteralNode parseIntegerLiteralAndAdvance(Counter c) {
-        if (getTokenAt(c).is(Token.Type.IntegerLiteralToken)) {
-            IntegerLiteralNode in = new IntegerLiteralNode(getTokenAt(c));
-            c.advance();
-            return in;
-        } else {
-            return null;
-        }
-    }
-
-    public boolean expectAssignmentAndAdvance(Counter c) {
-        if (getTokenAt(c).is(Token.Type.AssignmentToken)) {
-            c.advance();
-            return true;
-        } else {
-            return false;
+            args.clear();
+            ArgumentInfo argumentInfo = t.getArgumentInfo();
+            if (!argumentInfo.getVarargs()) {
+                for (int i = 0; i < argumentInfo.getCount(); i++) {
+                    args.add(stack.pop());
+                }
+            } else {
+                System.err.println("no vararg support yet");
+            }
+            Collections.reverse(args);
+            Token result = t.setArguments(args);
+            stack.push(result);
         }
-    }
-
-    public SymbolNode parseSymbolAndAdvance(Counter c) {
-        if (getTokenAt(c).is(Token.Type.SymbolToken)) {
-            SymbolNode sn = new SymbolNode(getTokenAt(c));
-            c.advance();
-            return sn;
-        } else {
-            return null;
+        while (stack.size() > 0) {
+            output.add(stack.pop());
         }
+        return output;
     }
 
-    public void printTree(ASTNode e) {
+    public void printTree(Token e) {
         System.out.println("### Tree begin ###");
         e.print(0);
         System.out.println("### Tree end ###");