From 4f7353b4470a974e7c96df3be869839a19102ba9 Mon Sep 17 00:00:00 2001 From: Matthias Zenger Date: Fri, 3 Oct 2003 13:52:47 +0000 Subject: *** empty log message *** --- sources/scala/Option.scala | 19 +-- sources/scala/tools/scalap/Arguments.scala | 192 +++++++++++++++++++++++++++++ sources/scala/tools/scalap/Main.scala | 79 ++++++++---- 3 files changed, 258 insertions(+), 32 deletions(-) create mode 100644 sources/scala/tools/scalap/Arguments.scala (limited to 'sources') 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 "); + Console.println("usage: scalap {