Add multiplication and division operations

9 files changed, 260 insertions, 18 deletions

diff --git a/main/core/parser/ast/DivisionNode.java b/main/core/parser/ast/DivisionNode.java
new file mode 100644
index 0000000..5bebf7b
--- /dev/null
+++ b/main/core/parser/ast/DivisionNode.java
@@ -0,0 +1,39 @@
+package com.jantuomi.interpreter.main.core.parser.ast;
+
+import com.jantuomi.interpreter.main.core.parser.datatype.DataContainer;
+import com.jantuomi.interpreter.main.core.tokenizer.token.Token;
+import com.jantuomi.interpreter.main.exception.ExceptionManager;
+import com.jantuomi.interpreter.main.exception.InterpreterException;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by jan on 16.6.2016.
+ */
+public class DivisionNode extends BinaryOperatorNode {
+
+    public DivisionNode(Token token, ASTNode lhs, ASTNode rhs) {
+        super(token, lhs, rhs);
+    }
+
+    @Override
+    public DataContainer evaluate() throws InterpreterException {
+        DataContainer operand1 = lhs.evaluate();
+        DataContainer operand2 = rhs.evaluate();
+
+        DataContainer result = operand1.divide(operand2);
+        if (result != null) {
+            return result;
+        } else {
+            ExceptionManager.raise(InterpreterException.ExceptionType.TypeError, source.getLine(),
+                    operand1.getType().toString(), operand2.getType().toString());
+            return null;
+        }
+
+    }
+    @Override
+    List<ASTNode> getChildren() {
+        return Arrays.asList(lhs, rhs);
+    }
+}
diff --git a/main/core/parser/ast/DoubleLiteralNode.java b/main/core/parser/ast/DoubleLiteralNode.java
new file mode 100644
index 0000000..a90c4af
--- /dev/null
+++ b/main/core/parser/ast/DoubleLiteralNode.java
@@ -0,0 +1,30 @@
+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.DoubleDataContainer;
+import com.jantuomi.interpreter.main.core.tokenizer.token.Token;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by jan on 16.6.2016.
+ */
+public class DoubleLiteralNode extends ASTNode {
+    private DoubleDataContainer value;
+
+    public DoubleLiteralNode(Token token) {
+        super(token);
+        value = new DoubleDataContainer(Double.parseDouble(token.getText()));
+    }
+
+    @Override
+    public DataContainer evaluate() {
+        return value;
+    }
+
+    @Override
+    List<ASTNode> getChildren() {
+        return Arrays.asList();
+    }
+}
diff --git a/main/core/parser/ast/MultiplicationNode.java b/main/core/parser/ast/MultiplicationNode.java
new file mode 100644
index 0000000..5d86cf3
--- /dev/null
+++ b/main/core/parser/ast/MultiplicationNode.java
@@ -0,0 +1,39 @@
+package com.jantuomi.interpreter.main.core.parser.ast;
+
+import com.jantuomi.interpreter.main.core.parser.datatype.DataContainer;
+import com.jantuomi.interpreter.main.core.tokenizer.token.Token;
+import com.jantuomi.interpreter.main.exception.ExceptionManager;
+import com.jantuomi.interpreter.main.exception.InterpreterException;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by jan on 16.6.2016.
+ */
+public class MultiplicationNode extends BinaryOperatorNode {
+
+    public MultiplicationNode(Token token, ASTNode lhs, ASTNode rhs) {
+        super(token, lhs, rhs);
+    }
+
+    @Override
+    public DataContainer evaluate() throws InterpreterException {
+        DataContainer operand1 = lhs.evaluate();
+        DataContainer operand2 = rhs.evaluate();
+
+        DataContainer result = operand1.multiply(operand2);
+        if (result != null) {
+            return result;
+        } else {
+            ExceptionManager.raise(InterpreterException.ExceptionType.TypeError, source.getLine(),
+                    operand1.getType().toString(), operand2.getType().toString());
+            return null;
+        }
+
+    }
+    @Override
+    List<ASTNode> getChildren() {
+        return Arrays.asList(lhs, rhs);
+    }
+}
diff --git a/main/core/parser/datatype/DoubleDataContainer.java b/main/core/parser/datatype/DoubleDataContainer.java
index 76849c2..9564ff9 100644
--- a/main/core/parser/datatype/DoubleDataContainer.java
+++ b/main/core/parser/datatype/DoubleDataContainer.java
@@ -21,30 +21,66 @@ public class DoubleDataContainer extends DataContainer<Double> {
     }
 
     @Override
