diff --git a/Task_C/.classpath b/Task_C/_classpath.xml
old mode 100755
new mode 100644
similarity index 100%
rename from Task_C/.classpath
rename to Task_C/_classpath.xml
diff --git a/Task_C/.project b/Task_C/_project.xml
old mode 100755
new mode 100644
similarity index 100%
rename from Task_C/.project
rename to Task_C/_project.xml
diff --git a/Task_C/src/interpreter/lisp/Case.java b/Task_C/src/interpreter/lisp/Case.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd67e0703333f05ffc268e82b4dc44cf17db92b6
--- /dev/null
+++ b/Task_C/src/interpreter/lisp/Case.java
@@ -0,0 +1,35 @@
+package interpreter.lisp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Case extends CompoundExpression {
+
+ private Expr condition;
+ private List<Expr> elements = new ArrayList<Expr>();
+
+ public Case(Expr cond, List<Expr> expr) {
+ this.condition = cond;
+ this.elements = expr;
+ }
+
+ public Expr getCondition() {
+ return condition;
+ }
+
+ public List<Expr> getElements() {
+ return elements;
+ }
+
+ @Override
+ public Expr evaluate(Context context) {
+ for(int i = 0; i < elements.size(); i++){
+ CompoundExpression compE = (CompoundExpression)elements.get(i);
+ List<Expr> list = compE.getElements();
+
+ if(list.get(0).evaluate(context).equals(condition.evaluate(context)))
+ return list.get(1).evaluate(context);
+ }
+ return Constants.FALSE;
+ }
+}
diff --git a/Task_C/src/interpreter/lisp/CompoundExpression.java b/Task_C/src/interpreter/lisp/CompoundExpression.java
index 705a11cabb1e78e25814d013b6c35bb8dcf332f3..5dea6c172af1ea0403dd087d79fa179a276740d5 100755
--- a/Task_C/src/interpreter/lisp/CompoundExpression.java
+++ b/Task_C/src/interpreter/lisp/CompoundExpression.java
@@ -27,6 +27,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 Case(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..7a83385dbd0d446486184fe3277ead55755bffa4 100755
--- a/Task_C/src/interpreter/lisp/Context.java
+++ b/Task_C/src/interpreter/lisp/Context.java
@@ -13,6 +13,7 @@ public class Context {
private Context() {
bindings.put(new Symbol("="), new Eq());
bindings.put(new Symbol("*"), new Mult());
+ bindings.put(new Symbol("+"), new Sum());
bindings.put(new Symbol("-"), new Sub());
// 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..88af932653e8023b8410152aed4679c41cc16710 100755
--- a/Task_C/src/interpreter/lisp/InterpreterTest.java
+++ b/Task_C/src/interpreter/lisp/InterpreterTest.java
@@ -3,8 +3,13 @@ package interpreter.lisp;
public class InterpreterTest {
public static void main(String[] args) {
- Expr expr = Reader
- .read("(def fac (x) (if (= x 0) 1 (* x (fac (- x 1)))))");
+// Expr expr = Reader
+// .read("(def fac (x) (if (= x 0) 1 (* x (fac (- x 1)))))");
+
+
+// Expr expr = Reader.read("(def fac (x) (case x(3 0)))");
+ Expr expr = Reader.read("(case 1 (0 0) (1 0))");
+
/*
* The expression above is a function definition of the function 'fac'
* with parameter 'x', that calculates the factorial of x.
@@ -25,8 +30,8 @@ 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("(fac 3)");
+// result = expr2.evaluate(Context.getTopLevelContext());
System.out.println(result);
}
diff --git a/Task_C/src/interpreter/lisp/Sum.java b/Task_C/src/interpreter/lisp/Sum.java
new file mode 100644
index 0000000000000000000000000000000000000000..3124fd75e172e8a09a259a49bc175f25b841f923
--- /dev/null
+++ b/Task_C/src/interpreter/lisp/Sum.java
@@ -0,0 +1,16 @@
+package interpreter.lisp;
+
+public class Sum extends BinaryExpression<Num> {
+
+ /**
+ *
+ * We assume that the operands have been evaluated to Num objects
+ *
+ * @see interpreter.lisp.BinaryExpression#evalBinaryExpression(interpreter.lisp.Expr, interpreter.lisp.Expr)
+ */
+ @Override
+ Expr evalBinaryExpression(Num value1, Num value2) {
+ return new Num(value1.getValue()+value2.getValue());
+ }
+
+}
diff --git a/Task_C/src/polymorphism/PolymorphismTest.java b/Task_C/src/polymorphism/PolymorphismTest.java
index b44832dbb43269fd73a4c62df934f0bc82275a29..1658a8abf61be57903355451cb74a17f3916f366 100755
--- a/Task_C/src/polymorphism/PolymorphismTest.java
+++ b/Task_C/src/polymorphism/PolymorphismTest.java
@@ -7,14 +7,14 @@ public class PolymorphismTest {
ASubClass sub = new ASubClass();
ABaseClass subAsBase = new ASubClass();
// base.aMethod(sub);
- base.aMethod(subAsBase); // The runtime type of subAsBase does not matter here ...
+// base.aMethod(subAsBase); // The runtime type of subAsBase does not matter here ...
// base.aMethod(base);
// sub.aMethod(sub);
- sub.aMethod(subAsBase);
+// sub.aMethod(subAsBase);
// sub.aMethod(base);
subAsBase.aMethod(sub); // but it matters here. Why?
-// subAsBase.aMethod(subAsBase);
-// subAsBase.aMethod(base);
+ subAsBase.aMethod(subAsBase);
+ subAsBase.aMethod(base);
}
diff --git a/Task_C/src/visitor/Minus.java b/Task_C/src/visitor/Minus.java
index 87866410ec7f4bc99ab7ef12fd85d00ff15d28a9..a4d8c45683e4c90b7e2c52d678b35a719a7e4ff3 100755
--- a/Task_C/src/visitor/Minus.java
+++ b/Task_C/src/visitor/Minus.java
@@ -13,9 +13,11 @@ 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);
v.visit(this);
+ rightOperand.accept(v);
}
}
diff --git a/Task_C/src/visitor/PrintVisitor.java b/Task_C/src/visitor/PrintVisitor.java
index af613f8d1b34638b4d10dfae449f202bdd9c8ee5..0d6ae43ef7fd973ceeda835e36bb734018f11f06 100755
--- a/Task_C/src/visitor/PrintVisitor.java
+++ b/Task_C/src/visitor/PrintVisitor.java
@@ -6,12 +6,12 @@ public class PrintVisitor extends Visitor {
@Override
public void visit(Number exp) {
- System.out.print(MessageFormat.format("{0} ", exp.getValue()));
+ System.out.print(MessageFormat.format("({0} ", exp.getValue()));
}
@Override
public void visit(Variable exp) {
- System.out.print(MessageFormat.format("{0} ", exp.getName()));
+ System.out.print(MessageFormat.format("{0}) ", exp.getName()));
}
@Override
@@ -24,5 +24,5 @@ public class PrintVisitor extends Visitor {
System.out.print("- ");
}
-
+
}
diff --git a/Task_C/src/visitor/SimpleExpression.java b/Task_C/src/visitor/SimpleExpression.java
index f754b5229df30096919c7ce8cf0c8c297a1e93dd..0def29678c39b5d937f602e7aed1276d0d4e309b 100755
--- a/Task_C/src/visitor/SimpleExpression.java
+++ b/Task_C/src/visitor/SimpleExpression.java
@@ -2,5 +2,5 @@ package visitor;
public abstract class SimpleExpression extends AbstractExpression {
-
+
}
diff --git a/Task_C/src/visitor/Sum.java b/Task_C/src/visitor/Sum.java
index 8a4902c76d12be026119664bfab1807b715c5edb..8f188a1a26db583eff847ee98889375c3c8a31b0 100755
--- a/Task_C/src/visitor/Sum.java
+++ b/Task_C/src/visitor/Sum.java
@@ -13,9 +13,11 @@ public class Sum extends CompoundExpression {
@Override
public void accept(Visitor v) {
+// v.visit(leftOperand);
+// v.visit(rightOperand);
leftOperand.accept(v);
- rightOperand.accept(v);
v.visit(this);
+ rightOperand.accept(v);
}
diff --git a/Task_C/src/visitor/VisitorTest.java b/Task_C/src/visitor/VisitorTest.java
index e9e3aa559529194d9549a226dc9aa347e2beb0b2..ddcc22e946baf0284db512a1ea6b84f9e6637bc9 100755
--- a/Task_C/src/visitor/VisitorTest.java
+++ b/Task_C/src/visitor/VisitorTest.java
@@ -1,16 +1,17 @@
package visitor;
+import java.text.MessageFormat;
public class VisitorTest {
public static void main(String[] args) {
-// CountingVariablesVisitor v = new CountingVariablesVisitor();
+ CountingVariablesVisitor v = new CountingVariablesVisitor();
AbstractExpression expression = new Sum(new Minus(new Number(1),
new Variable("x", 3)), new Sum(new Number(5), new Variable("y",
7)));
System.out.println(expression.toString());
-// expression.accept(v);
-// System.out.println(MessageFormat.format(
-// "There were {0} variables in the expression", v.getCount()));
+ expression.accept(v);
+ System.out.println(MessageFormat.format(
+ "There were {0} variables in the expression", v.getCount()));
expression.accept(new PrintVisitor());
}
}