Interpreter capable of handing variables

1 files changed, 118 insertions, 31 deletions

diff --git a/code/Interpreter/Interpreter.java b/code/Interpreter/Interpreter.java
index 17f2ccf..65cdeb4 100644
--- a/code/Interpreter/Interpreter.java
+++ b/code/Interpreter/Interpreter.java
@@ -1,44 +1,131 @@
 package Interpreter;
 
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Paths;
 import java.util.List;
-import java.util.Scanner;
 
-//Base class for the interpreter
+import Interpreter.Expression.*;
+import Interpreter.Statement.ExpressionStatement;
+import Interpreter.Statement.PrintStatement;
+import Interpreter.Statement.VariableDeclaration;
+
 public class Interpreter {
-    public static void main(String[] args){
-
-        //Allow users to input a single line of code
-        //Still needs some work to re-ask for input after each line
-        if (args.length < 1){
-            Scanner input = new Scanner(System.in);
-            System.out.print("Code: ");
-            String sourceCode = input.nextLine();
-            runInterpreter(sourceCode);
-            input.close();
-
-        //Allow users to provide a path to a file as an argument
-        } else if (args.length==1){
-            try {
-                String sourcecode = Files.readString(Paths.get(args[0]));  //Maybe should set charset here
-                runInterpreter(sourcecode);
-            } catch (IOException exception){
-                System.out.println("File not found");
+
+    private Environment environment = new Environment();
+
+    void interpret(List<Statement> statements){
+        try{
+            for (Statement statement: statements){
+                evaluateStatement(statement);
             }
+        } catch (Error e){
 
-        } else {
-            System.out.println("Error, argument should be file path");
-            System.exit(64);
         }
     }
 
-    private static void runInterpreter(String sourceCode){
-        TokenScanner scanner = new TokenScanner();
-        List<Token> tokens = scanner.extractTokens(sourceCode);
-        for (Token token : tokens) {
-            System.out.println(token);
+    private Object evaluateStatement(Statement statement){
+        switch(statement.getStatmentType()){
+            case "exprStmt":
+                return evalExpressionStatement((ExpressionStatement)statement);
+            case "vardec":
+                return evalVariableDeclaration((VariableDeclaration)statement);
+            case "print":
+                return evalPrintStatement((PrintStatement)statement);
+            default:
+                return null;
+        }
+    } 
+    private Object evalExpressionStatement(ExpressionStatement stmt){
+        return evaluateExpression(stmt.expr);
+    }
+
+    private Object evalVariableDeclaration(VariableDeclaration vardec){
+        environment.defineVariable(vardec.name.text, null);
+        return null;
+    }
+
+    private Object evalPrintStatement(PrintStatement print){
+        System.out.println(evaluateExpression(print.expr));
+        return null;
+    }
+
+    private Object evaluateExpression(Expression expression){
+        switch(expression.getExpressionType()){
+            case "binary":
+                return evaluateBinaryExpression((Binary)expression);
+            case "literal":
+                return evaluateLiteralExpression((Literal)expression);
+            case "bracket":
+                return evaluateBracketedExpression((BracketedExpression)expression);
+            case "assign":
+                return evaluateAssignmentExpression((AssignmentExpression)expression);
+            case "var":
+                return evaluateVariableExpression((Variable)expression);
+            default:
+                return null;
+        }
+    }
+
+    private Object evaluateBinaryExpression(Binary expr){
+        Object leftEval = evaluateExpression(expr.left);
+        Object rightEval = evaluateExpression(expr.right);
+        switch (expr.op.type){
+            case PLUS:
+                if (checkOperandsNum(leftEval, leftEval)){
+                    return (double)leftEval + (double)rightEval;
+                } 
+            case STAR:
+                if (checkOperandsNum(leftEval, leftEval)){
+                    return (double)leftEval * (double)rightEval;
+                } 
+            case MINUS:
+                if (checkOperandsNum(leftEval, leftEval)){
+                    return (double)leftEval - (double)rightEval;
+                }
+            case SLASH:
+                if (checkOperandsNum(leftEval, leftEval)){
+                    return (double)leftEval / (double)rightEval;
+                }
+
+            case GREATER:
+                if (checkOperandsNum(leftEval, leftEval)){
+                    return (double)leftEval > (double)rightEval;
+                }
+            case LESS:
+                if (checkOperandsNum(leftEval, leftEval)){
+                    return (double)leftEval < (double)rightEval;
+                }
+            
+            case EQUALITY:
+                return leftEval.equals(rightEval);
+            default:
+                break;
+        }
+        return null;
+    }
+
+    private Object evaluateLiteralExpression(Literal expr){
+        return expr.value.value;
+    }
+
+    private Object evaluateBracketedExpression(BracketedExpression expr){
+        return evaluateExpression(expr.expr);
+    }
+
+    private Object evaluateAssignmentExpression(AssignmentExpression expr){
+        Object assignedValue = evaluateExpression(expr.value);
+        environment.assignVariable(expr.name.text, assignedValue);
+        return null;
+    }
+
+    private Object evaluateVariableExpression(Variable expr){
+        return environment.getVariable(expr.name.text);
+    }
+
+    private boolean checkOperandsNum(Object left, Object right){
+        if (left instanceof Double && right instanceof Double){
+            return true;
+        } else {
+            Language.displayError("Operands must be numbers");
+            throw new Error();
         }
     }
 }