-    public DataContainer<Double> add(DataContainer<Double> other) throws InterpreterException {
-        return new DoubleDataContainer(
-                getData() + other.getData()
-        );
+    public DataContainer add(DataContainer other) throws InterpreterException {
+        switch (other.getType()) {
+            case Double:
+                return new DoubleDataContainer(
+                        getData() + ((DoubleDataContainer) other).getData()
+                );
+            case Integer:
+                return new DoubleDataContainer(
+                        getData() + ((IntegerDataContainer) other).getData()
+                );
+            default:
+                return null;
+        }
     }
 
     @Override
-    public DataContainer<Double> subtract(DataContainer<Double> other) throws InterpreterException {
-        return new DoubleDataContainer(
-                getData() - other.getData()
-        );
+    public DataContainer subtract(DataContainer other) throws InterpreterException {
+        switch (other.getType()) {
+            case Double:
+                return new DoubleDataContainer(
+                        getData() - ((DoubleDataContainer) other).getData()
+                );
+            case Integer:
+                return new DoubleDataContainer(
+                        getData() - ((IntegerDataContainer) other).getData()
+                );
+            default:
+                return null;
+        }
     }
 
     @Override
-    public DataContainer<Double> multiply(DataContainer<Double> other) throws InterpreterException {
-        return new DoubleDataContainer(
-                getData() * other.getData()
-        );
+    public DataContainer multiply(DataContainer other) throws InterpreterException {
+        switch (other.getType()) {
+            case Double:
+                return new DoubleDataContainer(
+                        getData() * ((DoubleDataContainer) other).getData()
+                );
+            case Integer:
+                return new DoubleDataContainer(
+                        getData() * ((IntegerDataContainer) other).getData()
+                );
+            default:
+                return null;
+        }
     }
 
     @Override
-    public DataContainer<Double> divide(DataContainer<Double> other) throws InterpreterException {
-        return new DoubleDataContainer(
-                getData() / other.getData()
-        );
+    public DataContainer divide(DataContainer other) throws InterpreterException {
+        switch (other.getType()) {
+            case Double:
+                return new DoubleDataContainer(
+                        getData() / ((DoubleDataContainer) other).getData()
+                );
+            case Integer:
+                return new DoubleDataContainer(
+                        getData() / ((IntegerDataContainer) other).getData()
+                );
+            default:
+                return null;
+        }
     }
 }
diff --git a/main/core/tokenizer/Tokenizer.java b/main/core/tokenizer/Tokenizer.java
index 3501737..9ff1e4c 100644
--- a/main/core/tokenizer/Tokenizer.java
+++ b/main/core/tokenizer/Tokenizer.java
@@ -34,7 +34,12 @@ public class Tokenizer {
 
     private Tokenizer() {
         tokenRegexes.put(Token.Type.CommentToken, "^\\/\\*(.*?)\\*\\/");
+
+        tokenRegexes.put(Token.Type.DoubleLiteralToken, "^([-+]?[0-9]*\\.?[0-9]+)f\\b");
+        tokenRegexes.put(Token.Type.IntegerLiteralToken, "^([-+]?\\d+)\\b");
+        tokenRegexes.put(Token.Type.BooleanLiteralToken, "^(true|false)\\b");
         tokenRegexes.put(Token.Type.StringLiteralToken, "^\"(.*?)\"");
+
         tokenRegexes.put(Token.Type.WhitespaceToken, "^( |\t)");
         tokenRegexes.put(Token.Type.NewlineToken, "^(\n|\r\n)");
         tokenRegexes.put(Token.Type.AdditionToken, "^(\\+)");
@@ -57,8 +62,7 @@ public class Tokenizer {
         tokenRegexes.put(Token.Type.NegationToken, "^(not)\\b");
         tokenRegexes.put(Token.Type.DeclarationToken, "^(decl)\\b");
         tokenRegexes.put(Token.Type.BranchToken, "^(if)\\b");
-        tokenRegexes.put(Token.Type.IntegerLiteralToken, "^(\\d+)");
-        tokenRegexes.put(Token.Type.BooleanLiteralToken, "^(true|false)\\b");
+
         tokenRegexes.put(Token.Type.SymbolToken, "^([a-zA-Z]+\\w*)");
 
         discardedTokenTypes.add(Token.Type.WhitespaceToken);
diff --git a/main/core/tokenizer/token/Token.java b/main/core/tokenizer/token/Token.java
index a9b66e8..d4058cb 100644
--- a/main/core/tokenizer/token/Token.java
+++ b/main/core/tokenizer/token/Token.java
@@ -33,32 +33,42 @@ abstract public class Token {
     /* Token types, ordered by precedence */
     public enum Type {
         CommentToken,
+
         AdditionToken,
         SubtractionToken,
         DivisionToken,
         MultiplicationToken,
+
         AssignmentToken,
+
         LessThanToken,
         GreaterThanToken,
         LessOrEqualThanToken,
         GreaterOrEqualThanToken,
         EqualsToken,
         NotEqualsToken,
+
         OpenParenToken,
         ClosedParenToken,
+
         FunctionDefineToken,
         DeclarationToken,
+
         StringLiteralToken,
         IntegerLiteralToken,
         BooleanLiteralToken,
+        DoubleLiteralToken,
+
         WhitespaceToken,
         NewlineToken,
+
         BranchToken,
         SymbolToken,
         EndBlockToken,
         FunctionBodyToken,
         BranchBodyToken,
         NegationToken,
+
         NotAToken
     }
 
@@ -162,10 +172,16 @@ abstract public class Token {
                     return new StringLiteralToken(text, rawText);
                 case BooleanLiteralToken:
                     return new BooleanLiteralToken(text);
+                case DoubleLiteralToken:
+                    return new DoubleLiteralToken(text, rawText);
                 case AdditionToken:
                     return new AdditionToken();
                 case SubtractionToken:
                     return new SubtractionToken();
+                case MultiplicationToken:
+                    return new MultiplicationToken();
+                case DivisionToken:
+                    return new DivisionToken();
                 case FunctionDefineToken:
                     return new FunctionDefineToken();
                 case EndBlockToken:
diff --git a/main/core/tokenizer/token/types/DivisionToken.java b/main/core/tokenizer/token/types/DivisionToken.java
new file mode 100644
index 0000000..14f4d13
--- /dev/null
+++ b/main/core/tokenizer/token/types/DivisionToken.java
@@ -0,0 +1,23 @@
+package com.jantuomi.interpreter.main.core.tokenizer.token.types;
+
+import com.jantuomi.interpreter.main.core.parser.ast.ASTNode;
+import com.jantuomi.interpreter.main.core.parser.ast.DivisionNode;
+import com.jantuomi.interpreter.main.exception.InterpreterException;
+
+/**
+ * Created by jan on 15.6.2016.
+ */
+public class DivisionToken extends BinaryOperatorToken {
+    public DivisionToken() {
+        super(Type.DivisionToken);
+    }
+
+    @Override
+    public ASTNode generateNode() throws InterpreterException {
+        return new DivisionNode(this,
+                lhs.generateNode(),
+                rhs.generateNode()
+        );
+
+    }
+}
diff --git a/main/core/tokenizer/token/types/DoubleLiteralToken.java b/main/core/tokenizer/token/types/DoubleLiteralToken.java
new file mode 100644
index 0000000..1a379eb
--- /dev/null
+++ b/main/core/tokenizer/token/types/DoubleLiteralToken.java
@@ -0,0 +1,32 @@
+package com.jantuomi.interpreter.main.core.tokenizer.token.types;
+
+import com.jantuomi.interpreter.main.core.parser.ast.ASTNode;
+import com.jantuomi.interpreter.main.core.parser.ast.DoubleLiteralNode;
+import com.jantuomi.interpreter.main.core.tokenizer.token.Token;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by jan on 15.6.2016.
+ */
+public class DoubleLiteralToken extends Token{
+    public DoubleLiteralToken(String text, String rawText) {
+        super(Type.DoubleLiteralToken, text, rawText);
+    }
+
+    @Override
+    public ASTNode generateNode() {
+        return new DoubleLiteralNode(this);
+    }
+
+    @Override
+    public Token setArguments(List<Token> args) {
+        return this;
+    }
+
+    @Override
+    public List<Token> getChildren() {
+        return Arrays.asList();
+    }
+}
diff --git a/main/core/tokenizer/token/types/MultiplicationToken.java b/main/core/tokenizer/token/types/MultiplicationToken.java
new file mode 100644
index 0000000..521f01a
--- /dev/null
+++ b/main/core/tokenizer/token/types/MultiplicationToken.java
@@ -0,0 +1,23 @@
+package com.jantuomi.interpreter.main.core.tokenizer.token.types;
+
+import com.jantuomi.interpreter.main.core.parser.ast.ASTNode;
+import com.jantuomi.interpreter.main.core.parser.ast.MultiplicationNode;
+import com.jantuomi.interpreter.main.exception.InterpreterException;
+
+/**
+ * Created by jan on 15.6.2016.
+ */
+public class MultiplicationToken extends BinaryOperatorToken {
+    public MultiplicationToken() {
+        super(Type.MultiplicationToken);
+    }
+
+    @Override
+    public ASTNode generateNode() throws InterpreterException {
+        return new MultiplicationNode(this,
+                lhs.generateNode(),
+                rhs.generateNode()
+        );
+
+    }
+}