2 files changed, 45 insertions, 38 deletions

diff --git a/src/main/scala/logger/Logger.scala b/src/main/scala/logger/Logger.scala
index 1cf7d7ee..00c29b1a 100644
--- a/src/main/scala/logger/Logger.scala
+++ b/src/main/scala/logger/Logger.scala
@@ -363,9 +363,9 @@ object Logger {
     * @param inputAnnotations annotation sequence containing logger options
     */
   def setOptions(inputAnnotations: AnnotationSeq): Unit = {
-    val annotations = Seq( AddDefaults,
-                           Checks )
-      .foldLeft(inputAnnotations)((a, p) => p.runTransform(a))
+    val annotations =
+      Seq( AddDefaults, Checks )
+      .foldLeft(inputAnnotations)((a, p) => p.transform(a))
 
     val lopts = view[LoggerOptions](annotations)
     state.globalLevel = (state.globalLevel, lopts.globalLogLevel) match {
diff --git a/src/main/scala/logger/LoggerAnnotations.scala b/src/main/scala/logger/LoggerAnnotations.scala
index 2811cc6c..204fc4ab 100644
--- a/src/main/scala/logger/LoggerAnnotations.scala
+++ b/src/main/scala/logger/LoggerAnnotations.scala
@@ -4,7 +4,7 @@ package logger
 
 import firrtl.AnnotationSeq
 import firrtl.annotations.{Annotation, NoTargetAnnotation}
-import firrtl.options.{HasScoptOptions, StageUtils}
+import firrtl.options.{HasShellOptions, ShellOption, StageUtils}
 
 import scopt.OptionParser
 
@@ -18,17 +18,16 @@ sealed trait LoggerOption { this: Annotation => }
   */
 case class LogLevelAnnotation(globalLogLevel: LogLevel.Value = LogLevel.None) extends NoTargetAnnotation with LoggerOption
 
-object LogLevelAnnotation extends HasScoptOptions {
-  def addOptions(p: OptionParser[AnnotationSeq]): Unit = p.opt[String]("log-level")
-    .abbr("ll")
-    .valueName("<Error|Warn|Info|Debug|Trace>")
-    .action( (x, c) => LogLevelAnnotation(LogLevel(x)) +: c )
-    .validate{ x =>
-      lazy val msg = s"$x bad value must be one of error|warn|info|debug|trace"
-      if (Array("error", "warn", "info", "debug", "trace").contains(x.toLowerCase)) { p.success      }
-      else                                                                          { p.failure(msg) }}
-    .unbounded()
-    .text(s"Sets the verbosity level of logging, default is ${new LoggerOptions().globalLogLevel}")
+object LogLevelAnnotation extends HasShellOptions {
+
+  val options = Seq(
+    new ShellOption[String](
+      longOption = "log-level",
+      toAnnotationSeq = (a: String) => Seq(LogLevelAnnotation(LogLevel(a))),
+      helpText = s"Set global logging verbosity (default: ${new LoggerOptions().globalLogLevel}",
+      shortOption = Some("ll"),
+      helpValueName = Some("{error|warn|info|debug|trace}") ) )
+
 }
 
 /** Describes a mapping of a class to a specific log level
@@ -38,16 +37,19 @@ object LogLevelAnnotation extends HasScoptOptions {
   */
 case class ClassLogLevelAnnotation(className: String, level: LogLevel.Value) extends NoTargetAnnotation with LoggerOption
 
-object ClassLogLevelAnnotation extends HasScoptOptions {
-  def addOptions(p: OptionParser[AnnotationSeq]): Unit = p.opt[Seq[String]]("class-log-level")
-    .abbr("cll")
-    .valueName("<FullClassName:[Error|Warn|Info|Debug|Trace]>[,...]")
-    .action( (x, c) => (x.map { y =>
-                          val className :: levelName :: _ = y.split(":").toList
-                          val level = LogLevel(levelName)
-                          ClassLogLevelAnnotation(className, level) }) ++ c )
-    .unbounded()
-    .text(s"This defines per-class verbosity of logging")
+object ClassLogLevelAnnotation extends HasShellOptions {
+
+  val options = Seq(
+    new ShellOption[Seq[String]](
+      longOption = "class-log-level",
+      toAnnotationSeq = (a: Seq[String]) => a.map { aa =>
+        val className :: levelName :: _ = aa.split(":").toList
+        val level = LogLevel(levelName)
+        ClassLogLevelAnnotation(className, level) },
+      helpText = "Set per-class logging verbosity",
+      shortOption = Some("cll"),
+      helpValueName = Some("<FullClassName:{error|warn|info|debug|trace}>...") ) )
+
 }
 
 /** Enables logging to a file (as opposed to STDOUT)
@@ -56,22 +58,27 @@ object ClassLogLevelAnnotation extends HasScoptOptions {
   */
 case class LogFileAnnotation(file: Option[String]) extends NoTargetAnnotation with LoggerOption
 
-object LogFileAnnotation extends HasScoptOptions {
-  def addOptions(p: OptionParser[AnnotationSeq]): Unit = {
-    p.opt[String]("log-file")
-      .action( (x, c) => LogFileAnnotation(Some(x)) +: c )
-      .unbounded()
-      .text(s"log to the specified file")
-  }
+object LogFileAnnotation extends HasShellOptions {
+
+  val options = Seq(
+    new ShellOption[String](
+      longOption = "log-file",
+      toAnnotationSeq = (a: String) => Seq(LogFileAnnotation(Some(a))),
+      helpText = "Log to a file instead of STDOUT",
+      helpValueName = Some("<file>") ) )
+
 }
 
 /** Enables class names in log output
   *  - enabled with `-lcn/--log-class-names`
   */
-case object LogClassNamesAnnotation extends NoTargetAnnotation with LoggerOption with HasScoptOptions {
-  def addOptions(p: OptionParser[AnnotationSeq]): Unit = p.opt[Unit]("log-class-names")
-    .abbr("lcn")
-    .action( (x, c) => LogClassNamesAnnotation +: c )
-    .unbounded()
-    .text(s"shows class names and log level in logging output, useful for target --class-log-level")
+case object LogClassNamesAnnotation extends NoTargetAnnotation with LoggerOption with HasShellOptions {
+
+  val options = Seq(
+    new ShellOption[Unit](
+      longOption = "log-class-names",
+      toAnnotationSeq = (a: Unit) => Seq(LogClassNamesAnnotation),
+      helpText = "Show class names and log level in logging output",
+      shortOption = Some("lcn") ) )
+
 }