diff --git a/sources/zweic/Parser.scala b/sources/zweic/Parser.scala
index a7ff858..ea0536f 100755
--- a/sources/zweic/Parser.scala
+++ b/sources/zweic/Parser.scala
@@ -106,7 +106,7 @@
   private def program(): Program = {
     var classes:List[ClassDef] = Nil;
     while (token == CLASS) {      
-      classDecl() :: classes;
+      classes = classDecl() :: classes;
     }
     var main = expression();
     return Program(classes.reverse, main);
diff --git a/sources/zweic/Printer.scala b/sources/zweic/Printer.scala
index 8faeb06..6d68ab9 100755
--- a/sources/zweic/Printer.scala
+++ b/sources/zweic/Printer.scala
@@ -32,18 +32,152 @@
    */
   def print(tree: Tree): Printer = tree match {
     case Program(decls, main) =>
-      for (val d <- decls)
+      for (val d <- decls) {
         print(d).println;
+      }
       print(main).println      
 
-    case Select(prefix, selector) =>
-      print(prefix).print(".").print(selector)
+//############################################################################
+// Tree nodes for definitions
 
     case ClassDef(name, extend, members) =>
-      print("testtest")
+      print("class ").print(name);
+      extend match {
+	case Some(e) => print(" extends ").print(e);
+	case _ => null;
+      }
+      print(" {")    
+      indent; println;
+      for (val m <- members) {
+	print(m).println;
+      }
+      undent;
+      print("}").println;
 
-    case _ => this
+    case FieldDecl(formal) =>
+      print(formal);
+
+    case MethodDef(name, args, returntype, expression) =>
+      print(returntype).print(" ").print(name).print(" (");
+      for (val a <- args) {	
+	print(a).print(", ");
+      }
+      print(") {").println;
+      indent;
+      print(expression).println;
+      undent;
+      print("}")
+      
+    case Formal(name, typ) =>
+      print(typ).print(" ").print(name);
+
+//############################################################################
+// Tree nodes for types
+
+    case IntType() =>
+      print("Int");
+
+    case NullType() =>
+      print("Null");
+
+    case ClassType(name) =>
+      print(name);
+
+//############################################################################
+// Tree nodes for statements
+
+    case While(cond, stats) =>
+      print("while (").print(cond).print(") {").println;
+      indent;
+      for (val s <- stats) {
+	print(s).println;
+      }
+      undent;
+      print("}");
+
+    case Var(varname, vartype, init) =>
+      print(vartype).print(" ").print(varname).print(" = ").print(init);
+
+    case Set(name, expr) =>
+      print(name).print(" = ").print(expr);
+
+    case Do(expr) =>
+      print(expr);
+
+    case PrintInt(expr) =>
+      print("PrintInt(").print(expr).print(")");
+    
+    case PrintChar(expr) =>
+      print("PrintChar(").print(expr).print(")");
+
+//############################################################################
+// Tree nodes for expressions
+
+    case Ident(name) =>
+      print(name)
+
+    case New(name, args) =>
+      print("new ").print(name).print("(");
+      for (val a <- args) {
+	print(a).print(",");
+      }
+      print(")");
+
+    case Select(prefix, selector) =>
+      print(prefix).print(".").print(selector);
+
+    case Call(obj, funcname, args) =>
+      print(obj).print(".").print(funcname).print("(");
+      for (val a <- args) {
+	print(a).print(",");
+      }
+      print(")");
+
+    case NullLit() =>
+      print("null");
+
+    case IntLit(value) =>
+      print(value.toString());
+
+    case Unop(op, expr) =>
+      print(op.toString()).print(expr);
+
+    case Binop(op, left, right) =>
+      print(left).print(op.toString()).print(right);
+
+    case ReadInt() =>
+      print("ReadInt");
+
+    case ReadChar() =>
+      print("ReadChar");
+
+    case If(cond, stata, statb) =>
+      print("if (").print(cond).print(") {");
+      indent; println;
+      print(stata)
+      undent; println;      
+      print("} else {")
+      indent; println;      
+      print(statb)
+      undent; println;
+      print("}").println;
+
+    case Block(stats, expression) =>
+      print("{")
+      indent; println;
+      for(val s <- stats) {
+	print(s).println;
+      }
+      print("return ").print(expression)
+      undent; println;      
+      print("}").println;
+
+    case x => 
+      this
+
+
   }
+  
 
   /**
    * Print abstract syntax trees separated by commas.