Removed the usage of Java-specific libraries.

1 files changed, 158 insertions, 158 deletions

diff --git a/sources/scala/tools/scalap/Arguments.scala b/sources/scala/tools/scalap/Arguments.scala
index 8f069f77ff..6649aa97e8 100644
--- a/sources/scala/tools/scalap/Arguments.scala
+++ b/sources/scala/tools/scalap/Arguments.scala
@@ -8,163 +8,163 @@
 
 package scala.tools.scalap;
 
-import scala.collection._;
+import scala.collection.mutable._;
 
 
 object Arguments {
 
-	case class Parser(optionPrefix: Char) {
-
-		val options = new mutable.JavaSetAdaptor[String](new java.util.HashSet());
-		val prefixes = new mutable.JavaSetAdaptor[String](new java.util.HashSet());
-		val optionalArgs = new mutable.JavaSetAdaptor[String](new java.util.HashSet());
-		val prefixedBindings = new mutable.JavaMapAdaptor[String, Char](new java.util.HashMap());
-		val optionalBindings = new mutable.JavaMapAdaptor[String, Char](new java.util.HashMap());
-
-		def error(message: String): Unit = Console.println(message);
-
-		def withOption(option: String): Parser = {
-			options += option;
-			this
-		}
-
-		def withOptionalArg(option: String): Parser = {
-			optionalArgs += option;
-			this
-		}
-
-		def withOptionalBinding(option: String, separator: Char): Parser = {
-			optionalBindings(option) = separator;
-			this
-		}
-
-		def withPrefixedArg(prefix: String): Parser = {
-			prefixes += prefix;
-			this
-		}
-
-		def withPrefixedBinding(prefix: String, separator: Char): Parser = {
-			prefixedBindings(prefix) = separator;
-			this
-		}
-
-		def parseBinding(str: String, separator: Char): Pair[String, String] = {
-			val eqls = str.indexOf(separator);
-			if (eqls < 0) {
-				error("missing '" + separator + "' in binding '" + str + "'");
-				Pair("", "")
-			} else
-				Pair(str.substring(0, eqls).trim(),
-					 str.substring(eqls + 1).trim());
-		}
-
-		def parse(args: Array[String]): Arguments = {
-			val res = new Arguments;
-			parse(args, res);
-			res
-		}
-
-		def parse(args: Array[String], res: Arguments): Unit = {
-			if (args != null) {
-				var i = 0;
-				while (i < args.length)
-					if ((args(i) == null) || (args(i).length() == 0))
-						i = i + 1;
-					else if (args(i).charAt(0) != optionPrefix) {
-						res.addOther(args(i));
-						i = i + 1;
-					} else if (options contains args(i)) {
-						res.addOption(args(i));
-						i = i + 1;
-					} else if (optionalArgs contains args(i)) {
-						if ((i + 1) == args.length) {
-							error("missing argument for '" + args(i) + "'");
-							i = i + 1;
-						} else {
-							res.addArgument(args(i), args(i + 1));
-							i = i + 2;
-						}
-					} else if (optionalBindings contains args(i)) {
-						if ((i + 1) == args.length) {
-							error("missing argument for '" + args(i) + "'");
-							i = i + 1;
-						} else {
-							res.addBinding(args(i),
-								parseBinding(args(i + 1), optionalBindings(args(i))));
-							i = i + 2;
-						}
-					} else {
-						var iter = prefixes.elements;
-						val j = i;
-						while ((i == j) && iter.hasNext) {
-							val prefix = iter.next;
-							if (args(i) startsWith prefix) {
-								res.addPrefixed(prefix, args(i).substring(prefix.length()).trim());
-								i = i + 1;
-							}
-						}
-						if (i == j) {
-							val iter = prefixedBindings.keys;
-							while ((i == j) && iter.hasNext) {
-								val prefix = iter.next;
-								if (args(i) startsWith prefix) {
-									val arg = args(i).substring(prefix.length()).trim();
-									i = i + 1;
-									res.addBinding(prefix,
-										parseBinding(arg, prefixedBindings(prefix)));
-								}
-							}
-							if (i == j) {
-								error("unknown option '" + args(i) + "'");
-								i = i + 1;
-							}
-						}
-					}
-			}
-		}
-	}
+    case class Parser(optionPrefix: Char) {
+
+        val options: Set[String] = new HashSet;
+        val prefixes: Set[String] = new HashSet;
+        val optionalArgs: Set[String] = new HashSet;
+        val prefixedBindings: Map[String, Char] = new HashMap;
+        val optionalBindings: Map[String, Char] = new HashMap;
+
+        def error(message: String): Unit = Console.println(message);
+
+        def withOption(option: String): Parser = {
+            options += option;
+            this
+        }
+
+        def withOptionalArg(option: String): Parser = {
+            optionalArgs += option;
+            this
+        }
+
+        def withOptionalBinding(option: String, separator: Char): Parser = {
+            optionalBindings(option) = separator;
+            this
+        }
+
+        def withPrefixedArg(prefix: String): Parser = {
+            prefixes += prefix;
+            this
+        }
+
+        def withPrefixedBinding(prefix: String, separator: Char): Parser = {
+            prefixedBindings(prefix) = separator;
+            this
+        }
+
+        def parseBinding(str: String, separator: Char): Pair[String, String] = {
+            val eqls = str.indexOf(separator);
+            if (eqls < 0) {
+                error("missing '" + separator + "' in binding '" + str + "'");
+                Pair("", "")
+            } else
+                Pair(str.substring(0, eqls).trim(),
+                     str.substring(eqls + 1).trim());
+        }
+
+        def parse(args: Array[String]): Arguments = {
+            val res = new Arguments;
+            parse(args, res);
+            res
+        }
+
+        def parse(args: Array[String], res: Arguments): Unit = {
+            if (args != null) {
+                var i = 0;
+                while (i < args.length)
+                    if ((args(i) == null) || (args(i).length() == 0))
+                        i = i + 1;
+                    else if (args(i).charAt(0) != optionPrefix) {
+                        res.addOther(args(i));
+                        i = i + 1;
+                    } else if (options contains args(i)) {
+                        res.addOption(args(i));
+                        i = i + 1;
+                    } else if (optionalArgs contains args(i)) {
+                        if ((i + 1) == args.length) {
+                            error("missing argument for '" + args(i) + "'");
+                            i = i + 1;
+                        } else {
+                            res.addArgument(args(i), args(i + 1));
+                            i = i + 2;
+                        }
+                    } else if (optionalBindings contains args(i)) {
+                        if ((i + 1) == args.length) {
+                            error("missing argument for '" + args(i) + "'");
+                            i = i + 1;
+                        } else {
+                            res.addBinding(args(i),
+                                parseBinding(args(i + 1), optionalBindings(args(i))));
+                            i = i + 2;
+                        }
+                    } else {
+                        var iter = prefixes.elements;
+                        val j = i;
+                        while ((i == j) && iter.hasNext) {
+                            val prefix = iter.next;
+                            if (args(i) startsWith prefix) {
+                                res.addPrefixed(prefix, args(i).substring(prefix.length()).trim());
+                                i = i + 1;
+                            }
+                        }
+                        if (i == j) {
+                            val iter = prefixedBindings.keys;
+                            while ((i == j) && iter.hasNext) {
+                                val prefix = iter.next;
+                                if (args(i) startsWith prefix) {
+                                    val arg = args(i).substring(prefix.length()).trim();
+                                    i = i + 1;
+                                    res.addBinding(prefix,
+                                        parseBinding(arg, prefixedBindings(prefix)));
+                                }
+                            }
+                            if (i == j) {
+                                error("unknown option '" + args(i) + "'");
+                                i = i + 1;
+                            }
+                        }
+                    }
+            }
+        }
+    }
 
     def parse(options: String*)(args: Array[String]): Arguments = {
         val parser = new Parser('-');
         val iter = options.elements;
         while (iter.hasNext)
-        	parser withOption iter.next;
+            parser withOption iter.next;
         parser.parse(args)
     }
 }
 
 class Arguments {
 
-	private val options: mutable.Set[String] = new mutable.JavaSetAdaptor(new java.util.HashSet());
-    private val arguments: mutable.Map[String, String] = new mutable.JavaMapAdaptor(new java.util.HashMap());
-	private val prefixes: mutable.Map[String, mutable.Set[String]] = new mutable.JavaMapAdaptor(new java.util.HashMap());
-    private val bindings: mutable.Map[String, mutable.Map[String, String]] = new mutable.JavaMapAdaptor(new java.util.HashMap());
-	private val others: mutable.Buffer[String] = new mutable.Buffer;
-
-	def addOption(option: String): Unit = options += option;
-
-	def addArgument(option: String, arg: String): Unit = arguments(option) = arg;
-
-	def addPrefixed(prefix: String, arg: String): Unit =
-		if (prefixes isDefinedAt prefix)
-			prefixes(prefix) += arg;
-		else {
-			prefixes(prefix) = new mutable.JavaSetAdaptor(new java.util.HashSet());
-			prefixes(prefix) += arg;
-		};
-
-	def addBinding(tag: String, key: String, value: String): Unit =
-		if (key.length() > 0) {
-			if (bindings isDefinedAt tag)
-				bindings(tag)(key) = value;
-			else {
-				bindings(tag) = new mutable.JavaMapAdaptor(new java.util.HashMap());
-				bindings(tag)(key) = value;
-			}
-		};
-
-   	def addBinding(tag: String, binding: Pair[String, String]): Unit =
-		addBinding(tag, binding._1, binding._2);
+    private val options: Set[String] = new HashSet;
+    private val arguments: Map[String, String] = new HashMap;
+    private val prefixes: Map[String, Set[String]] = new HashMap;
+    private val bindings: Map[String, Map[String, String]] = new HashMap;
+    private val others: Buffer[String] = new Buffer;
+
+    def addOption(option: String): Unit = options += option;
+
+    def addArgument(option: String, arg: String): Unit = arguments(option) = arg;
+
+    def addPrefixed(prefix: String, arg: String): Unit =
+        if (prefixes isDefinedAt prefix)
+            prefixes(prefix) += arg;
+        else {
+            prefixes(prefix) = new HashSet;
+            prefixes(prefix) += arg;
+        };
+
+    def addBinding(tag: String, key: String, value: String): Unit =
+        if (key.length() > 0) {
+            if (bindings isDefinedAt tag)
+                bindings(tag)(key) = value;
+            else {
+                bindings(tag) = new HashMap;
+                bindings(tag)(key) = value;
+            }
+        };
+
+    def addBinding(tag: String, binding: Pair[String, String]): Unit =
+        addBinding(tag, binding._1, binding._2);
 
     def addOther(arg: String): Unit = others += arg;
 
@@ -173,28 +173,28 @@ class Arguments {
     def getArgument(option: String): Option[String] = arguments get option;
 
     def getSuffixes(prefix: String): Set[String] =
-    	prefixes.get(prefix).match {
-    		case None => new mutable.JavaSetAdaptor(new java.util.HashSet());
-    		case Some(set) => set
-    	}
+        prefixes.get(prefix).match {
+            case None => new HashSet;
+            case Some(set) => set
+        }
 
     def containsSuffix(prefix: String, suffix: String): Boolean =
-    	prefixes.get(prefix).match {
-    		case None => false
-    		case Some(set) => set contains suffix
-    	};
+        prefixes.get(prefix).match {
+            case None => false
+            case Some(set) => set contains suffix
+        };
 
     def getBindings(tag: String): Map[String, String] =
-    	bindings.get(tag).match {
-    		case None => new mutable.JavaMapAdaptor(new java.util.HashMap());
-    		case Some(map) => map
-    	}
+        bindings.get(tag).match {
+            case None => new HashMap;
+            case Some(map) => map
+        }
 
     def getBinding(option: String, key: String): Option[String] =
-    	bindings.get(option).match {
-    		case None => None
-    		case Some(map) => map get key
-    	};
+        bindings.get(option).match {
+            case None => None
+            case Some(map) => map get key
+        };
 
     def getOthers: List[String] = others.toList;
 }