Refactoring.

3 files changed, 254 insertions, 1 deletions

diff --git a/config/list/library.lst b/config/list/library.lst
index aecd89e168..3d80ce9cab 100644
--- a/config/list/library.lst
+++ b/config/list/library.lst
@@ -11,7 +11,9 @@ BufferedIterator.scala
 Byte.java
 Cell.scala
 Char.java
+Console.scala
 Double.java
+Executable.scala
 Float.java
 Function0.java
 Function1.java
diff --git a/sources/scala/Console.scala b/sources/scala/Console.scala
new file mode 100644
index 0000000000..a70ef7325d
--- /dev/null
+++ b/sources/scala/Console.scala
@@ -0,0 +1,249 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003, LAMP/EPFL                  **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+** $Id$
+\*                                                                      */
+
+package scala;
+
+
+/** The <code>Console</code> object implements functionality for
+ *  printing Scala values on the terminal. There are also functions
+ *  for reading specific values. <code>Console</code> also defines
+ *  constants for marking up text on ANSI terminals.
+ *
+ *  @author  Matthias Zenger
+ *  @version 1.0, 03/09/2003
+ */
+object Console {
+    import java.io._;
+    import java.text._;
+
+    // ANSI colors foreground
+	final val BLACK      = "\033[30m";
+	final val RED        = "\033[31m";
+	final val GREEN      = "\033[32m";
+	final val YELLOW     = "\033[33m";
+	final val BLUE       = "\033[34m";
+	final val MAGENTA    = "\033[35m";
+	final val CYAN       = "\033[36m";
+	final val WHITE      = "\033[37m";
+
+	// ANSI colors background
+	final val BLACK_B    = "\033[40m";
+	final val RED_B      = "\033[41m";
+	final val GREEN_B    = "\033[42m";
+	final val YELLOW_B   = "\033[43m";
+	final val BLUE_B     = "\033[44m";
+	final val MAGENTA_B  = "\033[45m";
+	final val CYAN_B     = "\033[46m";
+	final val WHITE_B    = "\033[47m";
+
+	// ANSI styles
+	final val RESET      = "\033[0m";
+	final val BOLD       = "\033[1m";
+	final val UNDERLINED = "\033[4m";
+	final val BLINK      = "\033[5m";
+	final val REVERSED   = "\033[7m";
+	final val INVISIBLE  = "\033[8m";
+
+    private var out: PrintStream = System.out;
+    private var in: BufferedReader =
+    	new BufferedReader(new InputStreamReader(System.in));
+
+    /** Set the default output stream.
+     *
+     *  @param out the new output stream.
+     */
+    def setOut(out: PrintStream): Unit = {
+    	this.out = out;
+    }
+
+    /** Set the default input stream.
+     *
+     *  @param in the new input stream.
+     */
+    def setIn(in: InputStream): Unit = {
+    	this.in = new BufferedReader(new InputStreamReader(in));
+    }
+
+    /** Set the default input stream.
+     *
+     *  @param reader specifies the new input stream.
+     */
+    def setIn(reader: Reader): Unit = {
+    	this.in = new BufferedReader(reader);
+    }
+
+    /** Print an object on the terminal.
+     *
+     *  @param obj the object to print.
+     */
+    def print(obj: Any): Unit = {
+    	if (obj == null)
+    		out.print("null");
+    	else
+    		out.print(obj.toString());
+    }
+
+	/** Flush the output stream. This function is required when partial
+	 *  output (i.e. output not terminated by a new line character) has
+	 *  to be made visible on the terminal.
+	 */
+	def flush: Unit = out.flush();
+
+	/** Print a new line character on the terminal.
+	 */
+    def println: Unit = {
+        out.println();
+    }
+
+	/** Print out an object followed by a new line character.
+	 *
+	 *  @param x the object to print.
+	 */
+    def println(x: Any): Unit = {
+        out.println(x);
+    }
+
+    /** Format and print out some text (in a fashion similar to printf in C).
+     *  The format of the text to print is specified by the parameter
+     *  <code>text</code>. The arguments that are inserted into specific
+     *  locations in <code>text</code> are provided with parameter
+     *  <code>args</code>. See class <code>java.text.MessageFormat</code>
+     *  for a full specification of the format syntax.
+     *
+     *  @param text the format of the text to print out.
+     *  @param args the parameters used to instantiate the format.
+     */
+    def printf(text: String)(args: Any*): Unit = {
+        if (text == null)
+            out.print("null");
+        else
+        	out.print(MessageFormat.format(text, textParams(args)));
+    }
+
+    /** Read a full line from the terminal.
+     *
+     *  @return the string read from the terminal.
+     */
+    def readLine: String = in.readLine();
+
+    /** Read a boolean value from the terminal.
+     *
+     *  @return the boolean value read from the terminal.
+     */
+    def readBoolean: Boolean = in.readLine().toLowerCase() match {
+    	case "true" => true
+    	case "t" => true
+    	case "yes" => true
+    	case "y" => true
+    	case _ => false
+    }
+
+    /** Read a byte value from the terminal.
+     */
+    def readByte: Byte = java.lang.Byte.decode(in.readLine()).byteValue();
+
+    /** Read a short value from the terminal.
+     */
+    def readShort: Short = java.lang.Short.decode(in.readLine()).shortValue();
+
+    /** Read a char value from the terminal.
+     */
+    def readChar: Char = in.readLine().charAt(0);
+
+    /** Read an int value from the terminal.
+     */
+    def readInt: Int = java.lang.Integer.decode(in.readLine()).intValue();
+
+    /** Read a float value from the terminal.
+     */
+    def readFloat: Float = java.lang.Float.parseFloat(in.readLine());
+
+    /** Read a double value from the terminal.
+     */
+    def readDouble: Double = java.lang.Double.parseDouble(in.readLine());
+
+    /** Read in some structured input, specified by a format specifier.
+     *  See class <code>java.text.MessageFormat</code> for details of
+     *  the format specification.
+     *
+     *  @param format the format of the input.
+     *  @return a list of all extracted values.
+     */
+    def readf(format: String): List[Any] =
+    	textComponents(new MessageFormat(format).parse(in.readLine()));
+
+   	/** Read in some structured input, specified by a format specifier.
+   	 *  Opposed to <code>readf</code>, this function only returns the
+   	 *  first value extracted from the input according to the format
+   	 *  specification.
+   	 */
+   	def readf1(format: String): Any = readf(format).head;
+
+   	/** Read in some structured input, specified by a format specifier.
+   	 *  Opposed to <code>readf</code>, this function only returns the
+   	 *  first two values extracted from the input according to the format
+   	 *  specification.
+   	 */
+   	def readf2(format: String): Pair[Any, Any] = {
+   		val res = readf(format);
+   		Pair(res.head, res.tail.head)
+   	}
+
+    /** Read in some structured input, specified by a format specifier.
+   	 *  Opposed to <code>readf</code>, this function only returns the
+   	 *  first three values extracted from the input according to the format
+   	 *  specification.
+   	 */
+    def readf3(format: String): Triple[Any, Any, Any] = {
+   		val res = readf(format);
+   		Triple(res.head, res.tail.head, res.tail.tail.head)
+   	}
+
+    private def textComponents(a: Array[AnyRef]): List[Any] = {
+    	var i: Int = a.length - 1;
+    	var res: List[Any] = Nil;
+    	while (i >= 0) {
+    	    res = (a(i) match {
+    	    	case x: java.lang.Boolean => x.booleanValue()
+    	    	case x: java.lang.Byte => x.byteValue()
+    	    	case x: java.lang.Short => x.shortValue()
+    	    	case x: java.lang.Character => x.charValue()
+    	    	case x: java.lang.Integer => x.intValue()
+    	    	case x: java.lang.Long => x.longValue()
+    	    	case x: java.lang.Float => x.floatValue()
+    	    	case x: java.lang.Double => x.doubleValue()
+    	    	case x => x
+    	    }) :: res;
+    	    i = i - 1;
+    	}
+    	res
+    }
+
+    private def textParams(s: Seq[Any]): Array[AnyRef] = {
+    	val res = new Array[java.lang.Object](s.length);
+    	var i: Int = 0;
+    	val iter = s.elements;
+    	while (iter.hasNext) {
+    		res(i) = iter.next match {
+    			case x: Boolean => new java.lang.Boolean(x);
+    			case x: Byte => new java.lang.Byte(x);
+    			case x: Short => new java.lang.Short(x);
+    			case x: Char => new java.lang.Character(x);
+    			case x: Int => new java.lang.Integer(x);
+    			case x: Long => new java.lang.Long(x);
+    			case x: Float => new java.lang.Float(x);
+    			case x: Double => new java.lang.Double(x);
+    			case x: Unit => "()";
+    			case x: AnyRef => x;
+    		}
+    		i = i + 1;
+    	}
+    	res
+    }
+}
diff --git a/sources/scala/collection/immutable/GBTree.scala b/sources/scala/collection/immutable/GBTree.scala
index 39cafff0cc..3fc18cd36b 100755
--- a/sources/scala/collection/immutable/GBTree.scala
+++ b/sources/scala/collection/immutable/GBTree.scala
@@ -402,11 +402,13 @@ class GBTree[A <: Ord[A], B]() with scala.collection.immutable.Map[A, B, GBTree[
   */
   private val p = 2; // It seems that p = 2 is optimal for sorted keys */
   private def pow(a:int, b:int):int =
+  	if (a == 2) a * a else if (a == 1) a else a * pow(a, b - 1);
+  	/*
     a.match {
       case 2 => a * a;
       case 1 => a;
       case x if x > 0 => a * pow(a, b-1);
-    };
+    }; */
   private def div2(x:int) = x >> 1;
   private def mul2(x:int) = x << 1;
   private def max(x:int, y:int) = if(x < y) y; else x;