diff --git a/Task_C/src/interpreter/lisp/Add.java b/Task_C/src/interpreter/lisp/Add.java new file mode 100644 index 0000000000000000000000000000000000000000..4ad5f75734e4c8a73ec5c14b7a4b49e5b0263f58 --- /dev/null +++ b/Task_C/src/interpreter/lisp/Add.java @@ -0,0 +1,16 @@ +package interpreter.lisp; + +public class Add extends BinaryExpression<Num>{ + + public Add() { + // TODO Auto-generated constructor stub + } + + @Override + Expr evalBinaryExpression(Num value1, Num value2) { + // TODO Auto-generated method stub + return new Num(value1.getValue()+value2.getValue()); + + } + +} diff --git a/Task_C/src/interpreter/lisp/CaseConditional.java b/Task_C/src/interpreter/lisp/CaseConditional.java new file mode 100644 index 0000000000000000000000000000000000000000..2fb7f4fbb0c36742faa6dc9e05d24fbf97308e61 --- /dev/null +++ b/Task_C/src/interpreter/lisp/CaseConditional.java @@ -0,0 +1,29 @@ +package interpreter.lisp; +import java.util.List; + +public class CaseConditional extends CompoundExpression{ + private Expr cond; + private List<Expr> valsExpr; + + public CaseConditional(Expr cond, List<Expr> valExpr) { + // TODO Auto-generated constructor stub + this.cond = cond; + this.valsExpr = valExpr; + } + + @Override + public Expr evaluate(Context context) { + // TODO Auto-generated method stub + Expr correctExpr; + for (int i = 0; i < valsExpr.size(); i++) { + CompoundExpression expr = (CompoundExpression) valsExpr.get(i); + if (new Eq().evalBinaryExpression(cond.evaluate(context), + expr.getElements().get(0).evaluate(context)) == Constants.TRUE) { + correctExpr =expr.getElements().get(1).evaluate(context); + return correctExpr; + } + } + return Constants.FALSE; + } + +} diff --git a/Task_C/src/interpreter/lisp/CompoundExpression.java b/Task_C/src/interpreter/lisp/CompoundExpression.java index 705a11cabb1e78e25814d013b6c35bb8dcf332f3..e5a957bf3351f75272b66b0ba9671803a3d12dca 100755 --- a/Task_C/src/interpreter/lisp/CompoundExpression.java +++ b/Task_C/src/interpreter/lisp/CompoundExpression.java @@ -6,6 +6,7 @@ import java.util.List; public class CompoundExpression implements Expr { private List<Expr> elements = new ArrayList<Expr>(); + private Context context; public void add(Expr node) { elements.add(node); @@ -27,6 +28,8 @@ public class CompoundExpression implements Expr { } else if (keyword.equals("if")) { return new Conditional(elements.get(1), elements.get(2), elements.get(3)).evaluate(context); + } else if (keyword.equals("case")) { + return new CaseConditional(elements.get(1), elements.subList(2, elements.size())).evaluate(context); } } return new FunctionCall((Symbol) elements.get(0),elements.subList(1,elements.size())).evaluate(context); diff --git a/Task_C/src/interpreter/lisp/Context.java b/Task_C/src/interpreter/lisp/Context.java index 5d8ebee1206d5ee9601761844c92a55963b6c19a..ec3e3efaceb87c8e16c91bc586d0e3e4ddbde513 100755 --- a/Task_C/src/interpreter/lisp/Context.java +++ b/Task_C/src/interpreter/lisp/Context.java @@ -14,6 +14,8 @@ public class Context { bindings.put(new Symbol("="), new Eq()); bindings.put(new Symbol("*"), new Mult()); bindings.put(new Symbol("-"), new Sub()); + bindings.put(new Symbol("+"), new Add()); + // Add new top level bindings here } diff --git a/Task_C/src/interpreter/lisp/InterpreterTest.java b/Task_C/src/interpreter/lisp/InterpreterTest.java index ee5121a621058dbfb07f5252a37f0f98d5ac960c..60892e69e9d57d5f06e3ca0f8d2f6af6f192ac6f 100755 --- a/Task_C/src/interpreter/lisp/InterpreterTest.java +++ b/Task_C/src/interpreter/lisp/InterpreterTest.java @@ -5,6 +5,9 @@ public class InterpreterTest { public static void main(String[] args) { Expr expr = Reader .read("(def fac (x) (if (= x 0) 1 (* x (fac (- x 1)))))"); + + + /* * The expression above is a function definition of the function 'fac' * with parameter 'x', that calculates the factorial of x. @@ -25,8 +28,11 @@ public class InterpreterTest { */ Expr result = expr.evaluate(Context.getTopLevelContext()); - Expr expr2 = Reader.read("(fac 5)"); // fac(5) in Python - result = expr2.evaluate(Context.getTopLevelContext()); + Expr expr2 = Reader.read("(case 2 ((* 1 2) (- 1 5)) (1 3)"); + Expr expr3 = Reader.read("(case (* 3 (+ 1 2)) ((+ 6 2) 0) (14 2) ((+ 6 3) (- 2 1))))"); + + //Expr expr2 = Reader.read("(fac 5)"); // fac(5) in Python + result = expr3.evaluate(Context.getTopLevelContext()); System.out.println(result); } diff --git a/Task_C/src/visitor/Minus.java b/Task_C/src/visitor/Minus.java index 87866410ec7f4bc99ab7ef12fd85d00ff15d28a9..6ed38a645fe3ce692233c429b7a1eac00d0a5464 100755 --- a/Task_C/src/visitor/Minus.java +++ b/Task_C/src/visitor/Minus.java @@ -13,8 +13,10 @@ public class Minus extends CompoundExpression { @Override public void accept(Visitor v) { - v.visit(leftOperand); - v.visit(rightOperand); + //v.visit(leftOperand); + //v.visit(rightOperand); + leftOperand.accept(v); + rightOperand.accept(v); v.visit(this); }