separate type-safe proguard wrapper into self-contained library

also make logic to maintain auto-generated sections re-usable

5 files changed, 676 insertions, 0 deletions

diff --git a/libraries/proguard/Proguard.scala b/libraries/proguard/Proguard.scala
new file mode 100644
index 0000000..c4a74bd
--- /dev/null
+++ b/libraries/proguard/Proguard.scala
@@ -0,0 +1,249 @@
+package cbt
+package proguard
+import java.io.File
+import java.nio.file.Files.deleteIfExists
+
+sealed class KeepOptionModifier(val string: String)
+object KeepOptionModifier {
+  /* AUTO GENERATED SECTION BEGIN: keepModifiers */
+  /** Also keep any classes in the descriptors of specified fields and methods. */
+  object includedescriptorclasses extends KeepOptionModifier("includedescriptorclasses")
+
+  /** Allow the specified entry points to be removed in the shrinking step. */
+  object allowshrinking extends KeepOptionModifier("allowshrinking")
+
+  /** Allow the specified entry points to be modified in the optimization step. */
+  object allowoptimization extends KeepOptionModifier("allowoptimization")
+
+  /** Allow the specified entry points to be renamed in the obfuscation step. */
+  object allowobfuscation extends KeepOptionModifier("allowobfuscation")
+  /* AUTO GENERATED SECTION END: keepModifiers */
+}
+
+object ProGuard {
+  val artifactId = "proguard-base"
+  val groupId    = "net.sf.proguard"
+  val version    = "5.3.2"
+  val mainClass  = "proguard.ProGuard"
+  val `rt.jar`   = Seq(new File(System.getProperty("java.home"), "lib/rt.jar"))
+}
+case class ProGuard[T](
+  main: Seq[String] => Int,
+  T: Seq[File] => T,
+  log: String => Unit = _ => ()
+) {
+
+  /**
+  Typed interface on top of the proguard command line tool.
+  Check the official ProGuard docs for usage.
+  Use `Some(None)` to call an option without arguments.
+  Use `true` to set a flag.
+
+  @see https://www.guardsquare.com/en/proguard/manual/refcard
+  @see https://www.guardsquare.com/en/proguard/manual/usage
+
+  /* AUTO GENERATED SECTION BEGIN: docs */
+  @param include Read configuration options from the given file.
+  @param basedirectory Specifies the base directory for subsequent relative file names.
+  @param injars Specifies the program jars (or wars, ears, zips, or directories).
+  @param outjars Specifies the names of the output jars (or wars, ears, zips, or directories).
+  @param libraryjars Specifies the library jars (or wars, ears, zips, or directories).
+  @param skipnonpubliclibraryclasses Ignore non-public library classes.
+  @param dontskipnonpubliclibraryclasses Don't ignore non-public library classes (the default).
+  @param dontskipnonpubliclibraryclassmembers Don't ignore package visible library class members.
+  @param keepdirectories Keep the specified directories in the output jars (or wars, ears, zips, or directories).
+  @param target Set the given version number in the processed classes.
+  @param forceprocessing Process the input, even if the output seems up to date.
+  @param keep Preserve the specified classes and class members.
+  @param keepclassmembers Preserve the specified class members, if their classes are preserved as well.
+  @param keepclasseswithmembers Preserve the specified classes and class members, if all of the specified class members are present.
+  @param keepnames Preserve the names of the specified classes and class members (if they aren't removed in the shrinking step).
+  @param keepclassmembernames Preserve the names of the specified class members (if they aren't removed in the shrinking step).
+  @param keepclasseswithmembernames Preserve the names of the specified classes and class members, if all of the specified class members are present (after the shrinking step).
+  @param printseeds List classes and class members matched by the various -keep options, to the standard output or to the given file.
+  @param dontshrink Don't shrink the input class files.
+  @param printusage List dead code of the input class files, to the standard output or to the given file.
+  @param whyareyoukeeping Print details on why the given classes and class members are being kept in the shrinking step.
+  @param dontoptimize Don't optimize the input class files.
+  @param optimizations The optimizations to be enabled and disabled.
+  @param optimizationpasses The number of optimization passes to be performed.
+  @param assumenosideeffects Assume that the specified methods don't have any side effects, while optimizing.
+  @param allowaccessmodification Allow the access modifiers of classes and class members to be modified, while optimizing.
+  @param mergeinterfacesaggressively Allow any interfaces to be merged, while optimizing.
+  @param dontobfuscate Don't obfuscate the input class files.
+  @param printmapping Print the mapping from old names to new names for classes and class members that have been renamed, to the standard output or to the given file.
+  @param applymapping Reuse the given mapping, for incremental obfuscation.
+  @param obfuscationdictionary Use the words in the given text file as obfuscated field names and method names.
+  @param classobfuscationdictionary Use the words in the given text file as obfuscated class names.
+  @param packageobfuscationdictionary Use the words in the given text file as obfuscated package names.
+  @param overloadaggressively Apply aggressive overloading while obfuscating.
+  @param useuniqueclassmembernames Ensure uniform obfuscated class member names for subsequent incremental obfuscation.
+  @param dontusemixedcaseclassnames Don't generate mixed-case class names while obfuscating.
+  @param keeppackagenames Keep the specified package names from being obfuscated.
+  @param flattenpackagehierarchy Repackage all packages that are renamed into the single given parent package.
+  @param repackageclasses Repackage all class files that are renamed into the single given package.
+  @param keepattributes Preserve the given optional attributes; typically Exceptions, InnerClasses, Signature, Deprecated, SourceFile, SourceDir, LineNumberTable, LocalVariableTable, LocalVariableTypeTable, Synthetic, EnclosingMethod, and *Annotation*.
+  @param keepparameternames Keep the parameter names and types of methods that are kept.
+  @param renamesourcefileattribute Put the given constant string in the SourceFile attributes.
+  @param adaptclassstrings Adapt string constants in the specified classes, based on the obfuscated names of any corresponding classes.
+  @param adaptresourcefilenames Rename the specified resource files, based on the obfuscated names of the corresponding class files.
+  @param adaptresourcefilecontents Update the contents of the specified resource files, based on the obfuscated names of the processed classes.
+  @param dontpreverify Don't preverify the processed class files.
+  @param microedition Target the processed class files at Java Micro Edition.
+  @param verbose Write out some more information during processing.
+  @param dontnote Don't print notes about potential mistakes or omissions in the configuration.
+  @param dontwarn Don't warn about unresolved references at all.
+  @param ignorewarnings Print warnings about unresolved references, but continue processing anyhow.
+  @param printconfiguration Write out the entire configuration in traditional ProGuard style, to the standard output or to the given file.
+  @param dump Write out the internal structure of the processed class files, to the standard output or to the given file.
+  /* AUTO GENERATED SECTION END: docs */
+    */
+  case class proguard(
+    /* AUTO GENERATED SECTION BEGIN: params */
+    include: Option[File] = None,
+    basedirectory: Option[File] = None,
+    injars: Option[Seq[File]] = None,
+    outjars: Option[Seq[File]] = None,
+    libraryjars: Option[Seq[File]] = None,
+    skipnonpubliclibraryclasses: Boolean = false,
+    dontskipnonpubliclibraryclasses: Boolean = false,
+    dontskipnonpubliclibraryclassmembers: Boolean = false,
+    keepdirectories: Option[Option[String]] = None,
+    target: Option[String] = None,
+    forceprocessing: Boolean = false,
+    keep: Option[(Seq[KeepOptionModifier], String)] = None,
+    keepclassmembers: Option[(Seq[KeepOptionModifier], String)] = None,
+    keepclasseswithmembers: Option[(Seq[KeepOptionModifier], String)] = None,
+    keepnames: Option[String] = None,
+    keepclassmembernames: Option[String] = None,
+    keepclasseswithmembernames: Option[String] = None,
+    printseeds: Option[Option[File]] = None,
+    dontshrink: Boolean = false,
+    printusage: Option[Option[File]] = None,
+    whyareyoukeeping: Option[String] = None,
+    dontoptimize: Boolean = false,
+    optimizations: Option[String] = None,
+    optimizationpasses: Option[Int] = None,
+    assumenosideeffects: Option[String] = None,
+    allowaccessmodification: Boolean = false,
+    mergeinterfacesaggressively: Boolean = false,
+    dontobfuscate: Boolean = false,
+    printmapping: Option[Option[File]] = None,
+    applymapping: Option[File] = None,
+    obfuscationdictionary: Option[File] = None,
+    classobfuscationdictionary: Option[File] = None,
+    packageobfuscationdictionary: Option[File] = None,
+    overloadaggressively: Boolean = false,
+    useuniqueclassmembernames: Boolean = false,
+    dontusemixedcaseclassnames: Boolean = false,
+    keeppackagenames: Option[Option[String]] = None,
+    flattenpackagehierarchy: Option[Option[String]] = None,
+    repackageclasses: Option[Option[String]] = None,
+    keepattributes: Option[Option[String]] = None,
+    keepparameternames: Boolean = false,
+    renamesourcefileattribute: Option[Option[String]] = None,
+    adaptclassstrings: Option[Option[String]] = None,
+    adaptresourcefilenames: Option[Option[String]] = None,
+    adaptresourcefilecontents: Option[Option[String]] = None,
+    dontpreverify: Boolean = false,
+    microedition: Boolean = false,
+    verbose: Boolean = false,
+    dontnote: Option[Option[String]] = None,
+    dontwarn: Option[Option[String]] = None,
+    ignorewarnings: Boolean = false,
+    printconfiguration: Option[Option[File]] = None,
+    dump: Option[Option[File]] = None
+    /* AUTO GENERATED SECTION END: params */
+  ) extends (() => T) {
+    // type class rendering scala values into string arguments
+    private class argsFor[T](val apply: T => Option[Seq[String]])
+    private object argsFor {
+      def apply[T: argsFor](value: T) = implicitly[argsFor[T]].apply(value)
+      implicit object SeqFile extends argsFor[Seq[File]](v => Some(Seq(v.map(_.getPath).mkString(":"))))
+      implicit object File    extends argsFor[File](v => Some(Seq(v.getPath)))
+      implicit object String  extends argsFor[String](v => Some(Seq(v)))
+      implicit object Int     extends argsFor[Int](i => Some(Seq(i.toString)))
+      implicit object Boolean
+          extends argsFor[Boolean]({
+            case false => None
+            case true  => Some(Nil)
+          })
+      implicit def Option2[T: argsFor]: argsFor[Option[T]] = new argsFor(
+        _.map(implicitly[argsFor[T]].apply(_).toSeq.flatten)
+      )
+      implicit def Option3[T: argsFor]: argsFor[Option[Option[String]]] =
+        new argsFor(_.map(_.toSeq))
+      implicit def SpecWithModifiers: argsFor[(Seq[KeepOptionModifier], String)] =
+        new argsFor({
+          case (modifiers, spec) =>
+            Some(Seq(modifiers.map(_.string).map("," ++ _).mkString).filterNot(_ == "") :+ spec)
+        })
+    }
+
+    // capture string argument values and names
+    val args = (
+      /* AUTO GENERATED SECTION BEGIN: args */
+      argsFor(include).map("-include" +: _)
+        ++ argsFor(basedirectory).map("-basedirectory" +: _)
+        ++ argsFor(injars).map("-injars" +: _)
+        ++ argsFor(outjars).map("-outjars" +: _)
+        ++ argsFor(libraryjars).map("-libraryjars" +: _)
+        ++ argsFor(skipnonpubliclibraryclasses).map("-skipnonpubliclibraryclasses" +: _)
+        ++ argsFor(dontskipnonpubliclibraryclasses).map("-dontskipnonpubliclibraryclasses" +: _)
+        ++ argsFor(dontskipnonpubliclibraryclassmembers).map("-dontskipnonpubliclibraryclassmembers" +: _)
+        ++ argsFor(keepdirectories).map("-keepdirectories" +: _)
+        ++ argsFor(target).map("-target" +: _)
+        ++ argsFor(forceprocessing).map("-forceprocessing" +: _)
+        ++ argsFor(keep).map("-keep" +: _)
+        ++ argsFor(keepclassmembers).map("-keepclassmembers" +: _)
+        ++ argsFor(keepclasseswithmembers).map("-keepclasseswithmembers" +: _)
+        ++ argsFor(keepnames).map("-keepnames" +: _)
+        ++ argsFor(keepclassmembernames).map("-keepclassmembernames" +: _)
+        ++ argsFor(keepclasseswithmembernames).map("-keepclasseswithmembernames" +: _)
+        ++ argsFor(printseeds).map("-printseeds" +: _)
+        ++ argsFor(dontshrink).map("-dontshrink" +: _)
+        ++ argsFor(printusage).map("-printusage" +: _)
+        ++ argsFor(whyareyoukeeping).map("-whyareyoukeeping" +: _)
+        ++ argsFor(dontoptimize).map("-dontoptimize" +: _)
+        ++ argsFor(optimizations).map("-optimizations" +: _)
+        ++ argsFor(optimizationpasses).map("-optimizationpasses" +: _)
+        ++ argsFor(assumenosideeffects).map("-assumenosideeffects" +: _)
+        ++ argsFor(allowaccessmodification).map("-allowaccessmodification" +: _)
+        ++ argsFor(mergeinterfacesaggressively).map("-mergeinterfacesaggressively" +: _)
+        ++ argsFor(dontobfuscate).map("-dontobfuscate" +: _)
+        ++ argsFor(printmapping).map("-printmapping" +: _)
+        ++ argsFor(applymapping).map("-applymapping" +: _)
+        ++ argsFor(obfuscationdictionary).map("-obfuscationdictionary" +: _)
+        ++ argsFor(classobfuscationdictionary).map("-classobfuscationdictionary" +: _)
+        ++ argsFor(packageobfuscationdictionary).map("-packageobfuscationdictionary" +: _)
+        ++ argsFor(overloadaggressively).map("-overloadaggressively" +: _)
+        ++ argsFor(useuniqueclassmembernames).map("-useuniqueclassmembernames" +: _)
+        ++ argsFor(dontusemixedcaseclassnames).map("-dontusemixedcaseclassnames" +: _)
+        ++ argsFor(keeppackagenames).map("-keeppackagenames" +: _)
+        ++ argsFor(flattenpackagehierarchy).map("-flattenpackagehierarchy" +: _)
+        ++ argsFor(repackageclasses).map("-repackageclasses" +: _)
+        ++ argsFor(keepattributes).map("-keepattributes" +: _)
+        ++ argsFor(keepparameternames).map("-keepparameternames" +: _)
+        ++ argsFor(renamesourcefileattribute).map("-renamesourcefileattribute" +: _)
+        ++ argsFor(adaptclassstrings).map("-adaptclassstrings" +: _)
+        ++ argsFor(adaptresourcefilenames).map("-adaptresourcefilenames" +: _)
+        ++ argsFor(adaptresourcefilecontents).map("-adaptresourcefilecontents" +: _)
+        ++ argsFor(dontpreverify).map("-dontpreverify" +: _)
+        ++ argsFor(microedition).map("-microedition" +: _)
+        ++ argsFor(verbose).map("-verbose" +: _)
+        ++ argsFor(dontnote).map("-dontnote" +: _)
+        ++ argsFor(dontwarn).map("-dontwarn" +: _)
+        ++ argsFor(ignorewarnings).map("-ignorewarnings" +: _)
+        ++ argsFor(printconfiguration).map("-printconfiguration" +: _)
+        ++ argsFor(dump).map("-dump" +: _)
+      /* AUTO GENERATED SECTION END: args */
+    ).flatten.toSeq
+
+    def apply: T = {
+      outjars.foreach(_.map(_.toPath).map(deleteIfExists))
+      val c = main(args)
+      if (c != 0) throw new Exception
+      T(outjars.toSeq.flatten)
+    }
+  }
+}
diff --git a/libraries/proguard/Readme.md b/libraries/proguard/Readme.md
new file mode 100644
index 0000000..36d61d4
--- /dev/null
+++ b/libraries/proguard/Readme.md
@@ -0,0 +1,4 @@
+Type-safe Scala api on top of proguards .main method.
+
+TODO:
+- capture stdout and make it available to the caller via stream
diff --git a/libraries/proguard/build/build.scala b/libraries/proguard/build/build.scala
new file mode 100644
index 0000000..399714e
--- /dev/null
+++ b/libraries/proguard/build/build.scala
@@ -0,0 +1,151 @@
+package cbt_build.proguard
+import cbt._
+import java.nio.file.Files._
+import java.net._
+import java.io._
+import scala.xml._
+
+class Build(val context: Context) extends Scalafmt with GeneratedSections{
+  def refcard = projectDirectory / "spec/refcard.html"
+
+  /** downloads html proguard parameter specification */
+  def updateSpec = {
+    System.err.println(lib.blue("downloading ")+refcard)
+    lib.download(
+      new URL("https://www.guardsquare.com/en/proguard/manual/refcard"),
+      refcard,
+      None,
+      replace = true
+    )
+    System.err.println("simplifying html")
+    val tables = (
+      loadSloppyHtml( refcard.readAsString ) \ "body" \\ "table"
+    )
+    val s = (
+      "<html><body>\n" ++ tables.map( table =>
+        " <table>\n" ++ (table \\ "tr").map( tr =>
+          "  <tr>\n" ++ (tr \\ "td").map( td =>
+            "   <td>" ++ td.text ++ "</td>\n"
+          ).mkString ++ "  </tr>\n"
+        ).mkString ++ " </table>\n"
+      ).mkString ++ "</body></html>\n"
+    )
+    System.err.println("writing file")
+    write( refcard.toPath, s.getBytes)
+  }
+
+  private def loadSloppyHtml(html: String): scala.xml.Elem = {
+    object XmlNotDownloadingDTD extends scala.xml.factory.XMLLoader[scala.xml.Elem] {
+      override def parser: javax.xml.parsers.SAXParser = {
+        val f = javax.xml.parsers.SAXParserFactory.newInstance()
+        f.setNamespaceAware(false)
+        f.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+        f.newSAXParser()
+      }
+    }
+
+    val p = new org.ccil.cowan.tagsoup.Parser
+    val w = new StringWriter
+    p.setContentHandler(new org.ccil.cowan.tagsoup.XMLWriter(w))
+    p.parse(
+      new org.xml.sax.InputSource(
+        new ByteArrayInputStream( "<!DOCTYPE[^<]*>".r.replaceFirstIn( html, "" ).getBytes )
+      )
+    )
+    XmlNotDownloadingDTD.loadString( w.toString )
+  }
+
+  override def scalafmtConfig = {
+    import org.scalafmt.config._
+    ScalafmtConfig.defaultWithAlign.copy(
+      maxColumn = 120,
+      continuationIndent = super.scalafmtConfig.continuationIndent.copy(
+        defnSite = 2
+      ),
+      align = super.scalafmtConfig.align.copy(
+        tokens = AlignToken.default,
+        arrowEnumeratorGenerator = true,
+        mixedOwners = true
+      ),
+      binPack = super.scalafmtConfig.binPack.copy(
+        parentConstructors = true
+      ),
+      spaces = super.scalafmtConfig.spaces.copy(
+        inImportCurlyBraces = true
+      ),
+      lineEndings = LineEndings.unix,
+      newlines = super.scalafmtConfig.newlines.copy(
+        penalizeSingleSelectMultiArgList = false
+      ),
+      runner = super.scalafmtConfig.runner.copy(
+        optimizer = super.scalafmtConfig.runner.optimizer.copy(
+          forceConfigStyleOnOffset = -1
+        )
+      )
+    )
+  }
+
+  /** generates Scala code from parameter specification html */
+  def replacements = {
+    val tables = XML.loadFile(refcard) \\ "table"
+    def cellsToSeq( node: Node ) = (node \\ "tr").map(
+      tr => (tr \\ "td").map( td => td.text ) match {
+        case Seq( k, v ) => k -> v
+      }
+    )
+    val options = cellsToSeq( tables(0) ).collect{
+      case (k, v) if k.startsWith("-") => k.drop(1).split(" ").toList -> v
+    }.map{
+      case (k,description) =>
+        val name = k(0)
+        val tpe = k.drop(1).mkString(" ") match {
+          case "" => "Boolean"
+          case "n" => "Int"
+          case "class_specification" | "version" | "optimization_filter" => "String"
+          case "filename" | "directoryname" => "File"
+          case "class_path" if name === "outjars" => "Seq[File]"
+          case "class_path" => "Seq[File]"
+          case "[filename]" => "Option[File]"
+          case "[directory_filter]" | "[package_filter]" | "[package_name]"
+               | "[attribute_filter]" | "[string]" | "[class_filter]" | "[file_filter]"
+               => "Option[String]"
+          case "[,modifier,...] class_specification" => "(Seq[KeepOptionModifier], String)"
+        }
+       (name, tpe, description.split("\n").mkString(" "))
+    }//.sortBy(_._1)
+
+    val docs = options.map{
+      case (name, tpe, description) => s"  @param $name $description"
+    }.mkString("\n")
+
+    val params = options.map{
+      case v@(_, "Boolean", _) => v -> Some("false")
+      case (n, t, d) => (n, s"Option[$t]", d) -> Some("None")
+    }.map{
+      case ((name, tpe, description), default) => s"    $name: $tpe" ++ default.map(" = "++_).getOrElse("")
+    }.mkString(",\n")
+
+    val keepModifiers = cellsToSeq( tables(2) ).map{
+      case (k, v) => s"""  /** $v */\n  object $k extends KeepOptionModifier("$k")"""
+    }.mkString("\n")
+
+    val args = options.map{
+      case (name, _, description) => s"""argsFor($name).map("-$name" +: _)"""
+    }.mkString("\n++ ")
+
+    Seq(
+      "keepModifiers" -> keepModifiers,
+      "docs" -> docs,
+      "args" -> args,
+      "params" -> params
+    )
+  }
+  override def generate{
+    super.generate
+    compile
+  }
+  override def compile = {
+    scalafmt
+    super.compile
+  }
+}
diff --git a/libraries/proguard/build/build/build.scala b/libraries/proguard/build/build/build.scala
new file mode 100644
index 0000000..7928cfa
--- /dev/null
+++ b/libraries/proguard/build/build/build.scala
@@ -0,0 +1,13 @@
+package cbt_build.proguard.build
+import cbt._
+class Build(val context: Context) extends BuildBuild{
+  override def dependencies = (
+    super.dependencies ++ // don't forget super.dependencies here for scala-library, etc.
+    Resolver( mavenCentral, sonatypeReleases ).bind(
+      ScalaDependency("org.scala-lang.modules","scala-xml","1.0.5"),
+       "org.ccil.cowan.tagsoup" % "tagsoup" % "1.2.1"
+    ) ++ Seq(
+      plugins.scalafmt
+    )
+  )
+}
diff --git a/libraries/proguard/spec/refcard.html b/libraries/proguard/spec/refcard.html
new file mode 100644
index 0000000..9cb0c72
--- /dev/null
+++ b/libraries/proguard/spec/refcard.html
@@ -0,0 +1,259 @@
+<html><body>
+ <table>
+  <tr>
+   <td>@filename</td>
+   <td>Short for '-includefilename'. </td>
+  </tr>
+  <tr>
+   <td>-include filename</td>
+   <td>Read configuration options from the given file.</td>
+  </tr>
+  <tr>
+   <td>-basedirectory directoryname</td>
+   <td>Specifies the base directory for subsequent relative file names.</td>
+  </tr>
+  <tr>
+   <td>-injars class_path</td>
+   <td>Specifies the program jars (or wars, ears, zips, or directories).</td>
+  </tr>
+  <tr>
+   <td>-outjars class_path</td>
+   <td>Specifies the names of the output jars (or wars, ears, zips, or directories).</td>
+  </tr>
+  <tr>
+   <td>-libraryjars class_path</td>
+   <td>Specifies the library jars (or wars, ears, zips, or directories).</td>
+  </tr>
+  <tr>
+   <td>-skipnonpubliclibraryclasses</td>
+   <td>Ignore non-public library classes.</td>
+  </tr>
+  <tr>
+   <td>-dontskipnonpubliclibraryclasses</td>
+   <td>Don't ignore non-public library classes (the default).</td>
+  </tr>
+  <tr>
+   <td>-dontskipnonpubliclibraryclassmembers</td>
+   <td>Don't ignore package visible library class members.</td>
+  </tr>
+  <tr>
+   <td>-keepdirectories [directory_filter]</td>
+   <td>Keep the specified directories in the output jars (or wars, ears, zips, or directories).</td>
+  </tr>
+  <tr>
+   <td>-target version</td>
+   <td>Set the given version number in the processed classes.</td>
+  </tr>
+  <tr>
+   <td>-forceprocessing</td>
+   <td>Process the input, even if the output seems up to date.</td>
+  </tr>
+  <tr>
+   <td>-keep [,modifier,...] class_specification</td>
+   <td>Preserve the specified classes and class members.</td>
+  </tr>
+  <tr>
+   <td>-keepclassmembers [,modifier,...] class_specification</td>
+   <td>Preserve the specified class members, if their classes are preserved as well.</td>
+  </tr>
+  <tr>
+   <td>-keepclasseswithmembers [,modifier,...] class_specification</td>
+   <td>Preserve the specified classes and class members, if all of the specified class members are present.</td>
+  </tr>
+  <tr>
+   <td>-keepnames class_specification</td>
+   <td>Preserve the names of the specified classes and class members (if they aren't removed in the shrinking step).</td>
+  </tr>
+  <tr>
+   <td>-keepclassmembernames class_specification</td>
+   <td>Preserve the names of the specified class members (if they aren't removed in the shrinking step).</td>
+  </tr>
+  <tr>
+   <td>-keepclasseswithmembernames class_specification</td>
+   <td>Preserve the names of the specified classes and class members, if all of the specified class members are present (after the shrinking step).</td>
+  </tr>
+  <tr>
+   <td>-printseeds [filename]</td>
+   <td>List classes and class members matched by the various -keep options, to the standard output or to the given file.</td>
+  </tr>
+  <tr>
+   <td>-dontshrink</td>
+   <td>Don't shrink the input class files.</td>
+  </tr>
+  <tr>
+   <td>-printusage [filename]</td>
+   <td>List dead code of the input class files, to the standard output or to the given file.</td>
+  </tr>
+  <tr>
+   <td>-whyareyoukeeping class_specification</td>
+   <td>Print details on why the given classes and class members are being kept in the shrinking step.</td>
+  </tr>
+  <tr>
+   <td>-dontoptimize</td>
+   <td>Don't optimize the input class files.</td>
+  </tr>
+  <tr>
+   <td>-optimizations optimization_filter</td>
+   <td>The optimizations to be enabled and disabled.</td>
+  </tr>
+  <tr>
+   <td>-optimizationpasses n</td>
+   <td>The number of optimization passes to be performed.</td>
+  </tr>
+  <tr>
+   <td>-assumenosideeffects class_specification</td>
+   <td>Assume that the specified methods don't have any side effects, while optimizing.</td>
+  </tr>
+  <tr>
+   <td>-allowaccessmodification</td>
+   <td>Allow the access modifiers of classes and class members to be modified, while optimizing.</td>
+  </tr>
+  <tr>
+   <td>-mergeinterfacesaggressively</td>
+   <td>Allow any interfaces to be merged, while optimizing.</td>
+  </tr>
+  <tr>
+   <td>-dontobfuscate</td>
+   <td>Don't obfuscate the input class files.</td>
+  </tr>
+  <tr>
+   <td>-printmapping [filename]</td>
+   <td>Print the mapping from old names to new names for classes and class members that have been renamed, to the standard output or to the given file.</td>
+  </tr>
+  <tr>
+   <td>-applymapping filename</td>
+   <td>Reuse the given mapping, for incremental obfuscation.</td>
+  </tr>
+  <tr>
+   <td>-obfuscationdictionary filename</td>
+   <td>Use the words in the given text file as obfuscated field names and method names.</td>
+  </tr>
+  <tr>
+   <td>-classobfuscationdictionary filename</td>
+   <td>Use the words in the given text file as obfuscated class names.</td>
+  </tr>
+  <tr>
+   <td>-packageobfuscationdictionary filename</td>
+   <td>Use the words in the given text file as obfuscated package names.</td>
+  </tr>
+  <tr>
+   <td>-overloadaggressively</td>
+   <td>Apply aggressive overloading while obfuscating.</td>
+  </tr>
+  <tr>
+   <td>-useuniqueclassmembernames</td>
+   <td>Ensure uniform obfuscated class member names for subsequent incremental obfuscation.</td>
+  </tr>
+  <tr>
+   <td>-dontusemixedcaseclassnames</td>
+   <td>Don't generate mixed-case class names while obfuscating.</td>
+  </tr>
+  <tr>
+   <td>-keeppackagenames [package_filter]</td>
+   <td>Keep the specified package names from being obfuscated.</td>
+  </tr>
+  <tr>
+   <td>-flattenpackagehierarchy [package_name]</td>
+   <td>Repackage all packages that are renamed into the single given parent package.</td>
+  </tr>
+  <tr>
+   <td>-repackageclasses [package_name]</td>
+   <td>Repackage all class files that are renamed into the single given package.</td>
+  </tr>
+  <tr>
+   <td>-keepattributes [attribute_filter]</td>
+   <td>Preserve the given optional attributes; typically Exceptions, InnerClasses, Signature, Deprecated, SourceFile, SourceDir, LineNumberTable, LocalVariableTable, LocalVariableTypeTable, Synthetic, EnclosingMethod, and *Annotation*.</td>
+  </tr>
+  <tr>
+   <td>-keepparameternames</td>
+   <td>Keep the parameter names and types of methods that are kept.</td>
+  </tr>
+  <tr>
+   <td>-renamesourcefileattribute [string]</td>
+   <td>Put the given constant string in the SourceFile attributes.</td>
+  </tr>
+  <tr>
+   <td>-adaptclassstrings [class_filter]</td>
+   <td>Adapt string constants in the specified classes, based on the obfuscated names of any corresponding classes.</td>
+  </tr>
+  <tr>
+   <td>-adaptresourcefilenames [file_filter]</td>
+   <td>Rename the specified resource files, based on the obfuscated names of the corresponding class files.</td>
+  </tr>
+  <tr>
+   <td>-adaptresourcefilecontents [file_filter]</td>
+   <td>Update the contents of the specified resource files, based on the obfuscated names of the processed classes.</td>
+  </tr>
+  <tr>
+   <td>-dontpreverify</td>
+   <td>Don't preverify the processed class files.</td>
+  </tr>
+  <tr>
+   <td>-microedition</td>
+   <td>Target the processed class files at Java Micro Edition.</td>
+  </tr>
+  <tr>
+   <td>-verbose</td>
+   <td>Write out some more information during processing.</td>
+  </tr>
+  <tr>
+   <td>-dontnote [class_filter]</td>
+   <td>Don't print notes about potential mistakes or omissions in the configuration.</td>
+  </tr>
+  <tr>
+   <td>-dontwarn [class_filter]</td>
+   <td>Don't warn about unresolved references at all.</td>
+  </tr>
+  <tr>
+   <td>-ignorewarnings</td>
+   <td>Print warnings about unresolved references, but continue processing anyhow.</td>
+  </tr>
+  <tr>
+   <td>-printconfiguration [filename]</td>
+   <td>Write out the entire configuration in traditional ProGuard style, to the standard output or to the given file.</td>
+  </tr>
+  <tr>
+   <td>-dump [filename]</td>
+   <td>Write out the internal structure of the processed class files, to the standard output or to the given file.</td>
+  </tr>
+ </table>
+ <table>
+  <tr>
+   <td>From being removed or renamed</td>
+   <td>From being renamed</td>
+  </tr>
+  <tr>
+   <td>Classes and class members</td>
+   <td>-keep</td>
+   <td>-keepnames</td>
+  </tr>
+  <tr>
+   <td>Class members only</td>
+   <td>-keepclassmembers</td>
+   <td>-keepclassmembernames</td>
+  </tr>
+  <tr>
+   <td>Classes and class members, if class members present</td>
+   <td>-keepclasseswithmembers</td>
+   <td>-keepclasseswithmembernames</td>
+  </tr>
+ </table>
+ <table>
+  <tr>
+   <td>includedescriptorclasses</td>
+   <td>Also keep any classes in the descriptors of specified fields and methods.</td>
+  </tr>
+  <tr>
+   <td>allowshrinking</td>
+   <td>Allow the specified entry points to be removed in the shrinking step.</td>
+  </tr>
+  <tr>
+   <td>allowoptimization</td>
+   <td>Allow the specified entry points to be modified in the optimization step.</td>
+  </tr>
+  <tr>
+   <td>allowobfuscation</td>
+   <td>Allow the specified entry points to be renamed in the obfuscation step.</td>
+  </tr>
+ </table>
+</body></html>