lab 1 task C first commit

Task_C/src/interpreter/lisp/Add.java

+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());
+
+	}
+
+}

Task_C/src/interpreter/lisp/CaseConditional.java

+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;
+	}
+
+}

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);

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
 	}
 	

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);
 	}
 

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);
 	}