Interpreter

Viktor Reichert · Viktor Reichert · commit d040c57fee72 · 2022-11-30T09:45:17.000+01:00
diff --git a/src/interpreter/Add.java b/src/interpreter/Add.java
@@ -0,0 +1,25 @@
+package interpreter;
+
+public class Add implements Expression{
+    Expression a;
+    Expression b;
+
+    public Add(Expression a, Expression b) {
+        this.a = a;
+        this.b = b;
+    }
+
+    public Expression getA() {
+        return a;
+    }
+
+    public Expression getB() {
+        return b;
+    }
+
+    @Override
+    public <R> R inteprete(Interpreter<R> interpreter) {
+        return interpreter.interprete(this);
+    }
+
+}
diff --git a/src/interpreter/BooleanInterpreter.java b/src/interpreter/BooleanInterpreter.java
@@ -0,0 +1,31 @@
+package interpreter;
+
+import java.util.Map;
+
+public class BooleanInterpreter implements Interpreter<Boolean>{
+    Map<String, Boolean> variables;
+
+    public BooleanInterpreter(Map<String, Boolean> variables) {
+        this.variables = variables;
+    }
+
+    @Override
+    public Boolean interprete(Node node) {
+        return variables.get(node.getValue());
+    }
+
+    @Override
+    public Boolean interprete(Add add) {
+        return add.getA().inteprete(this) || add.getB().inteprete(this);
+    }
+
+    @Override
+    public Boolean interprete(Multiply multiply) {
+        return multiply.getA().inteprete(this) && multiply.getB().inteprete(this);
+    }
+
+    @Override
+    public Boolean interprete(Minus minus) {
+        return !minus.getA().inteprete(this);
+    }
+}
diff --git a/src/interpreter/Demo.java b/src/interpreter/Demo.java
@@ -0,0 +1,38 @@
+package interpreter;
+
+import java.util.Map;
+
+public class Demo {
+    public static void main(String[] args) {
+        Node a = new Node("a");
+        Node b = new Node("b");
+        Node c = new Node("c");
+        Expression expr = new Add(new Multiply(new Minus(a), b), c);
+
+        Map<String, Boolean> variables = Map.ofEntries(
+                Map.entry("a", true),
+                Map.entry("b", false),
+                Map.entry("c", true)
+        );
+
+        Interpreter<Boolean> interpreter = new BooleanInterpreter(variables);
+
+        System.out.println(expr.inteprete(interpreter));
+
+        Map<String, Integer> variablesInteger = Map.ofEntries(
+                Map.entry("a", 3),
+                Map.entry("b", 4),
+                Map.entry("c", 5)
+        );
+
+        System.out.println(expr.inteprete(new IntegerIntepreter(variablesInteger)));
+
+        System.out.println(expr.inteprete(new ReadableIntepreter()));
+
+        String input = "4 2 3 + * a - +";
+
+        Expression expression = PolishParser.parse(input);
+        System.out.println(expression.inteprete(new ReadableIntepreter()));
+
+    }
+}
diff --git a/src/interpreter/Expression.java b/src/interpreter/Expression.java
@@ -0,0 +1,5 @@
+package interpreter;
+
+public interface Expression {
+    <R> R inteprete(Interpreter<R> interpreter);
+}
diff --git a/src/interpreter/IntegerIntepreter.java b/src/interpreter/IntegerIntepreter.java
@@ -0,0 +1,31 @@
+package interpreter;
+
+import java.util.Map;
+
+public class IntegerIntepreter implements Interpreter<Integer>{
+    Map<String, Integer> variables;
+
+    public IntegerIntepreter(Map<String, Integer> variables) {
+        this.variables = variables;
+    }
+
+    @Override
+    public Integer interprete(Node node) {
+        return variables.get(node.getValue());
+    }
+
+    @Override
+    public Integer interprete(Add add) {
+        return add.getA().inteprete(this) + add.getB().inteprete(this);
+    }
+
+    @Override
+    public Integer interprete(Multiply multiply) {
+        return multiply.getA().inteprete(this) * multiply.getB().inteprete(this);
+    }
+
+    @Override
+    public Integer interprete(Minus minus) {
+        return -minus.getA().inteprete(this);
+    }
+}
diff --git a/src/interpreter/Interpreter.java b/src/interpreter/Interpreter.java
@@ -0,0 +1,11 @@
+package interpreter;
+
+public interface Interpreter<R> {
+    R interprete(Node node);
+
+    R interprete(Add add);
+
+    R interprete(Multiply multiply);
+
+    R interprete(Minus minus);
+}
diff --git a/src/interpreter/Minus.java b/src/interpreter/Minus.java
@@ -0,0 +1,19 @@
+package interpreter;
+
+public class Minus implements Expression {
+    private Expression a;
+
+    public Minus(Expression a) {
+        this.a = a;
+    }
+
+    public Expression getA() {
+        return a;
+    }
+
+    @Override
+    public <R> R inteprete(Interpreter<R> interpreter) {
+        return interpreter.interprete(this);
+    }
+
+}
diff --git a/src/interpreter/Multiply.java b/src/interpreter/Multiply.java
@@ -0,0 +1,25 @@
+package interpreter;
+
+public class Multiply implements Expression{
+    Expression a;
+    Expression b;
+
+    public Multiply(Expression a, Expression b) {
+        this.a = a;
+        this.b = b;
+    }
+
+    public Expression getA() {
+        return a;
+    }
+
+    public Expression getB() {
+        return b;
+    }
+
+    @Override
+    public <R> R inteprete(Interpreter<R> interpreter) {
+        return interpreter.interprete(this);
+    }
+
+}
diff --git a/src/interpreter/Node.java b/src/interpreter/Node.java
@@ -0,0 +1,25 @@
+package interpreter;
+
+public class Node implements Expression{
+    private String value;
+
+    public Node(String value) {
+        this.value = value;
+    }
+
+    @Override
+    public <R> R inteprete(Interpreter<R> interpreter) {
+        return interpreter.interprete(this);
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return "Node{" +
+                "value='" + value + '\'' +
+                '}';
+    }
+}
diff --git a/src/interpreter/PolishParser.java b/src/interpreter/PolishParser.java
@@ -0,0 +1,21 @@
+package interpreter;
+
+import java.util.Stack;
+
+public class PolishParser {
+    public static Expression parse(String input) {
+        Stack<Expression> stack = new Stack<>();
+        String[] parts = input.split(" ");
+
+        for (String part : parts) {
+            Expression expression = switch (part) {
+                case "+" -> new Add(stack.pop(), stack.pop());
+                case "-" -> new Minus(stack.pop());
+                case "*" -> new Multiply(stack.pop(), stack.pop());
+                default -> new Node(part);
+            };
+            stack.add(expression);
+        }
+        return stack.pop();
+    }
+}
diff --git a/src/interpreter/ReadableIntepreter.java b/src/interpreter/ReadableIntepreter.java
@@ -0,0 +1,29 @@
+package interpreter;
+
+import java.util.Map;
+
+public class ReadableIntepreter implements Interpreter<String>{
+
+    public ReadableIntepreter() {
+    }
+
+    @Override
+    public String interprete(Node node) {
+        return node.getValue();
+    }
+
+    @Override
+    public String interprete(Add add) {
+        return "(" + add.getA().inteprete(this) +"+"+ add.getB().inteprete(this) +")";
+    }
+
+    @Override
+    public String interprete(Multiply multiply) {
+        return multiply.getA().inteprete(this) +"*"+ multiply.getB().inteprete(this);
+    }
+
+    @Override
+    public String interprete(Minus minus) {
+        return "(-" + minus.getA().inteprete(this) + ")";
+    }
+}
