Cleaned up the code.

4 files changed, 22 insertions, 22 deletions

diff --git a/sources/scala/Monitor.scala b/sources/scala/Monitor.scala
index c03c7bd2ef..168f72a6ca 100644
--- a/sources/scala/Monitor.scala
+++ b/sources/scala/Monitor.scala
@@ -11,7 +11,7 @@ package scala;
 
 trait Monitor {
 
-	def synchronized[a](def p: a): a = NativeMonitor.synchronised(this, p);
+    def synchronized[a](def p: a): a = NativeMonitor.synchronised(this, p);
 
-	def await(def cond: Boolean) = while (!cond) { this.wait() }
+    def await(def cond: Boolean) = while (!cond) { this.wait() }
 }
diff --git a/sources/scala/NativeLoop.java b/sources/scala/NativeLoop.java
index 8751c15cb7..921259b90b 100644
--- a/sources/scala/NativeLoop.java
+++ b/sources/scala/NativeLoop.java
@@ -15,8 +15,8 @@ public class NativeLoop {
     /** @meta method [?A] (def scala.Boolean, def ?A) scala.Unit;
      */
     public static void loopWhile(scala.Function0 cond, scala.Function0 body) {
-    	while (((scala.Boolean)cond.apply()).asBoolean()) {
-    		body.apply();
-    	}
+        while (((scala.Boolean)cond.apply()).asBoolean()) {
+            body.apply();
+        }
     }
 }
diff --git a/sources/scala/Predef.scala b/sources/scala/Predef.scala
index 8556c2f21b..33a5cb7987 100644
--- a/sources/scala/Predef.scala
+++ b/sources/scala/Predef.scala
@@ -50,7 +50,7 @@ object Predef {
 
     def while(def cond: Boolean)(def body: Unit): Unit = NativeLoop.loopWhile(cond, body);
         /* if (cond) {
-            command; while(cond)(body)
+            body; while(cond)(body)
         } */
 
     trait Until {
diff --git a/sources/scala/SynchronizedSet.scala b/sources/scala/SynchronizedSet.scala
index 6c78ebddf8..8886ae18ed 100644
--- a/sources/scala/SynchronizedSet.scala
+++ b/sources/scala/SynchronizedSet.scala
@@ -14,66 +14,66 @@ package scala;
 trait SynchronizedSet[A] extends Set[A] with Monitor {
 
     override def size: Int = synchronized {
-    	super.size
+        super.size
     }
 
     override def isEmpty: Boolean = synchronized {
-    	super.isEmpty
+        super.isEmpty
     }
 
     override def contains(elem: A) = synchronized {
-    	super.contains(elem);
+        super.contains(elem);
     }
 
     override def add(elem: A): Unit = synchronized {
-    	super.add(elem);
+        super.add(elem);
     }
 
     override def addAll(elems: A*): Unit = synchronized {
-    	super.addSet(elems);
+        super.addSet(elems);
     }
 
     override def addSet(that: Iterable[A]) = synchronized {
-    	super.addSet(that);
+        super.addSet(that);
     }
 
     override def remove(elem: A): Unit = synchronized {
-    	super.remove(elem);
+        super.remove(elem);
     }
 
     override def removeAll(elems: A*): Unit = synchronized {
-    	super.removeSet(elems);
+        super.removeSet(elems);
     }
 
     override def removeSet(that: Iterable[A]) = synchronized {
-    	super.removeSet(that);
+        super.removeSet(that);
     }
 
     override def intersect(that: Set[A]) = synchronized {
-    	super.intersect(that);
+        super.intersect(that);
     }
 
     override def clear: Unit = synchronized {
-    	super.clear;
+        super.clear;
     }
 
     override def subsetOf(that: Set[A]) = synchronized {
-    	super.subsetOf(that);
+        super.subsetOf(that);
     }
 
     override def foreach(f: A => Unit) = synchronized {
-    	super.foreach(f);
+        super.foreach(f);
     }
 
     override def filter(p: A => Boolean) = synchronized {
-    	super.filter(p);
+        super.filter(p);
     }
 
     override def toList: List[A] = synchronized {
-    	super.toList;
+        super.toList;
     }
 
     override def toString() = synchronized {
-    	super.toString();
+        super.toString();
     }
 }