diff options
author | Matthias Zenger <mzenger@gmail.com> | 2003-10-03 13:52:47 +0000 |
---|---|---|
committer | Matthias Zenger <mzenger@gmail.com> | 2003-10-03 13:52:47 +0000 |
commit | 4f7353b4470a974e7c96df3be869839a19102ba9 (patch) | |
tree | 27ad56a43c3e4173d9ed1128da73b87279bb315f | |
parent | 82f735e5d5e9275a183d085c6b9d2ee01e701551 (diff) | |
download | scala-4f7353b4470a974e7c96df3be869839a19102ba9.tar.gz scala-4f7353b4470a974e7c96df3be869839a19102ba9.tar.bz2 scala-4f7353b4470a974e7c96df3be869839a19102ba9.zip |
*** empty log message ***
-rw-r--r-- | sources/scala/Option.scala | 19 | ||||
-rw-r--r-- | sources/scala/tools/scalap/Arguments.scala | 192 | ||||
-rw-r--r-- | sources/scala/tools/scalap/Main.scala | 79 |
3 files changed, 258 insertions, 32 deletions
diff --git a/sources/scala/Option.scala b/sources/scala/Option.scala index b037a3ef04..25030ab578 100644 --- a/sources/scala/Option.scala +++ b/sources/scala/Option.scala @@ -25,37 +25,42 @@ trait Option[+A] extends Iterable[A] { case _ => false } - def get: A = this match { + def get: A = match { case None => error("None.get") case Some(x) => x } - def map[B](f: A => B): Option[B] = this match { + def get[B >: A](default: B): B = match { + case None => default + case Some(x) => x + } + + def map[B](f: A => B): Option[B] = match { case None => None case Some(x) => Some(f(x)) } - def flatMap[B](f: A => Option[B]): Option[B] = this match { + def flatMap[B](f: A => Option[B]): Option[B] = match { case None => None case Some(x) => f(x) } - def filter(p: A => Boolean): Option[A] = this match { + def filter(p: A => Boolean): Option[A] = match { case None => None case Some(x) => if (p(x)) Some(x) else None } - def foreach(f: A => Unit): Unit = this match { + def foreach(f: A => Unit): Unit = match { case None => () case Some(x) => f(x) } - def elements: Iterator[A] = this match { + def elements: Iterator[A] = match { case None => Iterator.empty case Some(x) => Iterator.fromSeq(x) } - def toList: List[A] = this match { + def toList: List[A] = match { case None => Predef.List() case Some(x) => Predef.List(x) } diff --git a/sources/scala/tools/scalap/Arguments.scala b/sources/scala/tools/scalap/Arguments.scala new file mode 100644 index 0000000000..f8e0cb29a5 --- /dev/null +++ b/sources/scala/tools/scalap/Arguments.scala @@ -0,0 +1,192 @@ +package scalap; + +import scala.collection._; + + +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; + } + } + } + } + } + } + + def parse(options: String*)(args: Array[String]): Arguments = { + val parser = new Parser('-'); + val iter = options.elements; + while (iter.hasNext) + 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); + + def addOther(arg: String): Unit = others += arg; + + def contains(option: String): Boolean = options contains option; + + 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 + } + + def containsSuffix(prefix: String, suffix: String): Boolean = + 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 + } + + def getBinding(option: String, key: String): Option[String] = + bindings.get(option).match { + case None => None + case Some(map) => map get key + }; + + def getOthers: List[String] = others.toList; +} diff --git a/sources/scala/tools/scalap/Main.scala b/sources/scala/tools/scalap/Main.scala index 052df7f83d..4da32f5f67 100644 --- a/sources/scala/tools/scalap/Main.scala +++ b/sources/scala/tools/scalap/Main.scala @@ -14,38 +14,67 @@ import scala.collection._; object Main { + val VERSION = "1.0a"; + + var verbose = false; + def usage: Unit = { - Console.println("usage: scalap <name>"); + Console.println("usage: scalap {<option>} <name>"); + Console.println("where <option> is"); + Console.println(" -verbose print out additional information"); + Console.println(" -version print out the version number of scalap"); + Console.println(" -classpath <path> set the classpath"); + } + + def process(path: ClassPath)(classname: String): Unit = { + val file = path.openClass(Names.encode(classname)); + if (file.exists) { + if (verbose) + Console.println(Console.BOLD + "FILENAME" + Console.RESET + + " = " + file.getPath); + val reader = new ByteArrayReader(file.content); + val clazz = new Classfile(reader); + val attrib = clazz.attribs.find(a => a.toString() == "ScalaSignature"); + attrib match { + case Some(a) => + val info = new ScalaAttribute(a.reader); + //Console.println("read attribute"); + val symtab = new EntityTable(info); + //Console.println("read entities"); + //symtab.print; + val out = new OutputStreamWriter(System.out); + val writer = new ScalaWriter(out); + symtab.root.elements foreach ( + sym => { writer.printSymbol(sym); + writer.println*; }); + out.flush(); + case None => + Console.println("Java classes not supported yet."); + } + } else + Console.println("class/object not found."); } def main(args: Array[String]) = { if (args.length == 0) usage; else { - val path = new ClassPath; - val file = path.openClass(Names.encode(args(0))); - if (file.exists) { - val reader = new ByteArrayReader(file.content); - val clazz = new Classfile(reader); - val attrib = clazz.attribs.find(a => a.toString() == "ScalaSignature"); - attrib match { - case Some(a) => - val info = new ScalaAttribute(a.reader); - //Console.println("read attribute"); - val symtab = new EntityTable(info); - //Console.println("read entities"); - //symtab.print; - val out = new OutputStreamWriter(System.out); - val writer = new ScalaWriter(out); - symtab.root.elements foreach ( - sym => { writer.printSymbol(sym); - writer.println*; }); - out.flush(); - case None => - Console.println("Java classes not supported yet."); - } - } else - Console.println("class/object not found."); + val arguments = Arguments.Parser('-') + .withOption("-verbose") + .withOption("-version") + .withOptionalArg("-classpath") + .parse(args); + if (arguments contains "-version") + Console.println("scalap " + VERSION); + verbose = arguments contains "-verbose"; + val path = arguments.getArgument("-classpath") match { + case None => new ClassPath + case Some(path) => new ClassPath { override val classPath = path } + } + if (verbose) + Console.println(Console.BOLD + "CLASSPATH" + Console.RESET + + " = " + path); + arguments.getOthers.foreach(process(path)); } } } |