diff options
author | Christopher Vogt <oss.nsp@cvogt.org> | 2017-03-04 03:02:04 +0000 |
---|---|---|
committer | Christopher Vogt <oss.nsp@cvogt.org> | 2017-03-04 20:43:25 -0500 |
commit | c6fd3f43a9d2b2f38442602769e920803a7d43ba (patch) | |
tree | e1561087d27c603075b89877213818603c3787d3 /libraries/proguard | |
parent | 4bd0255f0a39d87652c032533ce45eb65e8f3b1e (diff) | |
download | cbt-c6fd3f43a9d2b2f38442602769e920803a7d43ba.tar.gz cbt-c6fd3f43a9d2b2f38442602769e920803a7d43ba.tar.bz2 cbt-c6fd3f43a9d2b2f38442602769e920803a7d43ba.zip |
separate type-safe proguard wrapper into self-contained library
also make logic to maintain auto-generated sections re-usable
Diffstat (limited to 'libraries/proguard')
-rw-r--r-- | libraries/proguard/Proguard.scala | 249 | ||||
-rw-r--r-- | libraries/proguard/Readme.md | 4 | ||||
-rw-r--r-- | libraries/proguard/build/build.scala | 151 | ||||
-rw-r--r-- | libraries/proguard/build/build/build.scala | 13 | ||||
-rw-r--r-- | libraries/proguard/spec/refcard.html | 259 |
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> |