Add interpreter and AST

5 files changed, 155 insertions, 38 deletions

diff --git a/main/core/parser/Parser.java b/main/core/parser/Parser.java
index af62f7e..416c3f0 100644
--- a/main/core/parser/Parser.java
+++ b/main/core/parser/Parser.java
@@ -2,9 +2,12 @@ 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.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.List;
 
 /**
@@ -24,6 +27,18 @@ 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();
+    }
+
     public List<ASTNode> parse(List<Token> tokens) {
         this.tokens = tokens;
         this.statementSequence = new ArrayList<>();
@@ -40,6 +55,11 @@ public class Parser {
                 statementSequence.add(adn);
                 continue;
             }
+
+            Token failed = tokens.get(c.getValue());
+            ExceptionManager.raise(InterpreterException.Exception.SyntaxError, failed.getLine(),
+                    Arrays.asList(failed.toString()));
+            break;
         }
 
         return statementSequence;
@@ -47,8 +67,13 @@ public class Parser {
 
     public AssignmentNode expectAssignmentRoutine(Counter c) {
         Counter d = c.clone();
+        d.deeper();
 
-        SymbolNode lhs = expectLHS(d);
+        if (isTooDeep(d)) {
+            return null;
+        }
+
+        SymbolNode lhs = expectAssignmentLHS(d);
         if (lhs == null) {
             return null;
         }
@@ -56,27 +81,98 @@ public class Parser {
         if (!isAssign) {
             return null;
         }
-        ExpressionNode rhs = expectRHS(d);
+        ExpressionNode rhs = expectAssignmentRHS(d);
         if (rhs == null) {
             return null;
         }
 
         AssignmentNode an = new AssignmentNode(lhs, rhs);
-        c.setValue(d.getValue());
+        d.shallower();
+        c.assign(d);
         return an;
     }
 
-    public SymbolNode expectLHS(Counter c) {
-        SymbolNode sn = parseSymbolAndAdvance(c);
+    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 expectRHS(Counter c) {
+    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;
@@ -84,49 +180,36 @@ public class Parser {
 
     private ExpressionNode expectExpression(Counter c) {
         Counter d = c.clone();
+        d.deeper();
+
+        if (isTooDeep(d)) {
+            return null;
+        }
 
         AdditionNode an = expectAdditionRoutine(d);
         if (an != null) {
-            c.setValue(d.getValue());
+            d.shallower();
+            c.assign(d);
             return an;
         }
         IntegerLiteralNode in = parseIntegerLiteralAndAdvance(d);
         if (in != null) {
-            c.setValue(d.getValue());
+            d.shallower();
+            c.assign(d);
             return in;
         }
         SymbolNode sn = parseSymbolAndAdvance(d);
         if (sn != null) {
-            c.setValue(d.getValue());
+            d.shallower();
+            c.assign(d);
             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)) {
+        if (getTokenAt(c).is(Token.Type.AdditionToken)) {
             c.advance();
             return true;
         } else {
@@ -135,8 +218,8 @@ public class Parser {
     }
 
     private IntegerLiteralNode parseIntegerLiteralAndAdvance(Counter c) {
-        if (tokens.get(c.getValue()).is(Token.Type.IntegerLiteralToken)) {
-            IntegerLiteralNode in = new IntegerLiteralNode(tokens.get(c.getValue()));
+        if (getTokenAt(c).is(Token.Type.IntegerLiteralToken)) {
+            IntegerLiteralNode in = new IntegerLiteralNode(getTokenAt(c));
             c.advance();
             return in;
         } else {
@@ -145,7 +228,7 @@ public class Parser {
     }
 
     public boolean expectAssignmentAndAdvance(Counter c) {
-        if (tokens.get(c.getValue()).is(Token.Type.AssignmentToken)) {
+        if (getTokenAt(c).is(Token.Type.AssignmentToken)) {
             c.advance();
             return true;
         } else {
@@ -154,8 +237,8 @@ public class Parser {
     }
 
     public SymbolNode parseSymbolAndAdvance(Counter c) {
-        if (tokens.get(c.getValue()).is(Token.Type.SymbolToken)) {
-            SymbolNode sn = new SymbolNode(tokens.get(c.getValue()));
+        if (getTokenAt(c).is(Token.Type.SymbolToken)) {
+            SymbolNode sn = new SymbolNode(getTokenAt(c));
             c.advance();
             return sn;
         } else {
diff --git a/main/core/parser/ast/AdditionNode.java b/main/core/parser/ast/AdditionNode.java
index 3117e41..f6ebc84 100644
--- a/main/core/parser/ast/AdditionNode.java
+++ b/main/core/parser/ast/AdditionNode.java
@@ -29,6 +29,8 @@ public class AdditionNode extends ExpressionNode {
 
     @Override
     public DataContainer evaluate() {
-        return null;
+        DataContainer lhs = this.lhs.evaluate();
+        DataContainer rhs = this.rhs.evaluate();
+        return lhs.add(rhs);
     }
 }
diff --git a/main/core/parser/ast/IntegerLiteralNode.java b/main/core/parser/ast/IntegerLiteralNode.java
index b68adf0..d2fceb1 100644
--- a/main/core/parser/ast/IntegerLiteralNode.java
+++ b/main/core/parser/ast/IntegerLiteralNode.java
@@ -1,6 +1,7 @@
 package com.jantuomi.interpreter.main.core.parser.ast;
 
 import com.jantuomi.interpreter.main.core.parser.datatype.DataContainer;
+import com.jantuomi.interpreter.main.core.parser.datatype.IntegerDataContainer;
 import com.jantuomi.interpreter.main.core.tokenizer.token.Token;
 
 import java.util.Arrays;
@@ -25,6 +26,6 @@ public class IntegerLiteralNode extends ExpressionNode {
 
     @Override
     public DataContainer evaluate() {
-        return null;
+        return new IntegerDataContainer(data);
     }
 }
diff --git a/main/core/parser/datatype/DataContainer.java b/main/core/parser/datatype/DataContainer.java
index 48e72a3..45199e2 100644
--- a/main/core/parser/datatype/DataContainer.java
+++ b/main/core/parser/datatype/DataContainer.java
@@ -14,4 +14,9 @@ abstract public class DataContainer<T> {
     }
 
     private T data;
+
+    @Override
+    abstract public String toString();
+
+    public abstract DataContainer add(DataContainer rhs);
 }
diff --git a/main/core/parser/datatype/IntegerDataContainer.java b/main/core/parser/datatype/IntegerDataContainer.java
index c5b9fb0..8566a1c 100644
--- a/main/core/parser/datatype/IntegerDataContainer.java
+++ b/main/core/parser/datatype/IntegerDataContainer.java
@@ -1,5 +1,11 @@
 package com.jantuomi.interpreter.main.core.parser.datatype;
 
+
+import com.jantuomi.interpreter.main.exception.ExceptionManager;
+import com.jantuomi.interpreter.main.exception.InterpreterException;
+
+import java.util.Arrays;
+
 /**
  * Created by jan on 11.6.2016.
  */
@@ -7,4 +13,24 @@ public class IntegerDataContainer extends DataContainer<Integer> {
     public IntegerDataContainer(Integer data) {
         this.setData(data);
     }
+
+    @Override
+    public String toString() {
+        return getData().toString();
+    }
+
+    @Override
+    public DataContainer add(DataContainer rhs) {
+        if (rhs instanceof IntegerDataContainer) {
+            return new IntegerDataContainer(
+                getData() + ((IntegerDataContainer) rhs).getData()
+            );
+        }
+        else {
+            ExceptionManager.raise(InterpreterException.Exception.TypeError, -1,
+                    Arrays.asList(this.getClass().toString(), rhs.getClass().toString()));
+
+            return null;
+        }
+    }
 }