v0.7.1

Changes max diff size to prevent valid resources filtration

.codecov.yml

@@ -0,0 +1,14 @@
+coverage:
+  precision: 2
+  round: down
+  range: "50...100"
+
+  status:
+    project:
+      default: on
+    patch:
+      default: on
+    changes:
+      default: off
+
+comment: false

.gitignore

@@ -10,13 +10,17 @@ out/
 *.ipr
 *.iws
 
+**/.DS_Store
+
 bin/
 target/
 build/
+classes/
 idea/
 .gradle/
 gradle.properties
 
+jadx-output/
 *-tmp/
 
 *.dex

.gitlab-ci.yml

@@ -0,0 +1,23 @@
+image: java:8
+
+variables:
+    GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+    TERM: "dumb"
+
+before_script:
+    - chmod +x gradlew
+
+stages:
+  - build
+
+build:
+  stage: build
+  script:
+    - sed -i " 1 s/.*/&-b$(git rev-list --count HEAD)-$(git rev-parse --short HEAD)/" version
+    - cat version
+    - ./gradlew -g /cache/.gradle clean build jacocoTestReport
+    - ./gradlew -g /cache/.gradle clean sonarqube -Dsonar.host.url=$SONAR_HOST -Dsonar.organization=$SONAR_ORG -Dsonar.login=$SONAR_TOKEN
+    - ./gradlew -g /cache/.gradle clean dist
+  artifacts:
+    paths:
+    - build/jadx*.zip

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "jadx-test-app/test-app"]
+	path = jadx-test-app/test-app
+	url = git://github.com/skylot/jadx-test-app.git

.travis.yml

@@ -1,24 +1,39 @@
 language: java
 jdk:
     - oraclejdk8
-    - oraclejdk7
-    - openjdk6
+
+env:
+    - TERM=dumb
 
 before_install:
     - chmod +x gradlew
 
 script:
-    - TERM=dumb ./gradlew clean build dist
+    - sed -i " 1 s/.*/&-b$TRAVIS_BUILD_NUMBER-$(git rev-parse --short HEAD)/" version
+    - cat version
+    - sed -i "s/BUILD_VERSION/$(head -c -1 version)/g" bintray.json
+    - ./gradlew clean build
 
 after_success:
-    - TERM=dumb ./gradlew jacocoTestReport coveralls
+    - ./gradlew clean build jacocoTestReport
+    - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports"
+    - ./gradlew clean sonarqube -Dsonar.host.url=$SONAR_HOST -Dsonar.organization=$SONAR_ORG -Dsonar.login=$SONAR_TOKEN
+    - ./gradlew clean dist
+
+deploy:
+    provider: bintray
+    edge:
+      branch: v1.8.47
+    file: bintray.json
+    user: skylot
+    key: $BINTRAY_KEY
+    skip_cleanup: true
+    on:
+      branch: master
+      tags: false
 
 sudo: false
 
-cache:
-    directories:
-        - $HOME/.gradle
-
 notifications:
     email:
         - skylot@gmail.com

CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Contribution
+
+To support this project you can:
+  - Post thoughts about new features/optimizations that important to you
+  - Submit bug using one of following patterns:
+    * Java code examples which decompiles incorrectly
+    * Error log and link to _public available_ apk file or app page on Google play

NOTICE

@@ -144,7 +144,8 @@ THE POSSIBILITY OF SUCH DAMAGE.
 Jadx-gui components
 ===================
 
-RSyntaxTextArea library licensed under modified BSD license:
+RSyntaxTextArea library (https://github.com/bobbylight/RSyntaxTextArea)
+licensed under modified BSD license:
 
 *******************************************************************************
 Copyright (c) 2012, Robert Futrell
@@ -174,8 +175,39 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************
 
 
-Icons copied from several places:
- - Eclipse Project (JDT UI) - licensed under EPL v1.0 (http://www.eclipse.org/legal/epl-v10.html)
- - famfamfam silk icon set (http://www.famfamfam.com/lab/icons/silk/) - licensed under Creative Commons Attribution 2.5 License (http://creativecommons.org/licenses/by/2.5/)
+Concurrent Trees (https://code.google.com/p/concurrent-trees/)
+licenced under Apache License 2.0:
+
+*******************************************************************************
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*******************************************************************************
+
+
+Image Viewer (https://github.com/kazocsaba/imageviewer)
+
+*******************************************************************************
+Copyright (c) 2008-2012 Kazó Csaba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*******************************************************************************
 
 JFontChooser Component - http://sourceforge.jp/projects/jfontchooser/
+
+Icons copied from several places:
+ - Eclipse Project (JDT UI) - licensed under EPL v1.0 (http://www.eclipse.org/legal/epl-v10.html)
+ - famfamfam silk icon set (http://www.famfamfam.com/lab/icons/silk/) - licensed
+     under Creative Commons Attribution 2.5 License (http://creativecommons.org/licenses/by/2.5/)

README.md

@@ -1,24 +1,33 @@
 ## JADX
 
 [![Build Status](https://travis-ci.org/skylot/jadx.png?branch=master)](https://travis-ci.org/skylot/jadx)
-[![Build Status](https://drone.io/github.com/skylot/jadx/status.png)](https://drone.io/github.com/skylot/jadx/latest)
-[![Coverage Status](https://coveralls.io/repos/skylot/jadx/badge.png)](https://coveralls.io/r/skylot/jadx)
-[![Coverity Scan Build Status](https://scan.coverity.com/projects/2166/badge.svg)](https://scan.coverity.com/projects/2166)
+[![Code Coverage](https://codecov.io/gh/skylot/jadx/branch/master/graph/badge.svg)](https://codecov.io/gh/skylot/jadx)
+[![SonarQube Bugs](https://sonarcloud.io/api/badges/measure?key=jadx&metric=bugs)](https://sonarcloud.io/dashboard?id=jadx)
 [![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
 
 **jadx** - Dex to Java decompiler
 
 Command line and GUI tools for produce Java source code from Android Dex and Apk files
 
-![jadx-gui screenshot](http://skylot.github.io/jadx/jadx-gui.png)
+![jadx-gui screenshot](https://i.imgur.com/h917IBZ.png)
+
 
 ### Downloads
-- [unstable](https://drone.io/github.com/skylot/jadx/files)
-- from [github](https://github.com/skylot/jadx/releases)
-- from [sourceforge](http://sourceforge.net/projects/jadx/files/)
+- latest [unstable build: ![Download](https://api.bintray.com/packages/skylot/jadx/unstable/images/download.svg) ](https://bintray.com/skylot/jadx/unstable/_latestVersion#files)
+- release from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- release from [bintray: ![Download](https://api.bintray.com/packages/skylot/jadx/releases/images/download.svg) ](https://bintray.com/skylot/jadx/releases/_latestVersion#files)
+- release from [sourceforge](http://sourceforge.net/projects/jadx/files/)
 
+After download unpack zip file go to `bin` directory and run:
+- `jadx` - command line version
+- `jadx-gui` - graphical version
+
+On Windows run `.bat` files with double-click\
+**Note:** ensure you have installed Java 8 64-bit version
 
 ### Building from source
+Java 8 JDK or higher must be installed:
+
     git clone https://github.com/skylot/jadx.git
     cd jadx
     ./gradlew dist
@@ -34,7 +43,7 @@ Run **jadx** on itself:
 
     cd build/jadx/
     bin/jadx -d out lib/jadx-core-*.jar
-    #or
+    # or
     bin/jadx-gui lib/jadx-core-*.jar
 
 
@@ -42,23 +51,31 @@ Run **jadx** on itself:
 ```
 jadx[-gui] [options] <input file> (.dex, .apk, .jar or .class)
 options:
- -d, --output-dir        - output directory
- -j, --threads-count     - processing threads count
- -f, --fallback          - make simple dump (using goto instead of 'if', 'for', etc)
- -r, --no-res            - do not decode resources
- -s, --no-src            - do not decompile source code
-     --show-bad-code     - show inconsistent code (incorrectly decompiled)
-     --cfg               - save methods control flow graph to dot file
-     --raw-cfg           - save methods control flow graph (use raw instructions)
- -v, --verbose           - verbose output
-     --deobf             - activate deobfuscation
-     --deobf-min         - min length of name
-     --deobf-max         - max length of name
-     --deobf-rewrite-cfg - force to save deobfuscation map
- -h, --help              - print this help
+ -d,  --output-dir           - output directory
+ -ds, --output-dir-src       - output directory for sources
+ -dr, --output-dir-res       - output directory for resources
+ -j,  --threads-count        - processing threads count
+ -r,  --no-res               - do not decode resources
+ -s,  --no-src               - do not decompile source code
+ -e,  --export-gradle        - save as android gradle project
+      --show-bad-code        - show inconsistent code (incorrectly decompiled)
+      --no-imports           - disable use of imports, always write entire package name
+      --no-replace-consts    - don't replace constant value with matching constant field
+      --escape-unicode       - escape non latin characters in strings (with \u)
+      --deobf                - activate deobfuscation
+      --deobf-min            - min length of name
+      --deobf-max            - max length of name
+      --deobf-rewrite-cfg    - force to save deobfuscation map
+      --deobf-use-sourcename - use source file name as class name alias
+      --cfg                  - save methods control flow graph to dot file
+      --raw-cfg              - save methods control flow graph (use raw instructions)
+ -f,  --fallback             - make simple dump (using goto instead of 'if', 'for', etc)
+ -v,  --verbose              - verbose output
+ -h,  --help                 - print this help
 Example:
  jadx -d out classes.dex
 ```
+These options also worked on jadx-gui running from command line and override options from preferences dialog
 
 ### Troubleshooting
 ##### Out of memory error:
@@ -69,21 +86,7 @@ Example:
     * edit 'jadx' script (jadx.bat on Windows) and setup bigger heap size:
       `DEFAULT_JVM_OPTS="-Xmx2500M"`
 
-
-### Contribution
-
-To support this project you can:
-  - Post thoughts about new features/optimizations that important to you
-  - Submit bug using one of following patterns:
-    * Java code examples which decompiles incorrectly
-    * Error log and link to _public available_ apk file or app page on Google play
-
-And any other comments will be very helpfull,
-because at current stage of development it is very time consuming
-to **find** new bugs, design and implement new features.
-Also I need to **prioritize** these task for complete most important at first.
-
 ---------------------------------------
 *Licensed under the Apache 2.0 License*
 
-*Copyright 2015 by Skylot*
+*Copyright 2018 by Skylot*

bintray.json

@@ -0,0 +1,34 @@
+{
+  "package": {
+    "name": "unstable",
+    "repo": "jadx",
+    "subject": "skylot",
+    "desc": "Unstable",
+    "website_url": "https://github.com/skylot/jadx",
+    "issue_tracker_url": "https://github.com/skylot/jadx/issues",
+    "vcs_url": "https://github.com/skylot/jadx.git",
+    "licenses": [
+      "Apache-2.0"
+    ],
+    "labels": [
+      "unstable"
+    ],
+    "public_download_numbers": true,
+    "public_stats": true
+  },
+  "version": {
+    "name": "BUILD_VERSION",
+    "desc": "Dev build: BUILD_VERSION"
+  },
+  "files": [
+    {
+      "includePattern": "build/(jadx.*\.zip)",
+      "uploadPattern": "$1",
+      "matrixParams": {
+        "override": 1
+      },
+      "list_in_downloads": true
+    }
+  ],
+  "publish": true
+}

build.gradle

@@ -1,38 +1,33 @@
-buildscript {
-    repositories {
-        mavenCentral()
-        jcenter()
-    }
-}
-
 plugins {
-    id "com.github.kt3k.coveralls" version "2.3.1"
-    id "info.solidsoft.pitest" version "1.1.4"
-//    id "com.github.ben-manes.versions" version "0.8"
+    id 'com.github.ksoichiro.console.reporter' version '0.5.0'
+    id 'org.sonarqube' version '2.6.2'
+    id 'com.github.ben-manes.versions' version '0.17.0'
 }
 
-apply plugin: 'sonar-runner'
-
 ext.jadxVersion = file('version').readLines().get(0)
 version = jadxVersion
 
-subprojects {
+allprojects {
     apply plugin: 'java'
     apply plugin: 'groovy'
     apply plugin: 'jacoco'
-    apply plugin: 'com.github.kt3k.coveralls'
+    apply plugin: 'com.github.ksoichiro.console.reporter'
 
     version = jadxVersion
 
     tasks.withType(JavaCompile) {
-        sourceCompatibility = JavaVersion.VERSION_1_6
-        targetCompatibility = JavaVersion.VERSION_1_6
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
 
         if (!"$it".contains(':jadx-samples:')) {
             options.compilerArgs << '-Xlint' << '-Xlint:unchecked' << '-Xlint:deprecation'
         }
     }
 
+    compileJava {
+        options.encoding = "UTF-8"
+    }
+
     jar {
         version = jadxVersion
         manifest {
@@ -41,36 +36,51 @@ subprojects {
     }
 
     dependencies {
-        compile 'org.slf4j:slf4j-api:1.7.10'
+        compile 'org.slf4j:slf4j-api:1.7.25'
 
-        testCompile 'ch.qos.logback:logback-classic:1.1.2'
+        testCompile 'ch.qos.logback:logback-classic:1.2.3'
         testCompile 'junit:junit:4.12'
         testCompile 'org.hamcrest:hamcrest-library:1.3'
-        testCompile 'org.mockito:mockito-core:1.10.19'
-        testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
-        testCompile 'cglib:cglib-nodep:3.1'
+        testCompile 'org.mockito:mockito-core:2.15.0'
+        testCompile 'org.spockframework:spock-core:1.1-groovy-2.4'
+        testCompile 'cglib:cglib-nodep:3.2.6'
     }
 
     repositories {
-        mavenCentral()
         mavenLocal()
+        mavenCentral()
         jcenter()
     }
 
+    jacoco {
+        toolVersion = "0.8.0"
+    }
     jacocoTestReport {
         reports {
-            xml.enabled = true // coveralls plugin depends on xml format report
+            xml.enabled = true
             html.enabled = true
         }
     }
 }
 
-/* Sonar runner configuration */
-repositories {
-    mavenCentral()
+sonarqube {
+    properties {
+        property 'sonar.exclusions', '**/jadx/samples/**/*,**/test-app/**/*'
+        property 'sonar.coverage.exclusions', '**/jadx/gui/**/*'
+    }
 }
-sonarRunner {
-    toolVersion = '2.4'
+
+dependencyUpdates.resolutionStrategy = {
+    componentSelection { rules ->
+        rules.all { ComponentSelection selection ->
+            boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm', 'atlassian'].any { qualifier ->
+                selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
+            }
+            if (rejected) {
+                selection.reject('Release candidate')
+            }
+        }
+    }
 }
 
 task copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installDist', 'jadx-gui:installDist']) {
@@ -93,7 +103,7 @@ task dist(dependsOn: pack) {
 task samples(dependsOn: 'jadx-samples:samples') {
 }
 
-task pitest(overwrite: true, dependsOn: 'jadx-core:pitest') {
+task testAppCheck(dependsOn: 'jadx-test-app:testAppCheck') {
 }
 
 task cleanBuildDir(type: Delete) {
@@ -104,6 +114,3 @@ build.dependsOn(dist, samples)
 
 clean.dependsOn(cleanBuildDir)
 
-task wrapper(type: Wrapper) {
-    gradleVersion = '2.3'
-}

gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.5.1-bin.zip

gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
 ##############################################################################
 ##
@@ -6,47 +6,6 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -61,9 +20,49 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -90,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -154,11 +154,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

jadx-cli/build.gradle

@@ -5,8 +5,8 @@ applicationName = 'jadx'
 
 dependencies {
     compile(project(':jadx-core'))
-    compile 'com.beust:jcommander:1.47'
-    compile 'ch.qos.logback:logback-classic:1.1.2'
+    compile 'com.beust:jcommander:1.72'
+    compile 'ch.qos.logback:logback-classic:1.2.3'
 }
 
 applicationDistribution.with {
@@ -18,3 +18,6 @@ applicationDistribution.with {
     }
 }
 
+startScripts {
+    defaultJvmOpts = [ '-Xms2g', '-Xmx4g' ]
+}

jadx-cli/src/main/java/jadx/cli/JadxCLI.java

@@ -1,32 +1,34 @@
 package jadx.cli;
 
-import jadx.api.JadxDecompiler;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxDecompiler;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
 public class JadxCLI {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxCLI.class);
 
-	public static void main(String[] args) throws JadxException {
+	public static void main(String[] args) {
 		try {
 			JadxCLIArgs jadxArgs = new JadxCLIArgs();
-			if (processArgs(jadxArgs, args)) {
+			if (jadxArgs.processArgs(args)) {
 				processAndSave(jadxArgs);
 			}
-		} catch (Throwable e) {
+		} catch (Exception e) {
 			LOG.error("jadx error: {}", e.getMessage(), e);
 			System.exit(1);
 		}
 	}
 
-	static void processAndSave(JadxCLIArgs jadxArgs) throws JadxException {
-		JadxDecompiler jadx = new JadxDecompiler(jadxArgs);
-		jadx.setOutputDir(jadxArgs.getOutDir());
-		jadx.loadFiles(jadxArgs.getInput());
+	static void processAndSave(JadxCLIArgs inputArgs) {
+		JadxDecompiler jadx = new JadxDecompiler(inputArgs.toJadxArgs());
+		try {
+			jadx.load();
+		} catch (JadxArgsValidateException e) {
+			LOG.error("Incorrect arguments: {}", e.getMessage());
+			System.exit(1);
+		}
 		jadx.save();
 		if (jadx.getErrorsCount() != 0) {
 			jadx.printErrorsReport();
@@ -35,34 +37,4 @@ public class JadxCLI {
 			LOG.info("done");
 		}
 	}
-
-	static boolean processArgs(JadxCLIArgs jadxArgs, String[] args) throws JadxException {
-		if (!jadxArgs.processArgs(args)) {
-			return false;
-		}
-		if (jadxArgs.getInput().isEmpty()) {
-			LOG.error("Please specify input file");
-			jadxArgs.printUsage();
-			return false;
-		}
-		File outputDir = jadxArgs.getOutDir();
-		if (outputDir == null) {
-			String outDirName;
-			File file = jadxArgs.getInput().get(0);
-			String name = file.getName();
-			int pos = name.lastIndexOf('.');
-			if (pos != -1) {
-				outDirName = name.substring(0, pos);
-			} else {
-				outDirName = name + "-jadx-out";
-			}
-			LOG.info("output directory: {}", outDirName);
-			outputDir = new File(outDirName);
-			jadxArgs.setOutputDir(outputDir);
-		}
-		if (outputDir.exists() && !outputDir.isDirectory()) {
-			throw new JadxException("Output directory exists as file " + outputDir);
-		}
-		return true;
-	}
 }

jadx-cli/src/main/java/jadx/cli/JadxCLIArgs.java

@@ -1,38 +1,40 @@
 package jadx.cli;
 
-import jadx.api.IJadxArgs;
-import jadx.api.JadxDecompiler;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
 import java.io.PrintStream;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.Appender;
 import com.beust.jcommander.JCommander;
 import com.beust.jcommander.Parameter;
 import com.beust.jcommander.ParameterDescription;
 import com.beust.jcommander.ParameterException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-public class JadxCLIArgs implements IJadxArgs {
+import jadx.api.JadxArgs;
+import jadx.api.JadxDecompiler;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.FileUtils;
 
-	@Parameter(description = "<input file> (.dex, .apk, .jar or .class)")
-	protected List<String> files;
+public class JadxCLIArgs {
+
+	@Parameter(description = "<input file> (.apk, .dex, .jar or .class)")
+	protected List<String> files = new ArrayList<>(1);
 
 	@Parameter(names = {"-d", "--output-dir"}, description = "output directory")
-	protected String outDirName;
+	protected String outDir;
 
-	@Parameter(names = {"-j", "--threads-count"}, description = "processing threads count")
-	protected int threadsCount = Runtime.getRuntime().availableProcessors();
+	@Parameter(names = {"-ds", "--output-dir-src"}, description = "output directory for sources")
+	protected String outDirSrc;
 
-	@Parameter(names = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)")
-	protected boolean fallbackMode = false;
+	@Parameter(names = {"-dr", "--output-dir-res"}, description = "output directory for resources")
+	protected String outDirRes;
 
 	@Parameter(names = {"-r", "--no-res"}, description = "do not decode resources")
 	protected boolean skipResources = false;
@@ -40,17 +42,23 @@ public class JadxCLIArgs implements IJadxArgs {
 	@Parameter(names = {"-s", "--no-src"}, description = "do not decompile source code")
 	protected boolean skipSources = false;
 
+	@Parameter(names = {"-e", "--export-gradle"}, description = "save as android gradle project")
+	protected boolean exportAsGradleProject = false;
+
+	@Parameter(names = {"-j", "--threads-count"}, description = "processing threads count")
+	protected int threadsCount = JadxArgs.DEFAULT_THREADS_COUNT;
+
 	@Parameter(names = {"--show-bad-code"}, description = "show inconsistent code (incorrectly decompiled)")
 	protected boolean showInconsistentCode = false;
 
-	@Parameter(names = {"--cfg"}, description = "save methods control flow graph to dot file")
-	protected boolean cfgOutput = false;
+	@Parameter(names = {"--no-imports"}, description = "disable use of imports, always write entire package name")
+	protected boolean useImports = true;
 
-	@Parameter(names = {"--raw-cfg"}, description = "save methods control flow graph (use raw instructions)")
-	protected boolean rawCfgOutput = false;
+	@Parameter(names = "--no-replace-consts", description = "don't replace constant value with matching constant field")
+	protected boolean replaceConsts = true;
 
-	@Parameter(names = {"-v", "--verbose"}, description = "verbose output")
-	protected boolean verbose = false;
+	@Parameter(names = {"--escape-unicode"}, description = "escape non latin characters in strings (with \\u)")
+	protected boolean escapeUnicode = false;
 
 	@Parameter(names = {"--deobf"}, description = "activate deobfuscation")
 	protected boolean deobfuscationOn = false;
@@ -64,19 +72,34 @@ public class JadxCLIArgs implements IJadxArgs {
 	@Parameter(names = {"--deobf-rewrite-cfg"}, description = "force to save deobfuscation map")
 	protected boolean deobfuscationForceSave = false;
 
+	@Parameter(names = {"--deobf-use-sourcename"}, description = "use source file name as class name alias")
+	protected boolean deobfuscationUseSourceNameAsAlias = false;
+
+	@Parameter(names = {"--cfg"}, description = "save methods control flow graph to dot file")
+	protected boolean cfgOutput = false;
+
+	@Parameter(names = {"--raw-cfg"}, description = "save methods control flow graph (use raw instructions)")
+	protected boolean rawCfgOutput = false;
+
+	@Parameter(names = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)")
+	protected boolean fallbackMode = false;
+
+	@Parameter(names = {"-v", "--verbose"}, description = "verbose output")
+	protected boolean verbose = false;
+
+	@Parameter(names = {"--version"}, description = "print jadx version")
+	protected boolean printVersion = false;
+
 	@Parameter(names = {"-h", "--help"}, description = "print this help", help = true)
 	protected boolean printHelp = false;
 
-	private final List<File> input = new ArrayList<File>(1);
-	private File outputDir;
-
 	public boolean processArgs(String[] args) {
 		return parse(args) && process();
 	}
 
 	private boolean parse(String[] args) {
 		try {
-			new JCommander(this, args);
+			makeJCommander().parse(args);
 			return true;
 		} catch (ParameterException e) {
 			System.err.println("Arguments parse error: " + e.getMessage());
@@ -85,35 +108,31 @@ public class JadxCLIArgs implements IJadxArgs {
 		}
 	}
 
+	private JCommander makeJCommander() {
+		return JCommander.newBuilder().addObject(this).build();
+	}
+
 	private boolean process() {
-		if (isPrintHelp()) {
+		if (printHelp) {
 			printUsage();
 			return false;
 		}
+		if (printVersion) {
+			System.out.println(JadxDecompiler.getVersion());
+			return false;
+		}
 		try {
 			if (threadsCount <= 0) {
-				throw new JadxException("Threads count must be positive");
+				throw new JadxException("Threads count must be positive, got: " + threadsCount);
 			}
-			if (files != null) {
-				for (String fileName : files) {
-					File file = new File(fileName);
-					if (file.exists()) {
-						input.add(file);
-					} else {
-						throw new JadxException("File not found: " + file);
-					}
-				}
-			}
-			if (input.size() > 1) {
-				throw new JadxException("Only one input file is supported");
-			}
-			if (outDirName != null) {
-				outputDir = new File(outDirName);
-			}
-			if (isVerbose()) {
+			if (verbose) {
 				ch.qos.logback.classic.Logger rootLogger =
 						(ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
-				rootLogger.setLevel(ch.qos.logback.classic.Level.DEBUG);
+				// remove INFO ThresholdFilter
+				Appender<ILoggingEvent> appender = rootLogger.getAppender("STDOUT");
+				if (appender != null) {
+					appender.clearAllFilters();
+				}
 			}
 		} catch (JadxException e) {
 			System.err.println("ERROR: " + e.getMessage());
@@ -124,7 +143,7 @@ public class JadxCLIArgs implements IJadxArgs {
 	}
 
 	public void printUsage() {
-		JCommander jc = new JCommander(this);
+		JCommander jc = makeJCommander();
 		// print usage in not sorted fields order (by default its sorted by description)
 		PrintStream out = System.out;
 		out.println();
@@ -134,7 +153,7 @@ public class JadxCLIArgs implements IJadxArgs {
 		out.println("options:");
 
 		List<ParameterDescription> params = jc.getParameters();
-		Map<String, ParameterDescription> paramsMap = new LinkedHashMap<String, ParameterDescription>(params.size());
+		Map<String, ParameterDescription> paramsMap = new LinkedHashMap<>(params.size());
 		int maxNamesLen = 0;
 		for (ParameterDescription p : params) {
 			paramsMap.put(p.getParameterized().getName(), p);
@@ -151,13 +170,13 @@ public class JadxCLIArgs implements IJadxArgs {
 				continue;
 			}
 			StringBuilder opt = new StringBuilder();
-			opt.append(' ').append(p.getNames());
+			opt.append("  ").append(p.getNames());
 			addSpaces(opt, maxNamesLen - opt.length() + 2);
 			opt.append("- ").append(p.getDescription());
 			out.println(opt);
 		}
 		out.println("Example:");
-		out.println(" jadx -d out classes.dex");
+		out.println("  jadx -d out classes.dex");
 	}
 
 	private static void addSpaces(StringBuilder str, int count) {
@@ -166,80 +185,112 @@ public class JadxCLIArgs implements IJadxArgs {
 		}
 	}
 
-	public List<File> getInput() {
-		return input;
+	public JadxArgs toJadxArgs() {
+		JadxArgs args = new JadxArgs();
+		args.setInputFiles(files.stream().map(FileUtils::toFile).collect(Collectors.toList()));
+		args.setOutDir(FileUtils.toFile(outDir));
+		args.setOutDirSrc(FileUtils.toFile(outDirSrc));
+		args.setOutDirRes(FileUtils.toFile(outDirRes));
+		args.setThreadsCount(threadsCount);
+		args.setSkipSources(skipSources);
+		args.setSkipResources(skipResources);
+		args.setFallbackMode(fallbackMode);
+		args.setShowInconsistentCode(showInconsistentCode);
+		args.setCfgOutput(cfgOutput);
+		args.setRawCFGOutput(rawCfgOutput);
+		args.setReplaceConsts(replaceConsts);
+		args.setDeobfuscationOn(deobfuscationOn);
+		args.setDeobfuscationForceSave(deobfuscationForceSave);
+		args.setDeobfuscationMinLength(deobfuscationMinLength);
+		args.setDeobfuscationMaxLength(deobfuscationMaxLength);
+		args.setUseSourceNameAsClassAlias(deobfuscationUseSourceNameAsAlias);
+		args.setEscapeUnicode(escapeUnicode);
+		args.setExportAsGradleProject(exportAsGradleProject);
+		args.setUseImports(useImports);
+		return args;
 	}
 
-	@Override
-	public File getOutDir() {
-		return outputDir;
+	public List<String> getFiles() {
+		return files;
 	}
 
-	public void setOutputDir(File outputDir) {
-		this.outputDir = outputDir;
+	public String getOutDir() {
+		return outDir;
 	}
 
-	public boolean isPrintHelp() {
-		return printHelp;
+	public String getOutDirSrc() {
+		return outDirSrc;
+	}
+
+	public String getOutDirRes() {
+		return outDirRes;
 	}
 
-	@Override
 	public boolean isSkipResources() {
 		return skipResources;
 	}
 
-	@Override
 	public boolean isSkipSources() {
 		return skipSources;
 	}
 
-	@Override
 	public int getThreadsCount() {
 		return threadsCount;
 	}
 
-	@Override
-	public boolean isCFGOutput() {
-		return cfgOutput;
-	}
-
-	@Override
-	public boolean isRawCFGOutput() {
-		return rawCfgOutput;
-	}
-
-	@Override
 	public boolean isFallbackMode() {
 		return fallbackMode;
 	}
 
-	@Override
 	public boolean isShowInconsistentCode() {
 		return showInconsistentCode;
 	}
 
-	@Override
-	public boolean isVerbose() {
-		return verbose;
+	public boolean isUseImports() {
+		return useImports;
 	}
 
-	@Override
 	public boolean isDeobfuscationOn() {
 		return deobfuscationOn;
 	}
 
-	@Override
 	public int getDeobfuscationMinLength() {
 		return deobfuscationMinLength;
 	}
 
-	@Override
 	public int getDeobfuscationMaxLength() {
 		return deobfuscationMaxLength;
 	}
 
-	@Override
 	public boolean isDeobfuscationForceSave() {
 		return deobfuscationForceSave;
 	}
+
+	public boolean isDeobfuscationUseSourceNameAsAlias() {
+		return deobfuscationUseSourceNameAsAlias;
+	}
+
+	public boolean escapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public boolean isRawCfgOutput() {
+		return rawCfgOutput;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
 }

jadx-cli/src/main/resources/logback.xml

@@ -1,12 +1,15 @@
 <configuration>
 
     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>INFO</level>
+        </filter>
         <encoder>
             <pattern>%-5level - %msg%n</pattern>
         </encoder>
     </appender>
 
-    <root level="INFO">
+    <root level="DEBUG">
         <appender-ref ref="STDOUT"/>
     </root>
 

jadx-cli/src/test/java/jadx/cli/JadxCLIArgsTest.java

@@ -0,0 +1,40 @@
+package jadx.cli;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class JadxCLIArgsTest {
+
+	private static final Logger LOG = LoggerFactory.getLogger(JadxCLIArgsTest.class);
+
+	@Test
+	public void testInvertedBooleanOption() {
+		assertThat(parse("--no-replace-consts").isReplaceConsts(), is(false));
+		assertThat(parse("").isReplaceConsts(), is(true));
+	}
+
+	@Test
+	public void testEscapeUnicodeOption() {
+		assertThat(parse("--escape-unicode").isEscapeUnicode(), is(true));
+		assertThat(parse("").isEscapeUnicode(), is(false));
+	}
+
+	@Test
+	public void testSrcOption() {
+		assertThat(parse("--no-src").isSkipSources(), is(true));
+		assertThat(parse("-s").isSkipSources(), is(true));
+		assertThat(parse("").isSkipSources(), is(false));
+	}
+
+	private JadxCLIArgs parse(String... args) {
+		JadxCLIArgs jadxArgs = new JadxCLIArgs();
+		boolean res = jadxArgs.processArgs(args);
+		assertThat(res, is(true));
+		LOG.info("Jadx args: {}", jadxArgs.toJadxArgs());
+		return jadxArgs;
+	}
+}

jadx-core/build.gradle

@@ -1,27 +1,15 @@
 ext.jadxClasspath = 'clsp-data/android-5.1.jar'
 
-apply plugin: "info.solidsoft.pitest"
-
 dependencies {
     runtime files(jadxClasspath)
 
-    compile files('lib/dx-1.10.jar')
-    compile 'commons-io:commons-io:2.4'
-    compile 'org.ow2.asm:asm:5.0.3'
-    compile 'com.intellij:annotations:12.0'
+    compile files('lib/dx-1.14.jar')
+    compile 'commons-io:commons-io:2.6'
+    compile 'org.ow2.asm:asm:6.0'
+    compile 'org.jetbrains:annotations:15.0'
+    compile 'uk.com.robust-it:cloning:1.9.9'
 
-    testCompile 'org.smali:smali:2.0.3'
+    testCompile 'org.smali:smali:2.2.2'
+    testCompile 'org.smali:baksmali:2.2.2'
 }
 
-task packTests(type: Jar) {
-    classifier = 'tests'
-    from sourceSets.test.output
-}
-
-pitest {
-    excludedMethods = ['toString']
-    threads = 4
-    enableDefaultIncrementalAnalysis = true
-    outputFormats = ['XML', 'HTML']
-    jvmArgs = ['-Xmx12G']
-}

jadx-core/src/main/java/jadx/api/CodePosition.java

@@ -2,24 +2,32 @@ package jadx.api;
 
 public final class CodePosition {
 
-	private final JavaClass cls;
+	private final JavaNode node;
 	private final int line;
 	private final int offset;
 
-	public CodePosition(JavaClass cls, int line, int offset) {
-		this.cls = cls;
+	public CodePosition(JavaNode node, int line, int offset) {
+		this.node = node;
 		this.line = line;
 		this.offset = offset;
 	}
 
 	public CodePosition(int line, int offset) {
-		this.cls = null;
+		this.node = null;
 		this.line = line;
 		this.offset = offset;
 	}
 
+	public JavaNode getNode() {
+		return node;
+	}
+
 	public JavaClass getJavaClass() {
-		return cls;
+		JavaClass parent = node.getDeclaringClass();
+		if (parent == null && node instanceof JavaClass) {
+			return (JavaClass) node;
+		}
+		return parent;
 	}
 
 	public int getLine() {
@@ -30,10 +38,6 @@ public final class CodePosition {
 		return offset;
 	}
 
-	public boolean isSet() {
-		return line != 0 || offset != 0;
-	}
-
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) {
@@ -53,6 +57,6 @@ public final class CodePosition {
 
 	@Override
 	public String toString() {
-		return line + ":" + offset + (cls != null ? " " + cls : "");
+		return line + ":" + offset + (node != null ? " " + node : "");
 	}
 }

jadx-core/src/main/java/jadx/api/DefaultJadxArgs.java

@@ -1,71 +0,0 @@
-package jadx.api;
-
-import java.io.File;
-
-public class DefaultJadxArgs implements IJadxArgs {
-
-	@Override
-	public File getOutDir() {
-		return new File("jadx-output");
-	}
-
-	@Override
-	public int getThreadsCount() {
-		return Runtime.getRuntime().availableProcessors();
-	}
-
-	@Override
-	public boolean isCFGOutput() {
-		return false;
-	}
-
-	@Override
-	public boolean isRawCFGOutput() {
-		return false;
-	}
-
-	@Override
-	public boolean isFallbackMode() {
-		return false;
-	}
-
-	@Override
-	public boolean isShowInconsistentCode() {
-		return false;
-	}
-
-	@Override
-	public boolean isVerbose() {
-		return false;
-	}
-
-	@Override
-	public boolean isSkipResources() {
-		return false;
-	}
-
-	@Override
-	public boolean isSkipSources() {
-		return false;
-	}
-
-	@Override
-	public boolean isDeobfuscationOn() {
-		return false;
-	}
-
-	@Override
-	public int getDeobfuscationMinLength() {
-		return Integer.MIN_VALUE + 1;
-	}
-
-	@Override
-	public int getDeobfuscationMaxLength() {
-		return Integer.MAX_VALUE - 1;
-	}
-
-	@Override
-	public boolean isDeobfuscationForceSave() {
-		return false;
-	}
-}

jadx-core/src/main/java/jadx/api/IJadxArgs.java

@@ -1,31 +0,0 @@
-package jadx.api;
-
-import java.io.File;
-
-public interface IJadxArgs {
-	File getOutDir();
-
-	int getThreadsCount();
-
-	boolean isCFGOutput();
-
-	boolean isRawCFGOutput();
-
-	boolean isFallbackMode();
-
-	boolean isShowInconsistentCode();
-
-	boolean isVerbose();
-
-	boolean isSkipResources();
-
-	boolean isSkipSources();
-
-	boolean isDeobfuscationOn();
-
-	int getDeobfuscationMinLength();
-
-	int getDeobfuscationMaxLength();
-
-	boolean isDeobfuscationForceSave();
-}

jadx-core/src/main/java/jadx/api/JadxArgs.java

@@ -0,0 +1,241 @@
+package jadx.api;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class JadxArgs {
+
+	public static final int DEFAULT_THREADS_COUNT = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
+
+	public static final String DEFAULT_OUT_DIR = "jadx-output";
+	public static final String DEFAULT_SRC_DIR = "sources";
+	public static final String DEFAULT_RES_DIR = "resources";
+
+	private List<File> inputFiles = new ArrayList<>(1);
+
+	private File outDir;
+	private File outDirSrc;
+	private File outDirRes;
+
+	private int threadsCount = DEFAULT_THREADS_COUNT;
+
+	private boolean cfgOutput = false;
+	private boolean rawCFGOutput = false;
+
+	private boolean fallbackMode = false;
+	private boolean showInconsistentCode = false;
+
+	private boolean useImports = true;
+
+	private boolean isSkipResources = false;
+	private boolean isSkipSources = false;
+
+	private boolean isDeobfuscationOn = false;
+	private boolean isDeobfuscationForceSave = false;
+	private boolean useSourceNameAsClassAlias = false;
+
+	private int deobfuscationMinLength = 0;
+	private int deobfuscationMaxLength = Integer.MAX_VALUE;
+
+	private boolean escapeUnicode = false;
+	private boolean replaceConsts = true;
+	private boolean exportAsGradleProject = false;
+
+	public JadxArgs() {
+		// use default options
+	}
+
+	public void setRootDir(File rootDir) {
+		setOutDir(rootDir);
+		setOutDirSrc(new File(rootDir, DEFAULT_SRC_DIR));
+		setOutDirRes(new File(rootDir, DEFAULT_RES_DIR));
+	}
+
+	public List<File> getInputFiles() {
+		return inputFiles;
+	}
+
+	public void setInputFiles(List<File> inputFiles) {
+		this.inputFiles = inputFiles;
+	}
+
+	public File getOutDir() {
+		return outDir;
+	}
+
+	public void setOutDir(File outDir) {
+		this.outDir = outDir;
+	}
+
+	public File getOutDirSrc() {
+		return outDirSrc;
+	}
+
+	public void setOutDirSrc(File outDirSrc) {
+		this.outDirSrc = outDirSrc;
+	}
+
+	public File getOutDirRes() {
+		return outDirRes;
+	}
+
+	public void setOutDirRes(File outDirRes) {
+		this.outDirRes = outDirRes;
+	}
+
+	public int getThreadsCount() {
+		return threadsCount;
+	}
+
+	public void setThreadsCount(int threadsCount) {
+		this.threadsCount = threadsCount;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public void setCfgOutput(boolean cfgOutput) {
+		this.cfgOutput = cfgOutput;
+	}
+
+	public boolean isRawCFGOutput() {
+		return rawCFGOutput;
+	}
+
+	public void setRawCFGOutput(boolean rawCFGOutput) {
+		this.rawCFGOutput = rawCFGOutput;
+	}
+
+	public boolean isFallbackMode() {
+		return fallbackMode;
+	}
+
+	public void setFallbackMode(boolean fallbackMode) {
+		this.fallbackMode = fallbackMode;
+	}
+
+	public boolean isShowInconsistentCode() {
+		return showInconsistentCode;
+	}
+
+	public void setShowInconsistentCode(boolean showInconsistentCode) {
+		this.showInconsistentCode = showInconsistentCode;
+	}
+
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public void setUseImports(boolean useImports) {
+		this.useImports = useImports;
+	}
+
+	public boolean isSkipResources() {
+		return isSkipResources;
+	}
+
+	public void setSkipResources(boolean skipResources) {
+		isSkipResources = skipResources;
+	}
+
+	public boolean isSkipSources() {
+		return isSkipSources;
+	}
+
+	public void setSkipSources(boolean skipSources) {
+		isSkipSources = skipSources;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return isDeobfuscationOn;
+	}
+
+	public void setDeobfuscationOn(boolean deobfuscationOn) {
+		isDeobfuscationOn = deobfuscationOn;
+	}
+
+	public boolean isDeobfuscationForceSave() {
+		return isDeobfuscationForceSave;
+	}
+
+	public void setDeobfuscationForceSave(boolean deobfuscationForceSave) {
+		isDeobfuscationForceSave = deobfuscationForceSave;
+	}
+
+	public boolean isUseSourceNameAsClassAlias() {
+		return useSourceNameAsClassAlias;
+	}
+
+	public void setUseSourceNameAsClassAlias(boolean useSourceNameAsClassAlias) {
+		this.useSourceNameAsClassAlias = useSourceNameAsClassAlias;
+	}
+
+	public int getDeobfuscationMinLength() {
+		return deobfuscationMinLength;
+	}
+
+	public void setDeobfuscationMinLength(int deobfuscationMinLength) {
+		this.deobfuscationMinLength = deobfuscationMinLength;
+	}
+
+	public int getDeobfuscationMaxLength() {
+		return deobfuscationMaxLength;
+	}
+
+	public void setDeobfuscationMaxLength(int deobfuscationMaxLength) {
+		this.deobfuscationMaxLength = deobfuscationMaxLength;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public void setEscapeUnicode(boolean escapeUnicode) {
+		this.escapeUnicode = escapeUnicode;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public void setReplaceConsts(boolean replaceConsts) {
+		this.replaceConsts = replaceConsts;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public void setExportAsGradleProject(boolean exportAsGradleProject) {
+		this.exportAsGradleProject = exportAsGradleProject;
+	}
+
+	@Override
+	public String toString() {
+		final StringBuilder sb = new StringBuilder("JadxArgs{");
+		sb.append("inputFiles=").append(inputFiles);
+		sb.append(", outDir=").append(outDir);
+		sb.append(", outDirSrc=").append(outDirSrc);
+		sb.append(", outDirRes=").append(outDirRes);
+		sb.append(", threadsCount=").append(threadsCount);
+		sb.append(", cfgOutput=").append(cfgOutput);
+		sb.append(", rawCFGOutput=").append(rawCFGOutput);
+		sb.append(", fallbackMode=").append(fallbackMode);
+		sb.append(", showInconsistentCode=").append(showInconsistentCode);
+		sb.append(", useImports=").append(useImports);
+		sb.append(", isSkipResources=").append(isSkipResources);
+		sb.append(", isSkipSources=").append(isSkipSources);
+		sb.append(", isDeobfuscationOn=").append(isDeobfuscationOn);
+		sb.append(", isDeobfuscationForceSave=").append(isDeobfuscationForceSave);
+		sb.append(", useSourceNameAsClassAlias=").append(useSourceNameAsClassAlias);
+		sb.append(", deobfuscationMinLength=").append(deobfuscationMinLength);
+		sb.append(", deobfuscationMaxLength=").append(deobfuscationMaxLength);
+		sb.append(", escapeUnicode=").append(escapeUnicode);
+		sb.append(", replaceConsts=").append(replaceConsts);
+		sb.append(", exportAsGradleProject=").append(exportAsGradleProject);
+		sb.append('}');
+		return sb.toString();
+	}
+}

jadx-core/src/main/java/jadx/api/JadxArgsValidator.java

@@ -0,0 +1,108 @@
+package jadx.api;
+
+import java.io.File;
+import java.util.List;
+
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
+public class JadxArgsValidator {
+
+	private static final Logger LOG = LoggerFactory.getLogger(JadxArgsValidator.class);
+
+	public static void validate(JadxArgs args) {
+		checkInputFiles(args);
+		validateOutDirs(args);
+
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Effective jadx args: {}", args);
+		}
+	}
+
+	private static void checkInputFiles(JadxArgs args) {
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty()) {
+			throw new JadxArgsValidateException("Please specify input file");
+		}
+		if (inputFiles.size() > 1) {
+			for (File inputFile : inputFiles) {
+				String fileName = inputFile.getName();
+				if (fileName.startsWith("--")) {
+					throw new JadxArgsValidateException("Unknown argument: " + fileName);
+				}
+			}
+			throw new JadxArgsValidateException("Only one input file supported");
+		}
+		for (File file : inputFiles) {
+			checkFile(file);
+		}
+	}
+
+	private static void validateOutDirs(JadxArgs args) {
+		File outDir = args.getOutDir();
+		File srcDir = args.getOutDirSrc();
+		File resDir = args.getOutDirRes();
+		if (outDir == null) {
+			if (srcDir != null) {
+				outDir = srcDir;
+			} else if (resDir != null) {
+				outDir = resDir;
+			} else {
+				outDir = makeDirFromInput(args);
+			}
+		}
+		args.setOutDir(outDir);
+		setFromOut(args);
+
+		checkDir(args.getOutDir());
+		checkDir(args.getOutDirSrc());
+		checkDir(args.getOutDirRes());
+	}
+
+	@NotNull
+	private static File makeDirFromInput(JadxArgs args) {
+		File outDir;
+		String outDirName;
+		File file = args.getInputFiles().get(0);
+		String name = file.getName();
+		int pos = name.lastIndexOf('.');
+		if (pos != -1) {
+			outDirName = name.substring(0, pos);
+		} else {
+			outDirName = name + "-" + JadxArgs.DEFAULT_OUT_DIR;
+		}
+		LOG.info("output directory: {}", outDirName);
+		outDir = new File(outDirName);
+		return outDir;
+	}
+
+	private static void setFromOut(JadxArgs args) {
+		if (args.getOutDirSrc() == null) {
+			args.setOutDirSrc(new File(args.getOutDir(), JadxArgs.DEFAULT_SRC_DIR));
+		}
+		if (args.getOutDirRes() == null) {
+			args.setOutDirRes(new File(args.getOutDir(), JadxArgs.DEFAULT_RES_DIR));
+		}
+	}
+
+	private static void checkFile(File file) {
+		if (!file.exists()) {
+			throw new JadxArgsValidateException("File not found " + file.getAbsolutePath());
+		}
+		if (file.isDirectory()) {
+			throw new JadxArgsValidateException("Expected file but found directory instead: " + file.getAbsolutePath());
+		}
+	}
+
+	private static void checkDir(File dir) {
+		if (dir != null && dir.exists() && !dir.isDirectory()) {
+			throw new JadxArgsValidateException("Output directory exists as file " + dir);
+		}
+	}
+
+	private JadxArgsValidator() {
+	}
+}

jadx-core/src/main/java/jadx/api/JadxDecompiler.java

@@ -1,27 +1,13 @@
 package jadx.api;
 
-import jadx.core.Jadx;
-import jadx.core.ProcessClass;
-import jadx.core.codegen.CodeGen;
-import jadx.core.codegen.CodeWriter;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.dex.visitors.IDexTreeVisitor;
-import jadx.core.dex.visitors.SaveCode;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-import jadx.core.utils.files.InputFile;
-import jadx.core.xmlgen.BinaryXMLParser;
-
 import java.io.File;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -29,16 +15,35 @@ import java.util.concurrent.TimeUnit;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.core.Jadx;
+import jadx.core.ProcessClass;
+import jadx.core.codegen.CodeGen;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.dex.visitors.IDexTreeVisitor;
+import jadx.core.dex.visitors.SaveCode;
+import jadx.core.export.ExportGradleProject;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.InputFile;
+import jadx.core.xmlgen.BinaryXMLParser;
+import jadx.core.xmlgen.ResourcesSaver;
+
 /**
  * Jadx API usage example:
  * <pre><code>
- *  JadxDecompiler jadx = new JadxDecompiler();
- *  jadx.loadFile(new File("classes.dex"));
- *  jadx.setOutputDir(new File("out"));
- *  jadx.save();
+ * JadxArgs args = new JadxArgs();
+ * args.getInputFiles().add(new File("test.apk"));
+ * args.setOutDir(new File("jadx-test-output"));
+ *
+ * JadxDecompiler jadx = new JadxDecompiler(args);
+ * jadx.load();
+ * jadx.save();
  * </code></pre>
  * <p/>
- * Instead of 'save()' you can get list of decompiled classes:
+ * Instead of 'save()' you can iterate over decompiled classes:
  * <pre><code>
  *  for(JavaClass cls : jadx.getClasses()) {
  *      System.out.println(cls.getCode());
@@ -48,10 +53,9 @@ import org.slf4j.LoggerFactory;
 public final class JadxDecompiler {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxDecompiler.class);
 
-	private final IJadxArgs args;
-	private final List<InputFile> inputFiles = new ArrayList<InputFile>();
+	private JadxArgs args;
 
-	private File outDir;
+	private final List<InputFile> inputFiles = new ArrayList<>();
 
 	private RootNode root;
 	private List<IDexTreeVisitor> passes;
@@ -62,28 +66,39 @@ public final class JadxDecompiler {
 
 	private BinaryXMLParser xmlParser;
 
+	private Map<ClassNode, JavaClass> classesMap = new ConcurrentHashMap<>();
+	private Map<MethodNode, JavaMethod> methodsMap = new ConcurrentHashMap<>();
+	private Map<FieldNode, JavaField> fieldsMap = new ConcurrentHashMap<>();
+
 	public JadxDecompiler() {
-		this(new DefaultJadxArgs());
+		this(new JadxArgs());
 	}
 
-	public JadxDecompiler(IJadxArgs jadxArgs) {
-		this.args = jadxArgs;
-		this.outDir = jadxArgs.getOutDir();
+	public JadxDecompiler(JadxArgs args) {
+		this.args = args;
+	}
+
+	public void load() {
 		reset();
+		JadxArgsValidator.validate(args);
 		init();
-	}
+		LOG.info("loading ...");
 
-	public void setOutputDir(File outDir) {
-		this.outDir = outDir;
-		init();
+		loadFiles(args.getInputFiles());
+
+		root = new RootNode(args);
+		root.load(inputFiles);
+
+		root.initClassPath();
+		root.loadResources(getResources());
+		root.initAppResClass();
+
+		initVisitors();
 	}
 
 	void init() {
-		if (outDir == null) {
-			outDir = new DefaultJadxArgs().getOutDir();
-		}
-		this.passes = Jadx.getPassesList(args, outDir);
-		this.codeGen = new CodeGen(args);
+		this.passes = Jadx.getPassesList(args);
+		this.codeGen = new CodeGen();
 	}
 
 	void reset() {
@@ -99,23 +114,18 @@ public final class JadxDecompiler {
 		return Jadx.getVersion();
 	}
 
-	public void loadFile(File file) throws JadxException {
-		loadFiles(Collections.singletonList(file));
-	}
-
-	public void loadFiles(List<File> files) throws JadxException {
+	private void loadFiles(List<File> files) {
 		if (files.isEmpty()) {
-			throw new JadxException("Empty file list");
+			throw new JadxRuntimeException("Empty file list");
 		}
 		inputFiles.clear();
 		for (File file : files) {
 			try {
-				inputFiles.add(new InputFile(file));
-			} catch (IOException e) {
-				throw new JadxException("Error load file: " + file, e);
+				InputFile.addFilesFrom(file, inputFiles, args.isSkipSources());
+			} catch (Exception e) {
+				throw new JadxRuntimeException("Error load file: " + file, e);
 			}
 		}
-		parse();
 	}
 
 	public void save() {
@@ -131,12 +141,13 @@ public final class JadxDecompiler {
 	}
 
 	private void save(boolean saveSources, boolean saveResources) {
+		ExecutorService ex = getSaveExecutor(saveSources, saveResources);
+		ex.shutdown();
 		try {
-			ExecutorService ex = getSaveExecutor(saveSources, saveResources);
-			ex.shutdown();
 			ex.awaitTermination(1, TimeUnit.DAYS);
 		} catch (InterruptedException e) {
-			throw new JadxRuntimeException("Save interrupted", e);
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
 		}
 	}
 
@@ -153,44 +164,57 @@ public final class JadxDecompiler {
 
 		LOG.info("processing ...");
 		ExecutorService executor = Executors.newFixedThreadPool(threadsCount);
+
+		File sourcesOutDir;
+		File resOutDir;
+		if (args.isExportAsGradleProject()) {
+			ExportGradleProject export = new ExportGradleProject(root, args.getOutDir());
+			export.init();
+			sourcesOutDir = export.getSrcOutDir();
+			resOutDir = export.getResOutDir();
+		} else {
+			sourcesOutDir = args.getOutDirSrc();
+			resOutDir = args.getOutDirRes();
+		}
 		if (saveSources) {
-			for (final JavaClass cls : getClasses()) {
-				executor.execute(new Runnable() {
-					@Override
-					public void run() {
-						cls.decompile();
-						SaveCode.save(outDir, args, cls.getClassNode());
-					}
-				});
-			}
+			appendSourcesSave(executor, sourcesOutDir);
 		}
 		if (saveResources) {
-			for (final ResourceFile resourceFile : getResources()) {
-				executor.execute(new Runnable() {
-					@Override
-					public void run() {
-						if (ResourceType.isSupportedForUnpack(resourceFile.getType())) {
-							CodeWriter cw = resourceFile.getContent();
-							if (cw != null) {
-								cw.save(new File(outDir, resourceFile.getName()));
-							}
-						}
-					}
-				});
-			}
+			appendResourcesSave(executor, resOutDir);
 		}
 		return executor;
 	}
 
+	private void appendResourcesSave(ExecutorService executor, File outDir) {
+		for (ResourceFile resourceFile : getResources()) {
+			executor.execute(new ResourcesSaver(outDir, resourceFile));
+		}
+	}
+
+	private void appendSourcesSave(ExecutorService executor, File outDir) {
+		for (JavaClass cls : getClasses()) {
+			if (cls.getClassNode().contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			executor.execute(() -> {
+				cls.decompile();
+				SaveCode.save(outDir, args, cls.getClassNode());
+			});
+		}
+	}
+
 	public List<JavaClass> getClasses() {
 		if (root == null) {
 			return Collections.emptyList();
 		}
 		if (classes == null) {
 			List<ClassNode> classNodeList = root.getClasses(false);
-			List<JavaClass> clsList = new ArrayList<JavaClass>(classNodeList.size());
+			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
+			classesMap.clear();
 			for (ClassNode classNode : classNodeList) {
-				clsList.add(new JavaClass(classNode, this));
+				JavaClass javaClass = new JavaClass(classNode, this);
+				clsList.add(javaClass);
+				classesMap.put(classNode, javaClass);
 			}
 			classes = Collections.unmodifiableList(clsList);
 		}
@@ -212,28 +236,19 @@ public final class JadxDecompiler {
 		if (classList.isEmpty()) {
 			return Collections.emptyList();
 		}
-		Map<String, List<JavaClass>> map = new HashMap<String, List<JavaClass>>();
+		Map<String, List<JavaClass>> map = new HashMap<>();
 		for (JavaClass javaClass : classList) {
 			String pkg = javaClass.getPackage();
-			List<JavaClass> clsList = map.get(pkg);
-			if (clsList == null) {
-				clsList = new ArrayList<JavaClass>();
-				map.put(pkg, clsList);
-			}
+			List<JavaClass> clsList = map.computeIfAbsent(pkg, k -> new ArrayList<>());
 			clsList.add(javaClass);
 		}
-		List<JavaPackage> packages = new ArrayList<JavaPackage>(map.size());
+		List<JavaPackage> packages = new ArrayList<>(map.size());
 		for (Map.Entry<String, List<JavaClass>> entry : map.entrySet()) {
 			packages.add(new JavaPackage(entry.getKey(), entry.getValue()));
 		}
 		Collections.sort(packages);
 		for (JavaPackage pkg : packages) {
-			Collections.sort(pkg.getClasses(), new Comparator<JavaClass>() {
-				@Override
-				public int compare(JavaClass o1, JavaClass o2) {
-					return o1.getName().compareTo(o2.getName());
-				}
-			});
+			pkg.getClasses().sort(Comparator.comparing(JavaClass::getName));
 		}
 		return Collections.unmodifiableList(packages);
 	}
@@ -249,24 +264,10 @@ public final class JadxDecompiler {
 		if (root == null) {
 			return;
 		}
+		root.getClsp().printMissingClasses();
 		root.getErrorsCounter().printReport();
 	}
 
-	void parse() throws DecodeException {
-		reset();
-		init();
-
-		root = new RootNode(args);
-		LOG.info("loading ...");
-		root.load(inputFiles);
-
-		root.initClassPath();
-		root.loadResources(getResources());
-		root.initAppResClass();
-
-		initVisitors();
-	}
-
 	private void initVisitors() {
 		for (IDexTreeVisitor pass : passes) {
 			try {
@@ -285,26 +286,26 @@ public final class JadxDecompiler {
 		return root;
 	}
 
-	BinaryXMLParser getXmlParser() {
+	synchronized BinaryXMLParser getXmlParser() {
 		if (xmlParser == null) {
 			xmlParser = new BinaryXMLParser(root);
 		}
 		return xmlParser;
 	}
 
-	JavaClass findJavaClass(ClassNode cls) {
-		if (cls == null) {
-			return null;
-		}
-		for (JavaClass javaClass : getClasses()) {
-			if (javaClass.getClassNode().equals(cls)) {
-				return javaClass;
-			}
-		}
-		return null;
+	Map<ClassNode, JavaClass> getClassesMap() {
+		return classesMap;
 	}
 
-	public IJadxArgs getArgs() {
+	Map<MethodNode, JavaMethod> getMethodsMap() {
+		return methodsMap;
+	}
+
+	Map<FieldNode, JavaField> getFieldsMap() {
+		return fieldsMap;
+	}
+
+	public JadxArgs getArgs() {
 		return args;
 	}
 

jadx-core/src/main/java/jadx/api/JavaClass.java

@@ -11,9 +11,12 @@ import jadx.core.dex.nodes.MethodNode;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import org.jetbrains.annotations.Nullable;
+
 public final class JavaClass implements JavaNode {
 
 	private final JadxDecompiler decompiler;
@@ -44,14 +47,14 @@ public final class JavaClass implements JavaNode {
 		if (code == null) {
 			decompile();
 			code = cls.getCode();
+			if (code == null) {
+				return "";
+			}
 		}
-		if (code == null) {
-			return "";
-		}
-		return code.toString();
+		return code.getCodeStr();
 	}
 
-	public void decompile() {
+	public synchronized void decompile() {
 		if (decompiler == null) {
 			return;
 		}
@@ -66,14 +69,16 @@ public final class JavaClass implements JavaNode {
 	}
 
 	private void load() {
+		JadxDecompiler rootDecompiler = getRootDecompiler();
 		int inClsCount = cls.getInnerClasses().size();
 		if (inClsCount != 0) {
-			List<JavaClass> list = new ArrayList<JavaClass>(inClsCount);
+			List<JavaClass> list = new ArrayList<>(inClsCount);
 			for (ClassNode inner : cls.getInnerClasses()) {
 				if (!inner.contains(AFlag.DONT_GENERATE)) {
 					JavaClass javaClass = new JavaClass(inner, this);
 					javaClass.load();
 					list.add(javaClass);
+					rootDecompiler.getClassesMap().put(inner, javaClass);
 				}
 			}
 			this.innerClasses = Collections.unmodifiableList(list);
@@ -81,10 +86,12 @@ public final class JavaClass implements JavaNode {
 
 		int fieldsCount = cls.getFields().size();
 		if (fieldsCount != 0) {
-			List<JavaField> flds = new ArrayList<JavaField>(fieldsCount);
+			List<JavaField> flds = new ArrayList<>(fieldsCount);
 			for (FieldNode f : cls.getFields()) {
 				if (!f.contains(AFlag.DONT_GENERATE)) {
-					flds.add(new JavaField(f, this));
+					JavaField javaField = new JavaField(f, this);
+					flds.add(javaField);
+					rootDecompiler.getFieldsMap().put(f, javaField);
 				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
@@ -92,10 +99,12 @@ public final class JavaClass implements JavaNode {
 
 		int methodsCount = cls.getMethods().size();
 		if (methodsCount != 0) {
-			List<JavaMethod> mths = new ArrayList<JavaMethod>(methodsCount);
+			List<JavaMethod> mths = new ArrayList<>(methodsCount);
 			for (MethodNode m : cls.getMethods()) {
 				if (!m.contains(AFlag.DONT_GENERATE)) {
-					mths.add(new JavaMethod(this, m));
+					JavaMethod javaMethod = new JavaMethod(this, m);
+					mths.add(javaMethod);
+					rootDecompiler.getMethodsMap().put(m, javaMethod);
 				}
 			}
 			Collections.sort(mths, new Comparator<JavaMethod>() {
@@ -108,38 +117,81 @@ public final class JavaClass implements JavaNode {
 		}
 	}
 
+	private JadxDecompiler getRootDecompiler() {
+		if (parent != null) {
+			return parent.getRootDecompiler();
+		}
+		return decompiler;
+	}
+
 	private Map<CodePosition, Object> getCodeAnnotations() {
 		decompile();
 		return cls.getCode().getAnnotations();
 	}
 
-	public CodePosition getDefinitionPosition(int line, int offset) {
+	public Map<CodePosition, JavaNode> getUsageMap() {
+		Map<CodePosition, Object> map = getCodeAnnotations();
+		if (map.isEmpty() || decompiler == null) {
+			return Collections.emptyMap();
+		}
+		Map<CodePosition, JavaNode> resultMap = new HashMap<>(map.size());
+		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
+			CodePosition codePosition = entry.getKey();
+			Object obj = entry.getValue();
+			if (obj instanceof LineAttrNode) {
+				JavaNode node = convertNode(obj);
+				if (node != null) {
+					resultMap.put(codePosition, node);
+				}
+			}
+		}
+		return resultMap;
+	}
+
+	@Nullable
+	private JavaNode convertNode(Object obj) {
+		if (!(obj instanceof LineAttrNode)) {
+			return null;
+		}
+		if (obj instanceof ClassNode) {
+			return getRootDecompiler().getClassesMap().get(obj);
+		}
+		if (obj instanceof MethodNode) {
+			return getRootDecompiler().getMethodsMap().get(obj);
+		}
+		if (obj instanceof FieldNode) {
+			return getRootDecompiler().getFieldsMap().get(obj);
+		}
+		return null;
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeAtPosition(int line, int offset) {
 		Map<CodePosition, Object> map = getCodeAnnotations();
 		if (map.isEmpty()) {
 			return null;
 		}
 		Object obj = map.get(new CodePosition(line, offset));
-		if (!(obj instanceof LineAttrNode)) {
+		if (obj == null) {
 			return null;
 		}
-		ClassNode clsNode = null;
-		if (obj instanceof ClassNode) {
-			clsNode = (ClassNode) obj;
-		} else if (obj instanceof MethodNode) {
-			clsNode = ((MethodNode) obj).getParentClass();
-		} else if (obj instanceof FieldNode) {
-			clsNode = ((FieldNode) obj).getParentClass();
-		}
-		if (clsNode == null) {
-			return null;
-		}
-		clsNode = clsNode.getTopParentClass();
-		JavaClass jCls = decompiler.findJavaClass(clsNode);
-		if (jCls == null) {
+		return convertNode(obj);
+	}
+
+	@Nullable
+	public CodePosition getDefinitionPosition(int line, int offset) {
+		JavaNode javaNode = getJavaNodeAtPosition(line, offset);
+		if (javaNode == null) {
 			return null;
 		}
+		return getDefinitionPosition(javaNode);
+	}
+
+	@Nullable
+	public CodePosition getDefinitionPosition(JavaNode javaNode) {
+		JavaClass jCls = javaNode.getTopParentClass();
 		jCls.decompile();
-		int defLine = ((LineAttrNode) obj).getDecompiledLine();
+		int defLine = javaNode.getDecompiledLine();
 		if (defLine == 0) {
 			return null;
 		}
@@ -170,6 +222,11 @@ public final class JavaClass implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent == null ? this : parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessInfo() {
 		return cls.getAccessFlags();
 	}

jadx-core/src/main/java/jadx/api/JavaField.java

@@ -29,6 +29,11 @@ public final class JavaField implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessFlags() {
 		return field.getAccessFlags();
 	}
@@ -40,4 +45,19 @@ public final class JavaField implements JavaNode {
 	public int getDecompiledLine() {
 		return field.getDecompiledLine();
 	}
+
+	@Override
+	public int hashCode() {
+		return field.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaField && field.equals(((JavaField) o).field);
+	}
+
+	@Override
+	public String toString() {
+		return field.toString();
+	}
 }

jadx-core/src/main/java/jadx/api/JavaMethod.java

@@ -30,6 +30,11 @@ public final class JavaMethod implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessFlags() {
 		return mth.getAccessFlags();
 	}
@@ -53,4 +58,19 @@ public final class JavaMethod implements JavaNode {
 	public int getDecompiledLine() {
 		return mth.getDecompiledLine();
 	}
+
+	@Override
+	public int hashCode() {
+		return mth.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaMethod && mth.equals(((JavaMethod) o).mth);
+	}
+
+	@Override
+	public String toString() {
+		return mth.toString();
+	}
 }

jadx-core/src/main/java/jadx/api/JavaNode.java

@@ -7,4 +7,8 @@ public interface JavaNode {
 	String getFullName();
 
 	JavaClass getDeclaringClass();
+
+	JavaClass getTopParentClass();
+
+	int getDecompiledLine();
 }

jadx-core/src/main/java/jadx/api/JavaPackage.java

@@ -33,6 +33,16 @@ public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 		return null;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return null;
+	}
+
+	@Override
+	public int getDecompiledLine() {
+		return 0;
+	}
+
 	@Override
 	public int compareTo(@NotNull JavaPackage o) {
 		return name.compareTo(o.name);

jadx-core/src/main/java/jadx/api/ResourceFile.java

@@ -1,6 +1,7 @@
 package jadx.api;
 
-import jadx.core.codegen.CodeWriter;
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
 
 import java.io.File;
 
@@ -34,7 +35,7 @@ public class ResourceFile {
 	private final ResourceType type;
 	private ZipRef zipRef;
 
-	ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+	protected ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
 		this.decompiler = decompiler;
 		this.name = name;
 		this.type = type;
@@ -48,7 +49,7 @@ public class ResourceFile {
 		return type;
 	}
 
-	public CodeWriter getContent() {
+	public ResContainer loadContent() {
 		return ResourcesLoader.loadContent(decompiler, this);
 	}
 
@@ -56,7 +57,7 @@ public class ResourceFile {
 		this.zipRef = zipRef;
 	}
 
-	ZipRef getZipRef() {
+	public ZipRef getZipRef() {
 		return zipRef;
 	}
 
@@ -64,4 +65,11 @@ public class ResourceFile {
 	public String toString() {
 		return "ResourceFile{name='" + name + '\'' + ", type=" + type + "}";
 	}
+	
+	public static ResourceFile createResourceFileInstance(JadxDecompiler decompiler, String name, ResourceType type) {
+		if(!ZipSecurity.isValidZipEntryName(name)) {
+			return null;
+		}
+		return new ResourceFile(decompiler, name, type);
+	}
 }

jadx-core/src/main/java/jadx/api/ResourceFileContent.java

@@ -0,0 +1,27 @@
+package jadx.api;
+
+import jadx.core.codegen.CodeWriter;
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+
+public class ResourceFileContent extends ResourceFile {
+
+	private final CodeWriter content;
+
+	private ResourceFileContent(String name, ResourceType type, CodeWriter content) {
+		super(null, name, type);
+		this.content = content;
+	}
+
+	@Override
+	public ResContainer loadContent() {
+		return ResContainer.singleFile(getName(), content);
+	}
+	
+	public static ResourceFileContent createResourceFileContentInstance(String name, ResourceType type, CodeWriter content) {
+		if(!ZipSecurity.isValidZipEntryName(name)) {
+			return null;
+		}
+		return new ResourceFileContent(name, type, content);
+	}
+}

jadx-core/src/main/java/jadx/api/ResourceType.java

@@ -1,10 +1,10 @@
 package jadx.api;
 
 public enum ResourceType {
-	CODE(".dex", ".class"),
+	CODE(".dex", ".jar", ".class"),
 	MANIFEST("AndroidManifest.xml"),
-	XML(".xml"), // TODO binary or not?
-	ARSC(".arsc"), // TODO decompile !!!
+	XML(".xml"),
+	ARSC(".arsc"),
 	FONT(".ttf"),
 	IMG(".png", ".gif", ".jpg"),
 	LIB(".so"),
@@ -34,15 +34,15 @@ public enum ResourceType {
 	public static boolean isSupportedForUnpack(ResourceType type) {
 		switch (type) {
 			case CODE:
-			case ARSC:
 			case LIB:
 			case FONT:
-			case IMG:
 			case UNKNOWN:
 				return false;
 
 			case MANIFEST:
 			case XML:
+			case ARSC:
+			case IMG:
 				return true;
 		}
 		return false;

jadx-core/src/main/java/jadx/api/ResourcesLoader.java

@@ -1,15 +1,9 @@
 package jadx.api;
 
-import jadx.api.ResourceFile.ZipRef;
-import jadx.core.codegen.CodeWriter;
-import jadx.core.utils.Utils;
-import jadx.core.utils.exceptions.JadxException;
-import jadx.core.utils.files.InputFile;
-import jadx.core.xmlgen.ResTableParser;
-
 import java.io.BufferedInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
@@ -21,11 +15,22 @@ import java.util.zip.ZipFile;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.ResourceFile.ZipRef;
+import jadx.core.codegen.CodeWriter;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.InputFile;
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.ResTableParser;
+
+import static jadx.core.utils.files.FileUtils.READ_BUFFER_SIZE;
+import static jadx.core.utils.files.FileUtils.copyStream;
+
 // TODO: move to core package
 public final class ResourcesLoader {
 	private static final Logger LOG = LoggerFactory.getLogger(ResourcesLoader.class);
 
-	private static final int READ_BUFFER_SIZE = 8 * 1024;
 	private static final int LOAD_SIZE_LIMIT = 10 * 1024 * 1024;
 
 	private final JadxDecompiler jadxRef;
@@ -35,7 +40,7 @@ public final class ResourcesLoader {
 	}
 
 	List<ResourceFile> load(List<InputFile> inputFiles) {
-		List<ResourceFile> list = new ArrayList<ResourceFile>(inputFiles.size());
+		List<ResourceFile> list = new ArrayList<>(inputFiles.size());
 		for (InputFile file : inputFiles) {
 			loadFile(list, file.getFile());
 		}
@@ -43,96 +48,95 @@ public final class ResourcesLoader {
 	}
 
 	public interface ResourceDecoder {
-		Object decode(long size, InputStream is) throws IOException;
+		ResContainer decode(long size, InputStream is) throws IOException;
 	}
 
-	public static Object decodeStream(ResourceFile rf, ResourceDecoder decoder) throws JadxException {
-		ZipRef zipRef = rf.getZipRef();
-		if (zipRef == null) {
-			return null;
-		}
-		ZipFile zipFile = null;
-		InputStream inputStream = null;
+	public static ResContainer decodeStream(ResourceFile rf, ResourceDecoder decoder) throws JadxException {
 		try {
-			zipFile = new ZipFile(zipRef.getZipFile());
-			ZipEntry entry = zipFile.getEntry(zipRef.getEntryName());
-			if (entry == null) {
-				throw new IOException("Zip entry not found: " + zipRef);
-			}
-			inputStream = new BufferedInputStream(zipFile.getInputStream(entry));
-			return decoder.decode(entry.getSize(), inputStream);
-		} catch (Exception e) {
-			throw new JadxException("Error decode: " + zipRef.getEntryName(), e);
-		} finally {
-			try {
-				if (zipFile != null) {
-					zipFile.close();
+			ZipRef zipRef = rf.getZipRef();
+			if (zipRef == null) {
+				File file = new File(rf.getName());
+				try (InputStream inputStream = new BufferedInputStream(new FileInputStream(file))) {
+					return decoder.decode(file.length(), inputStream);
 				}
-				if (inputStream != null) {
-					inputStream.close();
-				}
-			} catch (Exception e) {
-				LOG.debug("Error close zip file: {}", zipRef, e);
-			}
-		}
-	}
-
-	static CodeWriter loadContent(final JadxDecompiler jadxRef, final ResourceFile rf) {
-		try {
-			return (CodeWriter) decodeStream(rf, new ResourceDecoder() {
-				@Override
-				public Object decode(long size, InputStream is) throws IOException {
-					if (size > LOAD_SIZE_LIMIT) {
-						return new CodeWriter().add("File too big, size: "
-								+ String.format("%.2f KB", size / 1024.));
+			} else {
+				try (ZipFile zipFile = new ZipFile(zipRef.getZipFile())) {
+					ZipEntry entry = zipFile.getEntry(zipRef.getEntryName());
+					if (entry == null) {
+						throw new IOException("Zip entry not found: " + zipRef);
+					}
+					if (!ZipSecurity.isValidZipEntry(entry)) {
+						return null;
+					}
+					try (InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(entry))) {
+						return decoder.decode(entry.getSize(), inputStream);
 					}
-					return loadContent(jadxRef, rf.getType(), is);
 				}
-			});
+			}
+		} catch (Exception e) {
+			throw new JadxException("Error decode: " + rf.getName(), e);
+		}
+	}
+
+	static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf) {
+		try {
+			return decodeStream(rf, (size, is) -> loadContent(jadxRef, rf, is, size));
 		} catch (JadxException e) {
 			LOG.error("Decode error", e);
 			CodeWriter cw = new CodeWriter();
 			cw.add("Error decode ").add(rf.getType().toString().toLowerCase());
 			cw.startLine(Utils.getStackTrace(e.getCause()));
-			return cw;
+			return ResContainer.singleFile(rf.getName(), cw);
 		}
 	}
 
-	private static CodeWriter loadContent(JadxDecompiler jadxRef, ResourceType type,
-			InputStream inputStream) throws IOException {
-		switch (type) {
+	private static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf,
+	                                        InputStream inputStream, long size) throws IOException {
+		switch (rf.getType()) {
 			case MANIFEST:
 			case XML:
-				return jadxRef.getXmlParser().parse(inputStream);
+				return ResContainer.singleFile(rf.getName(),
+						jadxRef.getXmlParser().parse(inputStream));
 
 			case ARSC:
-				return new ResTableParser().decodeToCodeWriter(inputStream);
+				return new ResTableParser().decodeFiles(inputStream);
+
+			case IMG:
+				return ResContainer.singleImageFile(rf.getName(), inputStream);
+
+			default:
+				if (size > LOAD_SIZE_LIMIT) {
+					return ResContainer.singleFile(rf.getName(),
+							new CodeWriter().add("File too big, size: " + String.format("%.2f KB", size / 1024.)));
+				}
+				return ResContainer.singleFile(rf.getName(), loadToCodeWriter(inputStream));
 		}
-		return loadToCodeWriter(inputStream);
 	}
 
 	private void loadFile(List<ResourceFile> list, File file) {
 		if (file == null) {
 			return;
 		}
-		ZipFile zip = null;
-		try {
-			zip = new ZipFile(file);
+		try (ZipFile zip = new ZipFile(file)) {
 			Enumeration<? extends ZipEntry> entries = zip.entries();
 			while (entries.hasMoreElements()) {
 				ZipEntry entry = entries.nextElement();
-				addEntry(list, file, entry);
-			}
-		} catch (IOException e) {
-			LOG.debug("Not a zip file: {}", file.getAbsolutePath());
-		} finally {
-			if (zip != null) {
-				try {
-					zip.close();
-				} catch (Exception e) {
-					LOG.error("Zip file close error: {}", file.getAbsolutePath(), e);
+				if (ZipSecurity.isValidZipEntry(entry)) {
+					addEntry(list, file, entry);
 				}
 			}
+		} catch (Exception e) {
+			LOG.debug("Not a zip file: {}", file.getAbsolutePath());
+			addResourceFile(list, file);
+		}
+	}
+
+	private void addResourceFile(List<ResourceFile> list, File file) {
+		String name = file.getAbsolutePath();
+		ResourceType type = ResourceType.getFileType(name);
+		ResourceFile rf = ResourceFile.createResourceFileInstance(jadxRef, name, type);
+		if (rf != null) {
+			list.add(rf);
 		}
 	}
 
@@ -142,27 +146,17 @@ public final class ResourcesLoader {
 		}
 		String name = entry.getName();
 		ResourceType type = ResourceType.getFileType(name);
-		ResourceFile rf = new ResourceFile(jadxRef, name, type);
-		rf.setZipRef(new ZipRef(zipFile, name));
-		list.add(rf);
-		// LOG.debug("Add resource entry: {}, size: {}", name, entry.getSize());
+		ResourceFile rf = ResourceFile.createResourceFileInstance(jadxRef, name, type);
+		if (rf != null) {
+			rf.setZipRef(new ZipRef(zipFile, name));
+			list.add(rf);
+		}
 	}
 
-	private static CodeWriter loadToCodeWriter(InputStream is) throws IOException {
+	public static CodeWriter loadToCodeWriter(InputStream is) throws IOException {
 		CodeWriter cw = new CodeWriter();
 		ByteArrayOutputStream baos = new ByteArrayOutputStream(READ_BUFFER_SIZE);
-		byte[] buffer = new byte[READ_BUFFER_SIZE];
-		int count;
-		try {
-			while ((count = is.read(buffer)) != -1) {
-				baos.write(buffer, 0, count);
-			}
-		} finally {
-			try {
-				is.close();
-			} catch (Exception ignore) {
-			}
-		}
+		copyStream(is, baos);
 		cw.add(baos.toString("UTF-8"));
 		return cw;
 	}

jadx-core/src/main/java/jadx/core/Consts.java

@@ -21,4 +21,7 @@ public class Consts {
 	public static final String ANONYMOUS_CLASS_PREFIX = "AnonymousClass";
 
 	public static final String MTH_TOSTRING_SIGNATURE = "toString()Ljava/lang/String;";
+
+	private Consts() {
+	}
 }

jadx-core/src/main/java/jadx/core/Jadx.java

@@ -1,6 +1,15 @@
 package jadx.core;
 
-import jadx.api.IJadxArgs;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.jar.Manifest;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
 import jadx.core.dex.visitors.ClassModifier;
 import jadx.core.dex.visitors.CodeShrinker;
 import jadx.core.dex.visitors.ConstInlineVisitor;
@@ -8,6 +17,7 @@ import jadx.core.dex.visitors.DebugInfoVisitor;
 import jadx.core.dex.visitors.DependencyCollector;
 import jadx.core.dex.visitors.DotGraphVisitor;
 import jadx.core.dex.visitors.EnumVisitor;
+import jadx.core.dex.visitors.ExtractFieldInit;
 import jadx.core.dex.visitors.FallbackModeVisitor;
 import jadx.core.dex.visitors.IDexTreeVisitor;
 import jadx.core.dex.visitors.MethodInlineVisitor;
@@ -31,32 +41,21 @@ import jadx.core.dex.visitors.ssa.EliminatePhiNodes;
 import jadx.core.dex.visitors.ssa.SSATransform;
 import jadx.core.dex.visitors.typeinference.FinishTypeInference;
 import jadx.core.dex.visitors.typeinference.TypeInference;
-import jadx.core.utils.Utils;
-
-import java.io.File;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.jar.Manifest;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class Jadx {
 	private static final Logger LOG = LoggerFactory.getLogger(Jadx.class);
 
+	private Jadx() {
+	}
+
 	static {
 		if (Consts.DEBUG) {
 			LOG.info("debug enabled");
 		}
-		if (Jadx.class.desiredAssertionStatus()) {
-			LOG.info("assertions enabled");
-		}
 	}
 
-	public static List<IDexTreeVisitor> getPassesList(IJadxArgs args, File outDir) {
-		List<IDexTreeVisitor> passes = new ArrayList<IDexTreeVisitor>();
+	public static List<IDexTreeVisitor> getPassesList(JadxArgs args) {
+		List<IDexTreeVisitor> passes = new ArrayList<>();
 		if (args.isFallbackMode()) {
 			passes.add(new FallbackModeVisitor());
 		} else {
@@ -71,7 +70,7 @@ public class Jadx {
 			passes.add(new TypeInference());
 
 			if (args.isRawCFGOutput()) {
-				passes.add(DotGraphVisitor.dumpRaw(outDir));
+				passes.add(DotGraphVisitor.dumpRaw());
 			}
 
 			passes.add(new ConstInlineVisitor());
@@ -83,8 +82,8 @@ public class Jadx {
 			passes.add(new CodeShrinker());
 			passes.add(new ReSugarCode());
 
-			if (args.isCFGOutput()) {
-				passes.add(DotGraphVisitor.dump(outDir));
+			if (args.isCfgOutput()) {
+				passes.add(DotGraphVisitor.dump());
 			}
 
 			passes.add(new RegionMakerVisitor());
@@ -95,11 +94,12 @@ public class Jadx {
 			passes.add(new SimplifyVisitor());
 			passes.add(new CheckRegions());
 
-			if (args.isCFGOutput()) {
-				passes.add(DotGraphVisitor.dumpRegions(outDir));
+			if (args.isCfgOutput()) {
+				passes.add(DotGraphVisitor.dumpRegions());
 			}
 
 			passes.add(new MethodInlineVisitor());
+			passes.add(new ExtractFieldInit());
 			passes.add(new ClassModifier());
 			passes.add(new EnumVisitor());
 			passes.add(new PrepareForCodeGen());
@@ -115,7 +115,7 @@ public class Jadx {
 
 	public static String getVersion() {
 		try {
-			ClassLoader classLoader = Utils.class.getClassLoader();
+			ClassLoader classLoader = Jadx.class.getClassLoader();
 			if (classLoader != null) {
 				Enumeration<URL> resources = classLoader.getResources("META-INF/MANIFEST.MF");
 				while (resources.hasMoreElements()) {

jadx-core/src/main/java/jadx/core/ProcessClass.java

@@ -9,8 +9,6 @@ import jadx.core.utils.ErrorsCounter;
 import java.util.List;
 
 import org.jetbrains.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import static jadx.core.dex.nodes.ProcessState.GENERATED;
 import static jadx.core.dex.nodes.ProcessState.NOT_LOADED;
@@ -19,7 +17,6 @@ import static jadx.core.dex.nodes.ProcessState.STARTED;
 import static jadx.core.dex.nodes.ProcessState.UNLOADED;
 
 public final class ProcessClass {
-	private static final Logger LOG = LoggerFactory.getLogger(ProcessClass.class);
 
 	private ProcessClass() {
 	}
@@ -28,7 +25,7 @@ public final class ProcessClass {
 		if (codeGen == null && cls.getState() == PROCESSED) {
 			return;
 		}
-		synchronized (cls) {
+		synchronized (cls.getClassInfo()) {
 			try {
 				if (cls.getState() == NOT_LOADED) {
 					cls.load();
@@ -54,7 +51,7 @@ public final class ProcessClass {
 		}
 	}
 
-	static void processDependencies(ClassNode cls, List<IDexTreeVisitor> passes) {
+	private static void processDependencies(ClassNode cls, List<IDexTreeVisitor> passes) {
 		for (ClassNode depCls : cls.getDependencies()) {
 			process(depCls, passes, null);
 		}

jadx-core/src/main/java/jadx/core/clsp/ClsSet.java

@@ -6,6 +6,7 @@ import jadx.core.dex.nodes.RootNode;
 import jadx.core.utils.exceptions.DecodeException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 import jadx.core.utils.files.FileUtils;
+import jadx.core.utils.files.ZipSecurity;
 
 import java.io.BufferedOutputStream;
 import java.io.DataInputStream;
@@ -27,6 +28,8 @@ import java.util.zip.ZipOutputStream;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static jadx.core.utils.files.FileUtils.close;
+
 /**
  * Classes list for import into classpath graph
  */
@@ -46,7 +49,7 @@ public class ClsSet {
 
 	public void load(RootNode root) {
 		List<ClassNode> list = root.getClasses(true);
-		Map<String, NClass> names = new HashMap<String, NClass>(list.size());
+		Map<String, NClass> names = new HashMap<>(list.size());
 		int k = 0;
 		for (ClassNode cls : list) {
 			String clsRawName = cls.getRawName();
@@ -76,7 +79,7 @@ public class ClsSet {
 	}
 
 	public static NClass[] makeParentsArray(ClassNode cls, Map<String, NClass> names) {
-		List<NClass> parents = new ArrayList<NClass>(1 + cls.getInterfaces().size());
+		List<NClass> parents = new ArrayList<>(1 + cls.getInterfaces().size());
 		ArgType superClass = cls.getSuperClass();
 		if (superClass != null) {
 			NClass c = getCls(superClass.getObject(), names);
@@ -103,9 +106,7 @@ public class ClsSet {
 
 	void save(File output) throws IOException {
 		FileUtils.makeDirsForFile(output);
-
-		BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(output));
-		try {
+		try (BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(output))) {
 			String outputName = output.getName();
 			if (outputName.endsWith(CLST_EXTENSION)) {
 				save(outputStream);
@@ -115,19 +116,16 @@ public class ClsSet {
 					out.putNextEntry(new ZipEntry(CLST_PKG_PATH + "/" + CLST_FILENAME));
 					save(out);
 				} finally {
-					out.close();
+					close(out);
 				}
 			} else {
 				throw new JadxRuntimeException("Unknown file format: " + outputName);
 			}
-		} finally {
-			outputStream.close();
 		}
 	}
 
 	public void save(OutputStream output) throws IOException {
-		DataOutputStream out = new DataOutputStream(output);
-		try {
+		try (DataOutputStream out = new DataOutputStream(output)) {
 			out.writeBytes(JADX_CLS_SET_HEADER);
 			out.writeByte(VERSION);
 
@@ -143,53 +141,41 @@ public class ClsSet {
 					out.writeInt(parent.getId());
 				}
 			}
-		} finally {
-			out.close();
 		}
 	}
 
 	public void load() throws IOException, DecodeException {
-		InputStream input = getClass().getResourceAsStream(CLST_FILENAME);
-		if (input == null) {
-			throw new JadxRuntimeException("Can't load classpath file: " + CLST_FILENAME);
-		}
-		try {
+		try (InputStream input = getClass().getResourceAsStream(CLST_FILENAME)) {
+			if (input == null) {
+				throw new JadxRuntimeException("Can't load classpath file: " + CLST_FILENAME);
+			}
 			load(input);
-		} finally {
-			input.close();
 		}
 	}
 
 	public void load(File input) throws IOException, DecodeException {
 		String name = input.getName();
-		InputStream inputStream = new FileInputStream(input);
-		try {
+		try (InputStream inputStream = new FileInputStream(input)) {
 			if (name.endsWith(CLST_EXTENSION)) {
 				load(inputStream);
 			} else if (name.endsWith(".jar")) {
-				ZipInputStream in = new ZipInputStream(inputStream);
-				try {
+				try (ZipInputStream in = new ZipInputStream(inputStream)) {
 					ZipEntry entry = in.getNextEntry();
 					while (entry != null) {
-						if (entry.getName().endsWith(CLST_EXTENSION)) {
+						if (entry.getName().endsWith(CLST_EXTENSION) && ZipSecurity.isValidZipEntry(entry)) {
 							load(in);
 						}
 						entry = in.getNextEntry();
 					}
-				} finally {
-					in.close();
 				}
 			} else {
 				throw new JadxRuntimeException("Unknown file format: " + name);
 			}
-		} finally {
-			inputStream.close();
 		}
 	}
 
 	public void load(InputStream input) throws IOException, DecodeException {
-		DataInputStream in = new DataInputStream(input);
-		try {
+		try (DataInputStream in = new DataInputStream(input)) {
 			byte[] header = new byte[JADX_CLS_SET_HEADER.length()];
 			int readHeaderLength = in.read(header);
 			int version = in.readByte();
@@ -212,8 +198,6 @@ public class ClsSet {
 				}
 				classes[i].setParents(parents);
 			}
-		} finally {
-			in.close();
 		}
 	}
 

jadx-core/src/main/java/jadx/core/clsp/ClspGraph.java

@@ -5,6 +5,7 @@ import jadx.core.utils.exceptions.DecodeException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -22,9 +23,11 @@ import org.slf4j.LoggerFactory;
 public class ClspGraph {
 	private static final Logger LOG = LoggerFactory.getLogger(ClspGraph.class);
 
-	private final Map<String, Set<String>> ancestorCache = new WeakHashMap<String, Set<String>>();
+	private final Map<String, Set<String>> ancestorCache = Collections.synchronizedMap(new WeakHashMap<String, Set<String>>());
 	private Map<String, NClass> nameMap;
 
+	private final Set<String> missingClasses = new HashSet<>();
+
 	public void load() throws IOException, DecodeException {
 		ClsSet set = new ClsSet();
 		set.load();
@@ -33,7 +36,7 @@ public class ClspGraph {
 
 	public void addClasspath(ClsSet set) {
 		if (nameMap == null) {
-			nameMap = new HashMap<String, NClass>(set.getClassesCount());
+			nameMap = new HashMap<>(set.getClassesCount());
 			set.addToMap(nameMap);
 		} else {
 			throw new JadxRuntimeException("Classpath already loaded");
@@ -73,7 +76,7 @@ public class ClspGraph {
 		}
 		NClass cls = nameMap.get(implClsName);
 		if (cls == null) {
-			LOG.debug("Missing class: {}", implClsName);
+			missingClasses.add(clsName);
 			return null;
 		}
 		if (isImplements(clsName, implClsName)) {
@@ -104,10 +107,10 @@ public class ClspGraph {
 		}
 		NClass cls = nameMap.get(clsName);
 		if (cls == null) {
-			LOG.debug("Missing class: {}", clsName);
+			missingClasses.add(clsName);
 			return Collections.emptySet();
 		}
-		result = new HashSet<String>();
+		result = new HashSet<>();
 		addAncestorsNames(cls, result);
 		if (result.isEmpty()) {
 			result = Collections.emptySet();
@@ -122,4 +125,19 @@ public class ClspGraph {
 			addAncestorsNames(p, result);
 		}
 	}
+
+	public void printMissingClasses() {
+		int count = missingClasses.size();
+		if (count == 0) {
+			return;
+		}
+		LOG.warn("Found {} references to unknown classes", count);
+		if (LOG.isDebugEnabled()) {
+			List<String> clsNames = new ArrayList<>(missingClasses);
+			Collections.sort(clsNames);
+			for (String cls : clsNames) {
+				LOG.debug("  {}", cls);
+			}
+		}
+	}
 }

jadx-core/src/main/java/jadx/core/clsp/ConvertToClsSet.java

@@ -1,6 +1,6 @@
 package jadx.core.clsp;
 
-import jadx.api.DefaultJadxArgs;
+import jadx.api.JadxArgs;
 import jadx.core.dex.nodes.RootNode;
 import jadx.core.utils.exceptions.DecodeException;
 import jadx.core.utils.files.InputFile;
@@ -30,20 +30,20 @@ public class ConvertToClsSet {
 		}
 		File output = new File(args[0]);
 
-		List<InputFile> inputFiles = new ArrayList<InputFile>(args.length - 1);
+		List<InputFile> inputFiles = new ArrayList<>(args.length - 1);
 		for (int i = 1; i < args.length; i++) {
 			File f = new File(args[i]);
 			if (f.isDirectory()) {
 				addFilesFromDirectory(f, inputFiles);
 			} else {
-				inputFiles.add(new InputFile(f));
+				InputFile.addFilesFrom(f, inputFiles);
 			}
 		}
 		for (InputFile inputFile : inputFiles) {
 			LOG.info("Loaded: {}", inputFile.getFile());
 		}
 
-		RootNode root = new RootNode(new DefaultJadxArgs());
+		RootNode root = new RootNode(new JadxArgs());
 		root.load(inputFiles);
 
 		ClsSet set = new ClsSet();
@@ -53,8 +53,7 @@ public class ConvertToClsSet {
 		LOG.info("done");
 	}
 
-	private static void addFilesFromDirectory(File dir,
-			List<InputFile> inputFiles) throws IOException, DecodeException {
+	private static void addFilesFromDirectory(File dir, List<InputFile> inputFiles) {
 		File[] files = dir.listFiles();
 		if (files == null) {
 			return;
@@ -62,14 +61,13 @@ public class ConvertToClsSet {
 		for (File file : files) {
 			if (file.isDirectory()) {
 				addFilesFromDirectory(file, inputFiles);
-			}
-			String fileName = file.getName();
-			if (fileName.endsWith(".dex")
-					|| fileName.endsWith(".jar")
-					|| fileName.endsWith(".apk")) {
-				inputFiles.add(new InputFile(file));
+			} else {
+				try {
+					InputFile.addFilesFrom(file, inputFiles);
+				} catch (Exception e) {
+					LOG.warn("Skip file: {}, load error: {}", file, e.getMessage());
+				}
 			}
 		}
 	}
-
 }

jadx-core/src/main/java/jadx/core/codegen/AnnotationGen.java

@@ -130,11 +130,11 @@ public class AnnotationGen {
 			return;
 		}
 		if (val instanceof String) {
-			code.add(StringUtils.unescapeString((String) val));
+			code.add(getStringUtils().unescapeString((String) val));
 		} else if (val instanceof Integer) {
 			code.add(TypeGen.formatInteger((Integer) val));
 		} else if (val instanceof Character) {
-			code.add(StringUtils.unescapeChar((Character) val));
+			code.add(getStringUtils().unescapeChar((Character) val));
 		} else if (val instanceof Boolean) {
 			code.add(Boolean.TRUE.equals(val) ? "true" : "false");
 		} else if (val instanceof Float) {
@@ -172,4 +172,8 @@ public class AnnotationGen {
 			throw new JadxRuntimeException("Can't decode value: " + val + " (" + val.getClass() + ")");
 		}
 	}
+
+	private StringUtils getStringUtils() {
+		return cls.dex().root().getStringUtils();
+	}
 }

jadx-core/src/main/java/jadx/core/codegen/ClassGen.java

@@ -1,26 +1,5 @@
 package jadx.core.codegen;
 
-import jadx.api.IJadxArgs;
-import jadx.core.dex.attributes.AFlag;
-import jadx.core.dex.attributes.AType;
-import jadx.core.dex.attributes.AttrNode;
-import jadx.core.dex.attributes.nodes.EnumClassAttr;
-import jadx.core.dex.attributes.nodes.EnumClassAttr.EnumField;
-import jadx.core.dex.attributes.nodes.SourceFileAttr;
-import jadx.core.dex.info.AccessInfo;
-import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.instructions.args.PrimitiveType;
-import jadx.core.dex.instructions.mods.ConstructorInsn;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.DexNode;
-import jadx.core.dex.nodes.FieldNode;
-import jadx.core.dex.nodes.MethodNode;
-import jadx.core.dex.nodes.parser.FieldValueAttr;
-import jadx.core.utils.ErrorsCounter;
-import jadx.core.utils.Utils;
-import jadx.core.utils.exceptions.CodegenException;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -31,42 +10,57 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.android.dx.rop.code.AccessFlags;
 
-public class ClassGen {
-	private static final Logger LOG = LoggerFactory.getLogger(ClassGen.class);
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.AttrNode;
+import jadx.core.dex.attributes.nodes.EnumClassAttr;
+import jadx.core.dex.attributes.nodes.EnumClassAttr.EnumField;
+import jadx.core.dex.attributes.nodes.LineAttrNode;
+import jadx.core.dex.attributes.nodes.SourceFileAttr;
+import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.PrimitiveType;
+import jadx.core.dex.instructions.mods.ConstructorInsn;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.DexNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.InsnNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
+import jadx.core.dex.nodes.parser.FieldInitAttr.InitType;
+import jadx.core.utils.ErrorsCounter;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.CodegenException;
 
-	public static final Comparator<MethodNode> METHOD_LINE_COMPARATOR = new Comparator<MethodNode>() {
-		@Override
-		public int compare(MethodNode a, MethodNode b) {
-			return Utils.compare(a.getSourceLine(), b.getSourceLine());
-		}
-	};
+public class ClassGen {
 
 	private final ClassNode cls;
 	private final ClassGen parentGen;
 	private final AnnotationGen annotationGen;
 	private final boolean fallback;
+	private final boolean useImports;
 	private final boolean showInconsistentCode;
 
-	private final Set<ClassInfo> imports = new HashSet<ClassInfo>();
+	private final Set<ClassInfo> imports = new HashSet<>();
 	private int clsDeclLine;
 
-	public ClassGen(ClassNode cls, IJadxArgs jadxArgs) {
-		this(cls, null, jadxArgs.isFallbackMode(), jadxArgs.isShowInconsistentCode());
+	public ClassGen(ClassNode cls, JadxArgs jadxArgs) {
+		this(cls, null, jadxArgs.isUseImports(), jadxArgs.isFallbackMode(), jadxArgs.isShowInconsistentCode());
 	}
 
 	public ClassGen(ClassNode cls, ClassGen parentClsGen) {
-		this(cls, parentClsGen, parentClsGen.fallback, parentClsGen.showInconsistentCode);
+		this(cls, parentClsGen, parentClsGen.useImports, parentClsGen.fallback, parentClsGen.showInconsistentCode);
 	}
 
-	public ClassGen(ClassNode cls, ClassGen parentClsGen, boolean fallback, boolean showBadCode) {
+	public ClassGen(ClassNode cls, ClassGen parentClsGen, boolean useImports, boolean fallback, boolean showBadCode) {
 		this.cls = cls;
 		this.parentGen = parentClsGen;
 		this.fallback = fallback;
+		this.useImports = useImports;
 		this.showInconsistentCode = showBadCode;
 
 		this.annotationGen = new AnnotationGen(cls, this);
@@ -87,7 +81,7 @@ public class ClassGen {
 		}
 		int importsCount = imports.size();
 		if (importsCount != 0) {
-			List<String> sortImports = new ArrayList<String>(importsCount);
+			List<String> sortImports = new ArrayList<>(importsCount);
 			for (ClassInfo ic : imports) {
 				sortImports.add(ic.getAlias().getFullName());
 			}
@@ -146,6 +140,7 @@ public class ClassGen {
 		} else {
 			clsCode.add("class ");
 		}
+		clsCode.attachDefinition(cls);
 		clsCode.add(cls.getShortName());
 
 		addGenericMap(clsCode, cls.getGenericMap());
@@ -177,7 +172,6 @@ public class ClassGen {
 				clsCode.add(' ');
 			}
 		}
-		clsCode.attachDefinition(cls);
 	}
 
 	public boolean addGenericMap(CodeWriter code, Map<ArgType, List<ArgType>> gmap) {
@@ -262,15 +256,17 @@ public class ClassGen {
 			try {
 				addMethod(code, mth);
 			} catch (Exception e) {
-				String msg = ErrorsCounter.methodError(mth, "Method generation error", e);
-				code.startLine("/* " + msg + CodeWriter.NL + Utils.getStackTrace(e) + " */");
+				code.newLine().add("/*");
+				code.newLine().add(ErrorsCounter.methodError(mth, "Method generation error", e));
+				code.newLine().add(Utils.getStackTrace(e));
+				code.newLine().add("*/");
 			}
 		}
 	}
 
 	private static List<MethodNode> sortMethodsByLine(List<MethodNode> methods) {
-		List<MethodNode> out = new ArrayList<MethodNode>(methods);
-		Collections.sort(out, METHOD_LINE_COMPARATOR);
+		List<MethodNode> out = new ArrayList<>(methods);
+		out.sort(Comparator.comparingInt(LineAttrNode::getSourceLine));
 		return out;
 	}
 
@@ -335,21 +331,30 @@ public class ClassGen {
 				continue;
 			}
 			annotationGen.addForField(code, f);
+
+			if (f.getFieldInfo().isRenamed()) {
+				code.startLine("/* renamed from: ").add(f.getName()).add(" */");
+			}
 			code.startLine(f.getAccessFlags().makeString());
 			useType(code, f.getType());
 			code.add(' ');
+			code.attachDefinition(f);
 			code.add(f.getAlias());
-			FieldValueAttr fv = f.get(AType.FIELD_VALUE);
+			FieldInitAttr fv = f.get(AType.FIELD_INIT);
 			if (fv != null) {
 				code.add(" = ");
 				if (fv.getValue() == null) {
-					code.add(TypeGen.literalToString(0, f.getType()));
+					code.add(TypeGen.literalToString(0, f.getType(), cls));
 				} else {
-					annotationGen.encodeValue(code, fv.getValue());
+					if (fv.getValueType() == InitType.CONST) {
+						annotationGen.encodeValue(code, fv.getValue());
+					} else if (fv.getValueType() == InitType.INSN) {
+						InsnGen insnGen = makeInsnGen(fv.getInsnMth());
+						addInsnBody(insnGen, code, fv.getInsn());
+					}
 				}
 			}
 			code.add(';');
-			code.attachDefinition(f);
 		}
 	}
 
@@ -374,8 +379,7 @@ public class ClassGen {
 			ConstructorInsn constrInsn = f.getConstrInsn();
 			if (constrInsn.getArgsCount() > f.getStartArg()) {
 				if (igen == null) {
-					MethodGen mthGen = new MethodGen(this, enumFields.getStaticMethod());
-					igen = new InsnGen(mthGen, false);
+					igen = makeInsnGen(enumFields.getStaticMethod());
 				}
 				MethodNode callMth = cls.dex().resolveMethod(constrInsn.getCallMth());
 				igen.generateMethodArguments(code, constrInsn, f.getStartArg(), callMth);
@@ -399,6 +403,19 @@ public class ClassGen {
 		}
 	}
 
+	private InsnGen makeInsnGen(MethodNode mth) {
+		MethodGen mthGen = new MethodGen(this, mth);
+		return new InsnGen(mthGen, false);
+	}
+
+	private void addInsnBody(InsnGen insnGen, CodeWriter code, InsnNode insn) {
+		try {
+			insnGen.makeInsn(insn, code, InsnGen.Flags.BODY_ONLY_NOWRAP);
+		} catch (Exception e) {
+			ErrorsCounter.classError(cls, "Failed to generate init code", e);
+		}
+	}
+
 	public void useType(CodeWriter code, ArgType type) {
 		PrimitiveType stype = type.getPrimitiveType();
 		if (stype == null) {
@@ -455,7 +472,7 @@ public class ClassGen {
 
 	private String useClassInternal(ClassInfo useCls, ClassInfo extClsInfo) {
 		String fullName = extClsInfo.getFullName();
-		if (fallback) {
+		if (fallback || !useImports) {
 			return fullName;
 		}
 		String shortName = extClsInfo.getShortName();
@@ -480,6 +497,10 @@ public class ClassGen {
 		if (searchCollision(cls.dex(), useCls, extClsInfo)) {
 			return fullName;
 		}
+		// ignore classes from default package
+		if (extClsInfo.isDefaultPackage()) {
+			return shortName;
+		}
 		if (extClsInfo.getPackage().equals(useCls.getPackage())) {
 			fullName = extClsInfo.getNameWithoutPackage();
 		}
@@ -562,7 +583,7 @@ public class ClassGen {
 	private void insertRenameInfo(CodeWriter code, ClassNode cls) {
 		ClassInfo classInfo = cls.getClassInfo();
 		if (classInfo.isRenamed()) {
-			code.startLine("/* renamed from: ").add(classInfo.getFullName()).add(" */");
+			code.startLine("/* renamed from: ").add(classInfo.getType().getObject()).add(" */");
 		}
 	}
 

jadx-core/src/main/java/jadx/core/codegen/CodeGen.java

@@ -1,25 +1,17 @@
 package jadx.core.codegen;
 
-import jadx.api.IJadxArgs;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.visitors.AbstractVisitor;
 import jadx.core.utils.exceptions.CodegenException;
 
 public class CodeGen extends AbstractVisitor {
 
-	private final IJadxArgs args;
-
-	public CodeGen(IJadxArgs args) {
-		this.args = args;
-	}
-
 	@Override
 	public boolean visit(ClassNode cls) throws CodegenException {
-		ClassGen clsGen = new ClassGen(cls, args);
+		ClassGen clsGen = new ClassGen(cls, cls.root().getArgs());
 		CodeWriter clsCode = clsGen.makeClass();
 		clsCode.finish();
 		cls.setCode(clsCode);
 		return false;
 	}
-
 }

jadx-core/src/main/java/jadx/core/codegen/CodeWriter.java

@@ -3,6 +3,7 @@ package jadx.core.codegen;
 import jadx.api.CodePosition;
 import jadx.core.dex.attributes.nodes.LineAttrNode;
 import jadx.core.utils.files.FileUtils;
+import jadx.core.utils.files.ZipSecurity;
 
 import java.io.File;
 import java.io.PrintWriter;
@@ -12,28 +13,30 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.TreeMap;
 
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class CodeWriter {
 	private static final Logger LOG = LoggerFactory.getLogger(CodeWriter.class);
-	private static final int MAX_FILENAME_LENGTH = 128;
 
 	public static final String NL = System.getProperty("line.separator");
-	public static final String INDENT = "    ";
+	public static final String INDENT_STR = "    ";
 
 	private static final boolean ADD_LINE_NUMBERS = false;
 
 	private static final String[] INDENT_CACHE = {
 			"",
-			INDENT,
-			INDENT + INDENT,
-			INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT + INDENT,
+			INDENT_STR,
+			INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR,
 	};
 
-	private final StringBuilder buf = new StringBuilder();
+	private StringBuilder buf = new StringBuilder();
+	@Nullable
+	private String code;
 	private String indentStr;
 	private int indent;
 
@@ -113,7 +116,7 @@ public class CodeWriter {
 		}
 		line += code.line;
 		offset = code.offset;
-		buf.append(code);
+		buf.append(code.buf);
 		return this;
 	}
 
@@ -123,7 +126,7 @@ public class CodeWriter {
 	}
 
 	public CodeWriter addIndent() {
-		add(INDENT);
+		add(INDENT_STR);
 		return this;
 	}
 
@@ -144,9 +147,9 @@ public class CodeWriter {
 		if (curIndent < INDENT_CACHE.length) {
 			this.indentStr = INDENT_CACHE[curIndent];
 		} else {
-			StringBuilder s = new StringBuilder(curIndent * INDENT.length());
+			StringBuilder s = new StringBuilder(curIndent * INDENT_STR.length());
 			for (int i = 0; i < curIndent; i++) {
-				s.append(INDENT);
+				s.append(INDENT_STR);
 			}
 			this.indentStr = s.toString();
 		}
@@ -194,17 +197,18 @@ public class CodeWriter {
 		}
 	}
 
-	public Object attachDefinition(LineAttrNode obj) {
-		return attachAnnotation(new DefinitionWrapper(obj), new CodePosition(line, offset));
+	public void attachDefinition(LineAttrNode obj) {
+		attachAnnotation(obj);
+		attachAnnotation(new DefinitionWrapper(obj), new CodePosition(line, offset));
 	}
 
-	public Object attachAnnotation(Object obj) {
-		return attachAnnotation(obj, new CodePosition(line, offset + 1));
+	public void attachAnnotation(Object obj) {
+		attachAnnotation(obj, new CodePosition(line, offset + 1));
 	}
 
 	private Object attachAnnotation(Object obj, CodePosition pos) {
 		if (annotations.isEmpty()) {
-			annotations = new HashMap<CodePosition, Object>();
+			annotations = new HashMap<>();
 		}
 		return annotations.put(pos, obj);
 	}
@@ -222,7 +226,7 @@ public class CodeWriter {
 
 	private void attachSourceLine(int decompiledLine, int sourceLine) {
 		if (lineMap.isEmpty()) {
-			lineMap = new TreeMap<Integer, Integer>();
+			lineMap = new TreeMap<>();
 		}
 		lineMap.put(decompiledLine, sourceLine);
 	}
@@ -232,7 +236,11 @@ public class CodeWriter {
 	}
 
 	public void finish() {
+		removeFirstEmptyLine();
 		buf.trimToSize();
+		code = buf.toString();
+		buf = null;
+
 		Iterator<Map.Entry<CodePosition, Object>> it = annotations.entrySet().iterator();
 		while (it.hasNext()) {
 			Map.Entry<CodePosition, Object> entry = it.next();
@@ -245,81 +253,48 @@ public class CodeWriter {
 		}
 	}
 
-	private static String removeFirstEmptyLine(String str) {
-		if (str.startsWith(NL)) {
-			return str.substring(NL.length());
+	private void removeFirstEmptyLine() {
+		if (buf.indexOf(NL) == 0) {
+			buf.delete(0, NL.length());
 		}
-		return str;
 	}
 
-	public int length() {
+	public int bufLength() {
 		return buf.length();
 	}
 
-	public boolean isEmpty() {
-		return buf.length() == 0;
-	}
-
-	public boolean notEmpty() {
-		return buf.length() != 0;
+	public String getCodeStr() {
+		return code;
 	}
 
 	@Override
 	public String toString() {
-		return buf.toString();
+		return buf == null ? code : buf.toString();
 	}
 
 	public void save(File dir, String subDir, String fileName) {
+		if(!ZipSecurity.isValidZipEntryName(subDir) || !ZipSecurity.isValidZipEntryName(fileName)) {
+			return;
+		}
 		save(dir, new File(subDir, fileName).getPath());
 	}
 
 	public void save(File dir, String fileName) {
+		if(!ZipSecurity.isValidZipEntryName(fileName)) {
+			return;
+		}
 		save(new File(dir, fileName));
 	}
 
 	public void save(File file) {
-		String name = file.getName();
-		if (name.length() > MAX_FILENAME_LENGTH) {
-			int dotIndex = name.indexOf('.');
-			int cutAt = MAX_FILENAME_LENGTH - name.length() + dotIndex - 1;
-			if (cutAt <= 0) {
-				name = name.substring(0, MAX_FILENAME_LENGTH - 1);
-			} else {
-				name = name.substring(0, cutAt) + name.substring(dotIndex);
-			}
-			file = new File(file.getParentFile(), name);
+		if (code == null) {
+			finish();
 		}
-
-		PrintWriter out = null;
-		try {
-			FileUtils.makeDirsForFile(file);
-			out = new PrintWriter(file, "UTF-8");
-			String code = buf.toString();
-			code = removeFirstEmptyLine(code);
+		File outFile = FileUtils.prepareFile(file);
+		try (PrintWriter out = new PrintWriter(outFile, "UTF-8")) {
 			out.println(code);
 		} catch (Exception e) {
 			LOG.error("Save file error", e);
-		} finally {
-			if (out != null) {
-				out.close();
-			}
 		}
 	}
-
-	@Override
-	public int hashCode() {
-		return buf.toString().hashCode();
-	}
-
-	@Override
-	public boolean equals(Object o) {
-		if (this == o) {
-			return true;
-		}
-		if (!(o instanceof CodeWriter)) {
-			return false;
-		}
-		CodeWriter that = (CodeWriter) o;
-		return buf.toString().equals(that.buf.toString());
-	}
 }

jadx-core/src/main/java/jadx/core/codegen/ConditionGen.java

@@ -1,5 +1,12 @@
 package jadx.core.codegen;
 
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import jadx.core.dex.instructions.ArithNode;
 import jadx.core.dex.instructions.IfOp;
 import jadx.core.dex.instructions.InsnType;
@@ -15,18 +22,11 @@ import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Queue;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 public class ConditionGen extends InsnGen {
 	private static final Logger LOG = LoggerFactory.getLogger(ConditionGen.class);
 
 	private static class CondStack {
-		private final Queue<IfCondition> stack = new LinkedList<IfCondition>();
+		private final Queue<IfCondition> stack = new LinkedList<>();
 
 		public Queue<IfCondition> getStack() {
 			return stack;
@@ -126,7 +126,7 @@ public class ConditionGen extends InsnGen {
 				wrap(code, firstArg);
 				return;
 			}
-			LOG.warn(ErrorsCounter.formatErrorMsg(mth, "Unsupported boolean condition " + op.getSymbol()));
+			ErrorsCounter.methodError(mth, "Unsupported boolean condition " + op.getSymbol());
 		}
 
 		addArg(code, firstArg, isArgWrapNeeded(firstArg));
@@ -179,6 +179,9 @@ public class ConditionGen extends InsnGen {
 				case DIV:
 				case REM:
 					return false;
+
+				default:
+					return true;
 			}
 		} else {
 			switch (insnType) {
@@ -189,10 +192,10 @@ public class ConditionGen extends InsnGen {
 				case CONST:
 				case ARRAY_LENGTH:
 					return false;
+
 				default:
 					return true;
 			}
 		}
-		return true;
 	}
 }

jadx-core/src/main/java/jadx/core/codegen/InsnGen.java

@@ -36,24 +36,24 @@ import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.RegionUtils;
-import jadx.core.utils.StringUtils;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.EnumSet;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static jadx.core.utils.android.AndroidResourcesUtils.handleAppResField;
+
 public class InsnGen {
 	private static final Logger LOG = LoggerFactory.getLogger(InsnGen.class);
 
@@ -80,9 +80,9 @@ public class InsnGen {
 	}
 
 	public void addArgDot(CodeWriter code, InsnArg arg) throws CodegenException {
-		int len = code.length();
+		int len = code.bufLength();
 		addArg(code, arg, true);
-		if (len != code.length()) {
+		if (len != code.bufLength()) {
 			code.add('.');
 		}
 	}
@@ -123,13 +123,16 @@ public class InsnGen {
 	}
 
 	public void declareVar(CodeWriter code, RegisterArg arg) {
+		if (arg.getSVar().contains(AFlag.FINAL)) {
+			code.add("final ");
+		}
 		useType(code, arg.getType());
 		code.add(' ');
 		code.add(mgen.getNameGen().assignArg(arg));
 	}
 
-	private static String lit(LiteralArg arg) {
-		return TypeGen.literalToString(arg.getLiteral(), arg.getType());
+	private String lit(LiteralArg arg) {
+		return TypeGen.literalToString(arg.getLiteral(), arg.getType(), mth);
 	}
 
 	private void instanceField(CodeWriter code, FieldInfo field, InsnArg arg) throws CodegenException {
@@ -144,16 +147,19 @@ public class InsnGen {
 		if (fieldNode != null) {
 			FieldReplaceAttr replace = fieldNode.get(AType.FIELD_REPLACE);
 			if (replace != null) {
-				FieldInfo info = replace.getFieldInfo();
-				if (replace.isOuterClass()) {
-					useClass(code, info.getDeclClass());
-					code.add(".this");
+				switch (replace.getReplaceType()) {
+					case CLASS_INSTANCE:
+						useClass(code, replace.getClsRef());
+						code.add(".this");
+						break;
+					case VAR:
+						addArg(code, replace.getVarRef());
+						break;
 				}
 				return;
 			}
 		}
 		addArgDot(code, arg);
-		fieldNode = mth.dex().resolveField(field);
 		if (fieldNode != null) {
 			code.attachAnnotation(fieldNode);
 		}
@@ -165,12 +171,7 @@ public class InsnGen {
 		boolean fieldFromThisClass = clsGen.getClassNode().getClassInfo().equals(declClass);
 		if (!fieldFromThisClass) {
 			// Android specific resources class handler
-			ClassInfo parentClass = declClass.getParentClass();
-			if (parentClass != null && parentClass.getShortName().equals("R")) {
-				clsGen.useClass(code, parentClass);
-				code.add('.');
-				code.add(declClass.getAlias().getShortName());
-			} else {
+			if (!handleAppResField(code, clsGen, declClass)) {
 				clsGen.useClass(code, declClass);
 			}
 			code.add('.');
@@ -231,7 +232,7 @@ public class InsnGen {
 		switch (insn.getType()) {
 			case CONST_STR:
 				String str = ((ConstStringNode) insn).getString();
-				code.add(StringUtils.unescapeString(str));
+				code.add(mth.dex().root().getStringUtils().unescapeString(str));
 				break;
 
 			case CONST_CLASS:
@@ -269,18 +270,13 @@ public class InsnGen {
 				makeArith((ArithNode) insn, code, state);
 				break;
 
-			case NEG: {
-				boolean wrap = state.contains(Flags.BODY_ONLY);
-				if (wrap) {
-					code.add('(');
-				}
-				code.add('-');
-				addArg(code, insn.getArg(0));
-				if (wrap) {
-					code.add(')');
-				}
+			case NEG:
+				oneArgInsn(code, insn, state, '-');
+				break;
+
+			case NOT:
+				oneArgInsn(code, insn, state, '~');
 				break;
-			}
 
 			case RETURN:
 				if (insn.getArgsCount() != 0) {
@@ -445,7 +441,7 @@ public class InsnGen {
 
 			/* fallback mode instructions */
 			case IF:
-				assert isFallback() : "if insn in not fallback mode";
+				fallbackOnlyInsn(insn);
 				IfNode ifInsn = (IfNode) insn;
 				code.add("if (");
 				addArg(code, insn.getArg(0));
@@ -456,17 +452,17 @@ public class InsnGen {
 				break;
 
 			case GOTO:
-				assert isFallback();
+				fallbackOnlyInsn(insn);
 				code.add("goto ").add(MethodGen.getLabelName(((GotoNode) insn).getTarget()));
 				break;
 
 			case MOVE_EXCEPTION:
-				assert isFallback();
+				fallbackOnlyInsn(insn);
 				code.add("move-exception");
 				break;
 
 			case SWITCH:
-				assert isFallback();
+				fallbackOnlyInsn(insn);
 				SwitchNode sw = (SwitchNode) insn;
 				code.add("switch(");
 				addArg(code, insn.getArg(0));
@@ -484,7 +480,7 @@ public class InsnGen {
 				break;
 
 			case FILL_ARRAY:
-				assert isFallback();
+				fallbackOnlyInsn(insn);
 				FillArrayNode arrayNode = (FillArrayNode) insn;
 				Object data = arrayNode.getData();
 				String arrStr;
@@ -504,8 +500,19 @@ public class InsnGen {
 
 			case NEW_INSTANCE:
 				// only fallback - make new instance in constructor invoke
-				assert isFallback();
-				code.add("new " + insn.getResult().getType());
+				fallbackOnlyInsn(insn);
+				code.add("new ").add(insn.getResult().getType().toString());
+				break;
+
+			case PHI:
+			case MERGE:
+				fallbackOnlyInsn(insn);
+				code.add(insn.getType().toString()).add("(");
+				for (InsnArg insnArg : insn.getArguments()) {
+					addArg(code, insnArg);
+					code.add(' ');
+				}
+				code.add(")");
 				break;
 
 			default:
@@ -513,6 +520,24 @@ public class InsnGen {
 		}
 	}
 
+	private void oneArgInsn(CodeWriter code, InsnNode insn, Set<Flags> state, char op) throws CodegenException {
+		boolean wrap = state.contains(Flags.BODY_ONLY);
+		if (wrap) {
+			code.add('(');
+		}
+		code.add(op);
+		addArg(code, insn.getArg(0));
+		if (wrap) {
+			code.add(')');
+		}
+	}
+
+	private void fallbackOnlyInsn(InsnNode insn) throws CodegenException {
+		if (!fallback) {
+			throw new CodegenException(insn.getType() + " can be used only in fallback mode");
+		}
+	}
+
 	private void filledNewArray(FilledNewArrayNode insn, CodeWriter code) throws CodegenException {
 		code.add("new ");
 		useType(code, insn.getArrayType());
@@ -531,30 +556,7 @@ public class InsnGen {
 			throws CodegenException {
 		ClassNode cls = mth.dex().resolveClass(insn.getClassType());
 		if (cls != null && cls.contains(AFlag.ANONYMOUS_CLASS) && !fallback) {
-			// anonymous class construction
-			ArgType parent;
-			if (cls.getInterfaces().size() == 1) {
-				parent = cls.getInterfaces().get(0);
-			} else {
-				parent = cls.getSuperClass();
-			}
-			cls.add(AFlag.DONT_GENERATE);
-			MethodNode defCtr = cls.getDefaultConstructor();
-			if (defCtr != null) {
-				if (RegionUtils.notEmpty(defCtr.getRegion())) {
-					defCtr.add(AFlag.ANONYMOUS_CONSTRUCTOR);
-				} else {
-					defCtr.add(AFlag.DONT_GENERATE);
-				}
-			}
-			code.add("new ");
-			if (parent == null) {
-				code.add("Object");
-			} else {
-				useClass(code, parent);
-			}
-			code.add("() ");
-			new ClassGen(cls, mgen.getClassGen().getParentGen()).addClassBody(code);
+			inlineAnonymousConstr(code, cls, insn);
 			return;
 		}
 		if (insn.isSelf()) {
@@ -568,7 +570,42 @@ public class InsnGen {
 			code.add("new ");
 			useClass(code, insn.getClassType());
 		}
-		generateMethodArguments(code, insn, 0, mth.dex().resolveMethod(insn.getCallMth()));
+		MethodNode callMth = mth.dex().resolveMethod(insn.getCallMth());
+		generateMethodArguments(code, insn, 0, callMth);
+	}
+
+	private void inlineAnonymousConstr(CodeWriter code, ClassNode cls, ConstructorInsn insn) throws CodegenException {
+		// anonymous class construction
+		if (cls.contains(AFlag.DONT_GENERATE)) {
+			code.add("/* anonymous class already generated */");
+			ErrorsCounter.methodError(mth, "Anonymous class already generated: " + cls);
+			return;
+		}
+		ArgType parent;
+		if (cls.getInterfaces().size() == 1) {
+			parent = cls.getInterfaces().get(0);
+		} else {
+			parent = cls.getSuperClass();
+		}
+		cls.add(AFlag.DONT_GENERATE);
+		MethodNode defCtr = cls.getDefaultConstructor();
+		if (defCtr != null) {
+			if (RegionUtils.notEmpty(defCtr.getRegion())) {
+				defCtr.add(AFlag.ANONYMOUS_CONSTRUCTOR);
+			} else {
+				defCtr.add(AFlag.DONT_GENERATE);
+			}
+		}
+		code.add("new ");
+		if (parent == null) {
+			code.add("Object");
+		} else {
+			useClass(code, parent);
+		}
+		MethodNode callMth = mth.dex().resolveMethod(insn.getCallMth());
+		generateMethodArguments(code, insn, 0, callMth);
+		code.add(' ');
+		new ClassGen(cls, mgen.getClassGen().getParentGen()).addClassBody(code);
 	}
 
 	private void makeInvoke(InvokeNode insn, CodeWriter code) throws CodegenException {
@@ -627,23 +664,43 @@ public class InsnGen {
 		}
 		int argsCount = insn.getArgsCount();
 		code.add('(');
+		boolean firstArg = true;
 		if (k < argsCount) {
 			boolean overloaded = callMth != null && callMth.isArgsOverload();
 			for (int i = k; i < argsCount; i++) {
 				InsnArg arg = insn.getArg(i);
+				if (arg.contains(AFlag.SKIP_ARG)) {
+					continue;
+				}
+				RegisterArg callArg = getCallMthArg(callMth, i - startArgNum);
+				if (callArg != null && callArg.contains(AFlag.SKIP_ARG)) {
+					continue;
+				}
+				if (!firstArg) {
+					code.add(", ");
+				}
 				boolean cast = overloaded && processOverloadedArg(code, callMth, arg, i - startArgNum);
 				if (!cast && i == argsCount - 1 && processVarArg(code, callMth, arg)) {
 					continue;
 				}
 				addArg(code, arg, false);
-				if (i < argsCount - 1) {
-					code.add(", ");
-				}
+				firstArg = false;
 			}
 		}
 		code.add(')');
 	}
 
+	private static RegisterArg getCallMthArg(@Nullable MethodNode callMth, int num) {
+		if (callMth == null) {
+			return null;
+		}
+		List<RegisterArg> args = callMth.getArguments(false);
+		if (args != null && num < args.size()) {
+			return args.get(num);
+		}
+		return null;
+	}
+
 	/**
 	 * Add additional cast for overloaded method argument.
 	 */
@@ -701,9 +758,9 @@ public class InsnGen {
 				regs[callArg.getRegNum()] = arg;
 			}
 			// replace args
-			List<RegisterArg> inlArgs = new ArrayList<RegisterArg>();
-			inl.getRegisterArgs(inlArgs);
-			Map<RegisterArg, InsnArg> toRevert = new HashMap<RegisterArg, InsnArg>();
+			InsnNode inlCopy = inl.copy();
+			List<RegisterArg> inlArgs = new ArrayList<>();
+			inlCopy.getRegisterArgs(inlArgs);
 			for (RegisterArg r : inlArgs) {
 				int regNum = r.getRegNum();
 				if (regNum >= regs.length) {
@@ -713,16 +770,11 @@ public class InsnGen {
 					if (repl == null) {
 						LOG.warn("Not passed register {} in method call: {} from {}", r, callMthNode, mth);
 					} else {
-						inl.replaceArg(r, repl);
-						toRevert.put(r, repl);
+						inlCopy.replaceArg(r, repl);
 					}
 				}
 			}
-			makeInsn(inl, code, Flags.BODY_ONLY);
-			// revert changes in 'MethodInlineAttr'
-			for (Map.Entry<RegisterArg, InsnArg> e : toRevert.entrySet()) {
-				inl.replaceArg(e.getValue(), e.getKey());
-			}
+			makeInsn(inlCopy, code, Flags.BODY_ONLY);
 		}
 		return true;
 	}

jadx-core/src/main/java/jadx/core/codegen/MethodGen.java

@@ -8,6 +8,7 @@ import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.InsnType;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.RegisterArg;
+import jadx.core.dex.instructions.args.SSAVar;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.trycatch.CatchAttr;
@@ -56,8 +57,8 @@ public class MethodGen {
 
 	public boolean addDefinition(CodeWriter code) {
 		if (mth.getMethodInfo().isClassInit()) {
-			code.startLine("static");
 			code.attachDefinition(mth);
+			code.startLine("static");
 			return true;
 		}
 		if (mth.contains(AFlag.ANONYMOUS_CONSTRUCTOR)) {
@@ -79,6 +80,10 @@ public class MethodGen {
 		if (clsAccFlags.isAnnotation()) {
 			ai = ai.remove(AccessFlags.ACC_PUBLIC);
 		}
+
+		if (mth.getMethodInfo().isRenamed()) {
+			code.startLine("/* renamed from: ").add(mth.getName()).add(" */");
+		}
 		code.startLineWithNum(mth.getSourceLine());
 		code.add(ai.makeString());
 
@@ -86,10 +91,12 @@ public class MethodGen {
 			code.add(' ');
 		}
 		if (mth.getAccessFlags().isConstructor()) {
+			code.attachDefinition(mth);
 			code.add(classGen.getClassNode().getShortName()); // constructor
 		} else {
 			classGen.useType(code, mth.getReturnType());
 			code.add(' ');
+			code.attachDefinition(mth);
 			code.add(mth.getAlias());
 		}
 		code.add('(');
@@ -112,7 +119,6 @@ public class MethodGen {
 		code.add(')');
 
 		annotationGen.addThrows(mth, code);
-		code.attachDefinition(mth);
 		return true;
 	}
 
@@ -126,6 +132,10 @@ public class MethodGen {
 			if (paramsAnnotation != null) {
 				annotationGen.addForParameter(argsCode, paramsAnnotation, i);
 			}
+			SSAVar argSVar = arg.getSVar();
+			if (argSVar != null && argSVar.contains(AFlag.FINAL)) {
+				argsCode.add("final ");
+			}
 			if (!it.hasNext() && mth.getAccessFlags().isVarArgs()) {
 				// change last array argument to varargs
 				ArgType type = arg.getType();
@@ -161,7 +171,7 @@ public class MethodGen {
 				if (cause != null) {
 					code.newLine();
 					code.add("/*");
-					code.startLine("Error: ").add(Utils.getStackTrace(cause));
+					code.newLine().add("Error: ").add(Utils.getStackTrace(cause));
 					code.add("*/");
 				}
 			}
@@ -235,7 +245,7 @@ public class MethodGen {
 	 * Return fallback variant of method codegen
 	 */
 	public static MethodGen getFallbackMethodGen(MethodNode mth) {
-		ClassGen clsGen = new ClassGen(mth.getParentClass(), null, true, true);
+		ClassGen clsGen = new ClassGen(mth.getParentClass(), null, true, true, true);
 		return new MethodGen(clsGen, mth);
 	}
 

jadx-core/src/main/java/jadx/core/codegen/NameGen.java

@@ -26,12 +26,12 @@ public class NameGen {
 
 	private static final Map<String, String> OBJ_ALIAS;
 
-	private final Set<String> varNames = new HashSet<String>();
+	private final Set<String> varNames = new HashSet<>();
 	private final MethodNode mth;
 	private final boolean fallback;
 
 	static {
-		OBJ_ALIAS = new HashMap<String, String>();
+		OBJ_ALIAS = new HashMap<>();
 		OBJ_ALIAS.put(Consts.CLASS_STRING, "str");
 		OBJ_ALIAS.put(Consts.CLASS_CLASS, "cls");
 		OBJ_ALIAS.put(Consts.CLASS_THROWABLE, "th");
@@ -164,6 +164,9 @@ public class NameGen {
 			if (vName != null) {
 				return vName;
 			}
+			if (shortName != null) {
+				return StringUtils.escape(shortName.toLowerCase());
+			}
 		}
 		return StringUtils.escape(type.toString());
 	}

jadx-core/src/main/java/jadx/core/codegen/RegionGen.java

@@ -15,7 +15,7 @@ import jadx.core.dex.nodes.IBlock;
 import jadx.core.dex.nodes.IContainer;
 import jadx.core.dex.nodes.IRegion;
 import jadx.core.dex.nodes.InsnNode;
-import jadx.core.dex.nodes.parser.FieldValueAttr;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
 import jadx.core.dex.regions.Region;
 import jadx.core.dex.regions.SwitchRegion;
 import jadx.core.dex.regions.SynchronizedRegion;
@@ -207,11 +207,13 @@ public class RegionGen extends InsnGen {
 		if (region.isConditionAtEnd()) {
 			code.startLine("do {");
 			makeRegionIndent(code, region.getBody());
-			code.startLine("} while (");
+			code.startLineWithNum(region.getConditionSourceLine());
+			code.add("} while (");
 			conditionGen.add(code, condition);
 			code.add(");");
 		} else {
-			code.startLine("while (");
+			code.startLineWithNum(region.getConditionSourceLine());
+			code.add("while (");
 			conditionGen.add(code, condition);
 			code.add(") {");
 			makeRegionIndent(code, region.getBody());
@@ -249,13 +251,13 @@ public class RegionGen extends InsnGen {
 					} else {
 						staticField(code, fn.getFieldInfo());
 						// print original value, sometimes replace with incorrect field
-						FieldValueAttr valueAttr = fn.get(AType.FIELD_VALUE);
+						FieldInitAttr valueAttr = fn.get(AType.FIELD_INIT);
 						if (valueAttr != null && valueAttr.getValue() != null) {
 							code.add(" /*").add(valueAttr.getValue().toString()).add("*/");
 						}
 					}
 				} else if (k instanceof Integer) {
-					code.add(TypeGen.literalToString((Integer) k, arg.getType()));
+					code.add(TypeGen.literalToString((Integer) k, arg.getType(), mth));
 				} else {
 					throw new JadxRuntimeException("Unexpected key in switch: " + (k != null ? k.getClass() : null));
 				}

jadx-core/src/main/java/jadx/core/codegen/TypeGen.java

@@ -1,7 +1,9 @@
 package jadx.core.codegen;
 
+import jadx.api.JadxArgs;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.PrimitiveType;
+import jadx.core.dex.nodes.IDexNode;
 import jadx.core.utils.StringUtils;
 import jadx.core.utils.Utils;
 import jadx.core.utils.exceptions.JadxRuntimeException;
@@ -31,7 +33,16 @@ public class TypeGen {
 	 *
 	 * @throws JadxRuntimeException for incorrect type or literal value
 	 */
+	public static String literalToString(long lit, ArgType type, IDexNode dexNode) {
+		return literalToString(lit, type, dexNode.root().getStringUtils());
+	}
+
+	@Deprecated
 	public static String literalToString(long lit, ArgType type) {
+		return literalToString(lit, type, new StringUtils(new JadxArgs()));
+	}
+
+	private static String literalToString(long lit, ArgType type, StringUtils stringUtils) {
 		if (type == null || !type.isTypeKnown()) {
 			String n = Long.toString(lit);
 			if (Math.abs(lit) > 100) {
@@ -46,7 +57,7 @@ public class TypeGen {
 			case BOOLEAN:
 				return lit == 0 ? "false" : "true";
 			case CHAR:
-				return StringUtils.unescapeChar((char) lit);
+				return stringUtils.unescapeChar((char) lit);
 			case BYTE:
 				return formatByte((byte) lit);
 			case SHORT:

jadx-core/src/main/java/jadx/core/deobf/DeobfPresets.java

@@ -24,9 +24,9 @@ class DeobfPresets {
 	private final Deobfuscator deobfuscator;
 	private final File deobfMapFile;
 
-	private final Map<String, String> clsPresetMap = new HashMap<String, String>();
-	private final Map<String, String> fldPresetMap = new HashMap<String, String>();
-	private final Map<String, String> mthPresetMap = new HashMap<String, String>();
+	private final Map<String, String> clsPresetMap = new HashMap<>();
+	private final Map<String, String> fldPresetMap = new HashMap<>();
+	private final Map<String, String> mthPresetMap = new HashMap<>();
 
 	public DeobfPresets(Deobfuscator deobfuscator, File deobfMapFile) {
 		this.deobfuscator = deobfuscator;
@@ -98,7 +98,7 @@ class DeobfPresets {
 	 * Saves DefaultDeobfuscator presets
 	 */
 	private void dumpMapping() throws IOException {
-		List<String> list = new ArrayList<String>();
+		List<String> list = new ArrayList<>();
 		// packages
 		for (PackageNode p : deobfuscator.getRootPackage().getInnerPackages()) {
 			for (PackageNode pp : p.getInnerPackages()) {

jadx-core/src/main/java/jadx/core/deobf/Deobfuscator.java

@@ -1,18 +1,21 @@
 package jadx.core.deobf;
 
-import jadx.api.IJadxArgs;
+import jadx.api.JadxArgs;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.SourceFileAttr;
 import jadx.core.dex.info.ClassInfo;
 import jadx.core.dex.info.FieldInfo;
 import jadx.core.dex.info.MethodInfo;
+import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.DexNode;
 import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.MethodNode;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -31,31 +34,37 @@ public class Deobfuscator {
 	public static final String CLASS_NAME_SEPARATOR = ".";
 	public static final String INNER_CLASS_SEPARATOR = "$";
 
-	private final IJadxArgs args;
+	private final JadxArgs args;
 	@NotNull
 	private final List<DexNode> dexNodes;
 	private final DeobfPresets deobfPresets;
 
-	private final Map<ClassInfo, DeobfClsInfo> clsMap = new HashMap<ClassInfo, DeobfClsInfo>();
-	private final Map<FieldInfo, String> fldMap = new HashMap<FieldInfo, String>();
-	private final Map<MethodInfo, String> mthMap = new HashMap<MethodInfo, String>();
+	private final Map<ClassInfo, DeobfClsInfo> clsMap = new HashMap<>();
+	private final Map<FieldInfo, String> fldMap = new HashMap<>();
+	private final Map<MethodInfo, String> mthMap = new HashMap<>();
+
+	private final Map<MethodInfo, OverridedMethodsNode> ovrdMap = new HashMap<>();
+	private final List<OverridedMethodsNode> ovrd = new ArrayList<>();
 
 	private final PackageNode rootPackage = new PackageNode("");
-	private final Set<String> pkgSet = new TreeSet<String>();
+	private final Set<String> pkgSet = new TreeSet<>();
 
 	private final int maxLength;
 	private final int minLength;
+	private final boolean useSourceNameAsAlias;
+
 	private int pkgIndex = 0;
 	private int clsIndex = 0;
 	private int fldIndex = 0;
 	private int mthIndex = 0;
 
-	public Deobfuscator(IJadxArgs args, @NotNull List<DexNode> dexNodes, File deobfMapFile) {
+	public Deobfuscator(JadxArgs args, @NotNull List<DexNode> dexNodes, File deobfMapFile) {
 		this.args = args;
 		this.dexNodes = dexNodes;
 
 		this.minLength = args.getDeobfuscationMinLength();
 		this.maxLength = args.getDeobfuscationMaxLength();
+		this.useSourceNameAsAlias = args.isUseSourceNameAsClassAlias();
 
 		this.deobfPresets = new DeobfPresets(this, deobfMapFile);
 	}
@@ -95,6 +104,33 @@ public class Deobfuscator {
 				processClass(dexNode, cls);
 			}
 		}
+		postProcess();
+	}
+
+	private void postProcess() {
+		int id = 1;
+		for (OverridedMethodsNode o : ovrd) {
+			boolean aliasFromPreset = false;
+			String aliasToUse = null;
+			for (MethodInfo mth : o.getMethods()) {
+				if (mth.isAliasFromPreset()) {
+					aliasToUse = mth.getAlias();
+					aliasFromPreset = true;
+				}
+			}
+			for (MethodInfo mth : o.getMethods()) {
+				if (aliasToUse == null) {
+					if (mth.isRenamed() && !mth.isAliasFromPreset()) {
+						mth.setAlias(String.format("mo%d%s", id, makeName(mth.getName())));
+					}
+					aliasToUse = mth.getAlias();
+				}
+				mth.setAlias(aliasToUse);
+				mth.setAliasFromPreset(aliasFromPreset);
+			}
+
+			id++;
+		}
 	}
 
 	void clear() {
@@ -102,6 +138,94 @@ public class Deobfuscator {
 		clsMap.clear();
 		fldMap.clear();
 		mthMap.clear();
+
+		ovrd.clear();
+		ovrdMap.clear();
+	}
+
+	@Nullable
+	private static ClassNode resolveOverridingInternal(DexNode dex, ClassNode cls, String signature,
+			Set<MethodInfo> overrideSet, ClassNode rootClass) {
+		ClassNode result = null;
+
+		for (MethodNode m : cls.getMethods()) {
+			if (m.getMethodInfo().getShortId().startsWith(signature)) {
+				result = cls;
+				if (!overrideSet.contains(m.getMethodInfo())) {
+					overrideSet.add(m.getMethodInfo());
+				}
+				break;
+			}
+		}
+
+		ArgType superClass = cls.getSuperClass();
+		if (superClass != null) {
+			ClassNode superNode = dex.resolveClass(superClass);
+			if (superNode != null) {
+				ClassNode clsWithMth = resolveOverridingInternal(dex, superNode, signature, overrideSet, rootClass);
+				if (clsWithMth != null) {
+					if ((result != null) && (result != cls)) {
+						if (clsWithMth != result) {
+							LOG.warn(String.format("Multiple overriding '%s' from '%s' and '%s' in '%s'",
+									signature,
+									result.getFullName(), clsWithMth.getFullName(),
+									rootClass.getFullName()));
+						}
+					} else {
+						result = clsWithMth;
+					}
+				}
+			}
+		}
+
+		for (ArgType iFaceType : cls.getInterfaces()) {
+			ClassNode iFaceNode = dex.resolveClass(iFaceType);
+			if (iFaceNode != null) {
+				ClassNode clsWithMth = resolveOverridingInternal(dex, iFaceNode, signature, overrideSet, rootClass);
+				if (clsWithMth != null) {
+					if ((result != null) && (result != cls)) {
+						if (clsWithMth != result) {
+							LOG.warn(String.format("Multiple overriding '%s' from '%s' and '%s' in '%s'",
+									signature,
+									result.getFullName(), clsWithMth.getFullName(),
+									rootClass.getFullName()));
+						}
+					} else {
+						result = clsWithMth;
+					}
+				}
+			}
+		}
+
+		return result;
+	}
+
+	private void resolveOverriding(DexNode dex, ClassNode cls, MethodNode mth) {
+		Set<MethodInfo> overrideSet = new HashSet<>();
+		resolveOverridingInternal(dex, cls, mth.getMethodInfo().makeSignature(false), overrideSet, cls);
+		if (overrideSet.size() > 1) {
+			OverridedMethodsNode overrideNode = null;
+			for (MethodInfo _mth : overrideSet) {
+				if (ovrdMap.containsKey(_mth)) {
+					overrideNode = ovrdMap.get(_mth);
+					break;
+				}
+			}
+			if (overrideNode == null) {
+				overrideNode = new OverridedMethodsNode(overrideSet);
+				ovrd.add(overrideNode);
+			}
+			for (MethodInfo _mth : overrideSet) {
+				if (!ovrdMap.containsKey(_mth)) {
+					ovrdMap.put(_mth, overrideNode);
+					if (!overrideNode.contains(_mth)) {
+						overrideNode.add(_mth);
+					}
+				}
+			}
+		} else {
+			overrideSet.clear();
+		}
 	}
 
 	private void processClass(DexNode dex, ClassNode cls) {
@@ -123,6 +247,10 @@ public class Deobfuscator {
 			if (alias != null) {
 				methodInfo.setAlias(alias);
 			}
+
+			if (mth.isVirtual()) {
+				resolveOverriding(dex, cls, mth);
+			}
 		}
 	}
 
@@ -212,7 +340,12 @@ public class Deobfuscator {
 
 	private String makeClsAlias(ClassNode cls) {
 		ClassInfo classInfo = cls.getClassInfo();
-		String alias = getAliasFromSourceFile(cls);
+		String alias = null;
+
+		if (this.useSourceNameAsAlias) {
+			alias = getAliasFromSourceFile(cls);
+		}
+
 		if (alias == null) {
 			String clsName = classInfo.getShortName();
 			alias = String.format("C%04d%s", clsIndex++, makeName(clsName));
@@ -269,6 +402,7 @@ public class Deobfuscator {
 		alias = deobfPresets.getForMth(methodInfo);
 		if (alias != null) {
 			mthMap.put(methodInfo, alias);
+			methodInfo.setAliasFromPreset(true);
 			return alias;
 		}
 		if (shouldRename(mth.getName())) {
@@ -304,9 +438,9 @@ public class Deobfuscator {
 			parentPkg = parentPkg.getParentPackage();
 		}
 
-		final String pkgName = pkg.getName();
+		String pkgName = pkg.getName();
 		if (!pkg.hasAlias() && shouldRename(pkgName)) {
-			final String pkgAlias = String.format("p%03d%s", pkgIndex++, makeName(pkgName));
+			String pkgAlias = String.format("p%03d%s", pkgIndex++, makeName(pkgName));
 			pkg.setAlias(pkgAlias);
 		}
 	}
@@ -363,7 +497,7 @@ public class Deobfuscator {
 	}
 
 	private String getPackageName(String packageName) {
-		final PackageNode pkg = getPackageNode(packageName, false);
+		PackageNode pkg = getPackageNode(packageName, false);
 		if (pkg != null) {
 			return pkg.getFullAlias();
 		}
@@ -371,7 +505,7 @@ public class Deobfuscator {
 	}
 
 	private String getClassName(ClassInfo clsInfo) {
-		final DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
+		DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
 		if (deobfClsInfo != null) {
 			return deobfClsInfo.makeNameWithoutPkg();
 		}
@@ -383,7 +517,7 @@ public class Deobfuscator {
 	}
 
 	private String getClassFullName(ClassInfo clsInfo) {
-		final DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
+		DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
 		if (deobfClsInfo != null) {
 			return deobfClsInfo.getFullName();
 		}

jadx-core/src/main/java/jadx/core/deobf/NameMapper.java

@@ -13,8 +13,8 @@ public class NameMapper {
 	private static final Pattern VALID_JAVA_FULL_IDENTIFIER = Pattern.compile(
 			"(" + VALID_JAVA_IDENTIFIER + "\\.)*" + VALID_JAVA_IDENTIFIER);
 
-	private static final Set<String> RESERVED_NAMES = new HashSet<String>(
-			Arrays.asList(new String[]{
+	private static final Set<String> RESERVED_NAMES = new HashSet<>(
+			Arrays.asList(
 					"abstract",
 					"assert",
 					"boolean",
@@ -67,8 +67,8 @@ public class NameMapper {
 					"try",
 					"void",
 					"volatile",
-					"while",
-			})
+					"while"
+			)
 	);
 
 	public static boolean isReserved(String str) {
@@ -96,4 +96,7 @@ public class NameMapper {
 		}
 		return true;
 	}
+
+	private NameMapper() {
+	}
 }

jadx-core/src/main/java/jadx/core/deobf/OverridedMethodsNode.java

@@ -0,0 +1,26 @@
+package jadx.core.deobf;
+
+import jadx.core.dex.info.MethodInfo;
+
+import java.util.Set;
+
+/* package */ class OverridedMethodsNode {
+
+	private Set<MethodInfo> methods;
+
+	public OverridedMethodsNode(Set<MethodInfo> methodsSet) {
+		methods = methodsSet;
+	}
+
+	public boolean contains(MethodInfo mth) {
+		return methods.contains(mth);
+	}
+
+	public void add(MethodInfo mth) {
+		methods.add(mth);
+	}
+
+	public Set<MethodInfo> getMethods() {
+		return methods;
+	}
+}

jadx-core/src/main/java/jadx/core/deobf/PackageNode.java

@@ -1,9 +1,10 @@
 package jadx.core.deobf;
 
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Deque;
 import java.util.List;
-import java.util.Stack;
 
 public class PackageNode {
 
@@ -29,11 +30,11 @@ public class PackageNode {
 
 	public String getFullName() {
 		if (cachedPackageFullName == null) {
-			Stack<PackageNode> pp = getParentPackages();
+			Deque<PackageNode> pp = getParentPackages();
 
 			StringBuilder result = new StringBuilder();
 			result.append(pp.pop().getName());
-			while (pp.size() > 0) {
+			while (!pp.isEmpty()) {
 				result.append(SEPARATOR_CHAR);
 				result.append(pp.pop().getName());
 			}
@@ -59,12 +60,17 @@ public class PackageNode {
 
 	public String getFullAlias() {
 		if (cachedPackageFullAlias == null) {
-			Stack<PackageNode> pp = getParentPackages();
+			Deque<PackageNode> pp = getParentPackages();
 			StringBuilder result = new StringBuilder();
-			result.append(pp.pop().getAlias());
-			while (pp.size() > 0) {
-				result.append(SEPARATOR_CHAR);
+
+			if (!pp.isEmpty()) {
 				result.append(pp.pop().getAlias());
+				while (!pp.isEmpty()) {
+					result.append(SEPARATOR_CHAR);
+					result.append(pp.pop().getAlias());
+				}
+			} else {
+				result.append(this.getAlias());
 			}
 			cachedPackageFullAlias = result.toString();
 		}
@@ -81,7 +87,7 @@ public class PackageNode {
 
 	public void addInnerPackage(PackageNode pkg) {
 		if (innerPackages.isEmpty()) {
-			innerPackages = new ArrayList<PackageNode>();
+			innerPackages = new ArrayList<>();
 		}
 		innerPackages.add(pkg);
 		pkg.parentPackage = this;
@@ -109,16 +115,15 @@ public class PackageNode {
 	 *
 	 * @return stack with parent packages
 	 */
-	private Stack<PackageNode> getParentPackages() {
-		Stack<PackageNode> pp = new Stack<PackageNode>();
+	private Deque<PackageNode> getParentPackages() {
+		Deque<PackageNode> pp = new ArrayDeque<>();
 
-		PackageNode currentP = this;
-		PackageNode parentP = currentP.getParentPackage();
-
-		while (currentP != parentP) {
-			pp.push(currentP);
-			currentP = parentP;
-			parentP = currentP.getParentPackage();
+		PackageNode currentPkg = this;
+		PackageNode parentPkg = currentPkg.getParentPackage();
+		while (currentPkg != parentPkg) {
+			pp.push(currentPkg);
+			currentPkg = parentPkg;
+			parentPkg = currentPkg.getParentPackage();
 		}
 		return pp;
 	}

jadx-core/src/main/java/jadx/core/dex/attributes/AFlag.java

@@ -8,6 +8,7 @@ public enum AFlag {
 	LOOP_END,
 
 	SYNTHETIC,
+	FINAL, // SSAVar attribute for make var final
 
 	RETURN, // block contains only return instruction
 	ORIG_RETURN,
@@ -22,6 +23,7 @@ public enum AFlag {
 	REMOVE,
 
 	SKIP_FIRST_ARG,
+	SKIP_ARG, // skip argument in invoke call
 	ANONYMOUS_CONSTRUCTOR,
 	ANONYMOUS_CLASS,
 

jadx-core/src/main/java/jadx/core/dex/attributes/AType.java

@@ -3,6 +3,7 @@ package jadx.core.dex.attributes;
 import jadx.core.dex.attributes.annotations.AnnotationsList;
 import jadx.core.dex.attributes.annotations.MethodParameters;
 import jadx.core.dex.attributes.nodes.DeclareVariablesAttr;
+import jadx.core.dex.attributes.nodes.EdgeInsnAttr;
 import jadx.core.dex.attributes.nodes.EnumClassAttr;
 import jadx.core.dex.attributes.nodes.EnumMapAttr;
 import jadx.core.dex.attributes.nodes.FieldReplaceAttr;
@@ -15,7 +16,7 @@ import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.attributes.nodes.MethodInlineAttr;
 import jadx.core.dex.attributes.nodes.PhiListAttr;
 import jadx.core.dex.attributes.nodes.SourceFileAttr;
-import jadx.core.dex.nodes.parser.FieldValueAttr;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
 import jadx.core.dex.trycatch.CatchAttr;
 import jadx.core.dex.trycatch.ExcHandlerAttr;
 import jadx.core.dex.trycatch.SplitterBlockAttr;
@@ -28,24 +29,25 @@ import jadx.core.dex.trycatch.SplitterBlockAttr;
  */
 public class AType<T extends IAttribute> {
 
-	public static final AType<AttrList<JumpInfo>> JUMP = new AType<AttrList<JumpInfo>>();
-	public static final AType<AttrList<LoopInfo>> LOOP = new AType<AttrList<LoopInfo>>();
+	public static final AType<AttrList<JumpInfo>> JUMP = new AType<>();
+	public static final AType<AttrList<LoopInfo>> LOOP = new AType<>();
+	public static final AType<AttrList<EdgeInsnAttr>> EDGE_INSN = new AType<>();
 
-	public static final AType<ExcHandlerAttr> EXC_HANDLER = new AType<ExcHandlerAttr>();
-	public static final AType<CatchAttr> CATCH_BLOCK = new AType<CatchAttr>();
-	public static final AType<SplitterBlockAttr> SPLITTER_BLOCK = new AType<SplitterBlockAttr>();
-	public static final AType<ForceReturnAttr> FORCE_RETURN = new AType<ForceReturnAttr>();
-	public static final AType<FieldValueAttr> FIELD_VALUE = new AType<FieldValueAttr>();
-	public static final AType<FieldReplaceAttr> FIELD_REPLACE = new AType<FieldReplaceAttr>();
-	public static final AType<JadxErrorAttr> JADX_ERROR = new AType<JadxErrorAttr>();
-	public static final AType<MethodInlineAttr> METHOD_INLINE = new AType<MethodInlineAttr>();
-	public static final AType<EnumClassAttr> ENUM_CLASS = new AType<EnumClassAttr>();
-	public static final AType<EnumMapAttr> ENUM_MAP = new AType<EnumMapAttr>();
-	public static final AType<AnnotationsList> ANNOTATION_LIST = new AType<AnnotationsList>();
-	public static final AType<MethodParameters> ANNOTATION_MTH_PARAMETERS = new AType<MethodParameters>();
-	public static final AType<PhiListAttr> PHI_LIST = new AType<PhiListAttr>();
-	public static final AType<SourceFileAttr> SOURCE_FILE = new AType<SourceFileAttr>();
-	public static final AType<DeclareVariablesAttr> DECLARE_VARIABLES = new AType<DeclareVariablesAttr>();
-	public static final AType<LoopLabelAttr> LOOP_LABEL = new AType<LoopLabelAttr>();
-	public static final AType<IgnoreEdgeAttr> IGNORE_EDGE = new AType<IgnoreEdgeAttr>();
+	public static final AType<ExcHandlerAttr> EXC_HANDLER = new AType<>();
+	public static final AType<CatchAttr> CATCH_BLOCK = new AType<>();
+	public static final AType<SplitterBlockAttr> SPLITTER_BLOCK = new AType<>();
+	public static final AType<ForceReturnAttr> FORCE_RETURN = new AType<>();
+	public static final AType<FieldInitAttr> FIELD_INIT = new AType<>();
+	public static final AType<FieldReplaceAttr> FIELD_REPLACE = new AType<>();
+	public static final AType<JadxErrorAttr> JADX_ERROR = new AType<>();
+	public static final AType<MethodInlineAttr> METHOD_INLINE = new AType<>();
+	public static final AType<EnumClassAttr> ENUM_CLASS = new AType<>();
+	public static final AType<EnumMapAttr> ENUM_MAP = new AType<>();
+	public static final AType<AnnotationsList> ANNOTATION_LIST = new AType<>();
+	public static final AType<MethodParameters> ANNOTATION_MTH_PARAMETERS = new AType<>();
+	public static final AType<PhiListAttr> PHI_LIST = new AType<>();
+	public static final AType<SourceFileAttr> SOURCE_FILE = new AType<>();
+	public static final AType<DeclareVariablesAttr> DECLARE_VARIABLES = new AType<>();
+	public static final AType<LoopLabelAttr> LOOP_LABEL = new AType<>();
+	public static final AType<IgnoreEdgeAttr> IGNORE_EDGE = new AType<>();
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AttrList.java

@@ -8,7 +8,7 @@ import java.util.List;
 public class AttrList<T> implements IAttribute {
 
 	private final AType<AttrList<T>> type;
-	private final List<T> list = new LinkedList<T>();
+	private final List<T> list = new LinkedList<>();
 
 	public AttrList(AType<AttrList<T>> type) {
 		this.type = type;

jadx-core/src/main/java/jadx/core/dex/attributes/AttrNode.java

@@ -27,10 +27,13 @@ public abstract class AttrNode implements IAttributeNode {
 
 	@Override
 	public void copyAttributesFrom(AttrNode attrNode) {
-		initStorage().addAll(attrNode.storage);
+		AttributeStorage copyFrom = attrNode.storage;
+		if (!copyFrom.isEmpty()) {
+			initStorage().addAll(copyFrom);
+		}
 	}
 
-	AttributeStorage initStorage() {
+	private AttributeStorage initStorage() {
 		AttributeStorage store = storage;
 		if (store == EMPTY_ATTR_STORAGE) {
 			store = new AttributeStorage();

jadx-core/src/main/java/jadx/core/dex/attributes/AttributeStorage.java

@@ -24,7 +24,7 @@ public class AttributeStorage {
 
 	public AttributeStorage() {
 		flags = EnumSet.noneOf(AFlag.class);
-		attributes = new IdentityHashMap<AType<?>, IAttribute>();
+		attributes = new IdentityHashMap<>();
 	}
 
 	public void add(AFlag flag) {
@@ -38,7 +38,7 @@ public class AttributeStorage {
 	public <T> void add(AType<AttrList<T>> type, T obj) {
 		AttrList<T> list = get(type);
 		if (list == null) {
-			list = new AttrList<T>(type);
+			list = new AttrList<>(type);
 			add(list);
 		}
 		list.getList().add(obj);
@@ -84,7 +84,7 @@ public class AttributeStorage {
 	}
 
 	public void remove(IAttribute attr) {
-		AType<?> type = attr.getType();
+		AType<? extends IAttribute> type = attr.getType();
 		IAttribute a = attributes.get(type);
 		if (a == attr) {
 			attributes.remove(type);
@@ -101,7 +101,7 @@ public class AttributeStorage {
 		if (size == 0) {
 			return Collections.emptyList();
 		}
-		List<String> list = new ArrayList<String>(size);
+		List<String> list = new ArrayList<>(size);
 		for (AFlag a : flags) {
 			list.add(a.toString());
 		}
@@ -111,6 +111,10 @@ public class AttributeStorage {
 		return list;
 	}
 
+	public boolean isEmpty() {
+		return flags.isEmpty() && attributes.isEmpty();
+	}
+
 	@Override
 	public String toString() {
 		List<String> list = getAttributeStrings();

jadx-core/src/main/java/jadx/core/dex/attributes/EmptyAttrStorage.java

@@ -53,6 +53,11 @@ public final class EmptyAttrStorage extends AttributeStorage {
 		return Collections.emptyList();
 	}
 
+	@Override
+	public boolean isEmpty() {
+		return true;
+	}
+
 	@Override
 	public String toString() {
 		return "";

jadx-core/src/main/java/jadx/core/dex/attributes/IAttribute.java

@@ -1,7 +1,5 @@
 package jadx.core.dex.attributes;
 
 public interface IAttribute {
-
-	AType<?> getType();
-
+	AType<? extends IAttribute> getType();
 }

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/AnnotationsList.java

@@ -17,7 +17,7 @@ public class AnnotationsList implements IAttribute {
 	private final Map<String, Annotation> map;
 
 	public AnnotationsList(List<Annotation> anList) {
-		map = new HashMap<String, Annotation>(anList.size());
+		map = new HashMap<>(anList.size());
 		for (Annotation a : anList) {
 			map.put(a.getAnnotationClass(), a);
 		}

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/MethodParameters.java

@@ -12,7 +12,7 @@ public class MethodParameters implements IAttribute {
 	private final List<AnnotationsList> paramList;
 
 	public MethodParameters(int paramCount) {
-		paramList = new ArrayList<AnnotationsList>(paramCount);
+		paramList = new ArrayList<>(paramCount);
 	}
 
 	public List<AnnotationsList> getParamList() {

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/DeclareVariablesAttr.java

@@ -13,7 +13,7 @@ import java.util.List;
  */
 public class DeclareVariablesAttr implements IAttribute {
 
-	private final List<RegisterArg> vars = new LinkedList<RegisterArg>();
+	private final List<RegisterArg> vars = new LinkedList<>();
 
 	public Iterable<RegisterArg> getVars() {
 		return vars;

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EdgeInsnAttr.java

@@ -0,0 +1,48 @@
+package jadx.core.dex.attributes.nodes;
+
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.AttrList;
+import jadx.core.dex.attributes.IAttribute;
+import jadx.core.dex.nodes.BlockNode;
+import jadx.core.dex.nodes.InsnNode;
+
+public class EdgeInsnAttr implements IAttribute {
+
+	private final BlockNode start;
+	private final BlockNode end;
+	private final InsnNode insn;
+
+	public static void addEdgeInsn(BlockNode start, BlockNode end, InsnNode insn) {
+		EdgeInsnAttr edgeInsnAttr = new EdgeInsnAttr(start, end, insn);
+		start.addAttr(AType.EDGE_INSN, edgeInsnAttr);
+		end.addAttr(AType.EDGE_INSN, edgeInsnAttr);
+	}
+
+	public EdgeInsnAttr(BlockNode start, BlockNode end, InsnNode insn) {
+		this.start = start;
+		this.end = end;
+		this.insn = insn;
+	}
+
+	@Override
+	public AType<AttrList<EdgeInsnAttr>> getType() {
+		return AType.EDGE_INSN;
+	}
+
+	public BlockNode getStart() {
+		return start;
+	}
+
+	public BlockNode getEnd() {
+		return end;
+	}
+
+	public InsnNode getInsn() {
+		return insn;
+	}
+
+	@Override
+	public String toString() {
+		return "EDGE_INSN: " + start + "->" + end + " " + insn;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EnumClassAttr.java

@@ -54,7 +54,7 @@ public class EnumClassAttr implements IAttribute {
 	private MethodNode staticMethod;
 
 	public EnumClassAttr(int fieldsCount) {
-		this.fields = new ArrayList<EnumField>(fieldsCount);
+		this.fields = new ArrayList<>(fieldsCount);
 	}
 
 	public List<EnumField> getFields() {

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EnumMapAttr.java

@@ -10,7 +10,7 @@ import java.util.Map;
 public class EnumMapAttr implements IAttribute {
 
 	public static class KeyValueMap {
-		private final Map<Object, Object> map = new HashMap<Object, Object>();
+		private final Map<Object, Object> map = new HashMap<>();
 
 		public Object get(Object key) {
 			return map.get(key);
@@ -21,7 +21,7 @@ public class EnumMapAttr implements IAttribute {
 		}
 	}
 
-	private final Map<FieldNode, KeyValueMap> fieldsMap = new HashMap<FieldNode, KeyValueMap>();
+	private final Map<FieldNode, KeyValueMap> fieldsMap = new HashMap<>();
 
 	public KeyValueMap getMap(FieldNode field) {
 		return fieldsMap.get(field);

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/FieldReplaceAttr.java

@@ -2,24 +2,39 @@ package jadx.core.dex.attributes.nodes;
 
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
-import jadx.core.dex.info.FieldInfo;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.instructions.args.InsnArg;
 
 public class FieldReplaceAttr implements IAttribute {
 
-	private final FieldInfo fieldInfo;
-	private final boolean isOuterClass;
-
-	public FieldReplaceAttr(FieldInfo fieldInfo, boolean isOuterClass) {
-		this.fieldInfo = fieldInfo;
-		this.isOuterClass = isOuterClass;
+	public enum ReplaceWith {
+		CLASS_INSTANCE,
+		VAR
 	}
 
-	public FieldInfo getFieldInfo() {
-		return fieldInfo;
+	private final ReplaceWith replaceType;
+	private final Object replaceObj;
+
+	public FieldReplaceAttr(ClassInfo cls) {
+		this.replaceType = ReplaceWith.CLASS_INSTANCE;
+		this.replaceObj = cls;
 	}
 
-	public boolean isOuterClass() {
-		return isOuterClass;
+	public FieldReplaceAttr(InsnArg reg) {
+		this.replaceType = ReplaceWith.VAR;
+		this.replaceObj = reg;
+	}
+
+	public ReplaceWith getReplaceType() {
+		return replaceType;
+	}
+
+	public ClassInfo getClsRef() {
+		return (ClassInfo) replaceObj;
+	}
+
+	public InsnArg getVarRef() {
+		return (InsnArg) replaceObj;
 	}
 
 	@Override
@@ -29,6 +44,6 @@ public class FieldReplaceAttr implements IAttribute {
 
 	@Override
 	public String toString() {
-		return "REPLACE: " + fieldInfo;
+		return "REPLACE: " + replaceType + " " + replaceObj;
 	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/IgnoreEdgeAttr.java

@@ -10,7 +10,7 @@ import java.util.Set;
 
 public class IgnoreEdgeAttr implements IAttribute {
 
-	private final Set<BlockNode> blocks = new HashSet<BlockNode>(3);
+	private final Set<BlockNode> blocks = new HashSet<>(3);
 
 	public Set<BlockNode> getBlocks() {
 		return blocks;

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/LineAttrNode.java

@@ -23,4 +23,9 @@ public abstract class LineAttrNode extends AttrNode {
 	public void setDecompiledLine(int decompiledLine) {
 		this.decompiledLine = decompiledLine;
 	}
+
+	public void copyLines(LineAttrNode lineAttrNode) {
+		setSourceLine(lineAttrNode.getSourceLine());
+		setDecompiledLine(lineAttrNode.getDecompiledLine());
+	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/LoopInfo.java

@@ -43,7 +43,7 @@ public class LoopInfo {
 	 * Exit nodes belongs to loop (contains in {@code loopBlocks})
 	 */
 	public Set<BlockNode> getExitNodes() {
-		Set<BlockNode> nodes = new HashSet<BlockNode>();
+		Set<BlockNode> nodes = new HashSet<>();
 		Set<BlockNode> blocks = getLoopBlocks();
 		for (BlockNode block : blocks) {
 			// exit: successor node not from this loop, (don't change to getCleanSuccessors)
@@ -60,7 +60,7 @@ public class LoopInfo {
 	 * Return loop exit edges.
 	 */
 	public List<Edge> getExitEdges() {
-		List<Edge> edges = new LinkedList<Edge>();
+		List<Edge> edges = new LinkedList<>();
 		Set<BlockNode> blocks = getLoopBlocks();
 		for (BlockNode block : blocks) {
 			for (BlockNode s : block.getSuccessors()) {

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/PhiListAttr.java

@@ -9,7 +9,7 @@ import java.util.List;
 
 public class PhiListAttr implements IAttribute {
 
-	private final List<PhiInsn> list = new LinkedList<PhiInsn>();
+	private final List<PhiInsn> list = new LinkedList<>();
 
 	@Override
 	public AType<PhiListAttr> getType() {

jadx-core/src/main/java/jadx/core/dex/info/ClassInfo.java

@@ -35,12 +35,12 @@ public final class ClassInfo {
 		if (type.isArray()) {
 			type = ArgType.OBJECT;
 		}
-		ClassInfo cls = dex.getInfoStorage().getCls(type);
+		ClassInfo cls = dex.root().getInfoStorage().getCls(type);
 		if (cls != null) {
 			return cls;
 		}
 		cls = new ClassInfo(dex, type);
-		return dex.getInfoStorage().putCls(cls);
+		return dex.root().getInfoStorage().putCls(cls);
 	}
 
 	public static ClassInfo fromDex(DexNode dex, int clsIndex) {
@@ -89,6 +89,10 @@ public final class ClassInfo {
 		int sep = clsName.lastIndexOf('$');
 		if (canBeInner && sep > 0 && sep != clsName.length() - 1) {
 			String parClsName = pkg + "." + clsName.substring(0, sep);
+			if (pkg.isEmpty()) {
+				parClsName = clsName.substring(0, sep);
+			}
+
 			parentClass = fromName(dex, parClsName);
 			clsName = clsName.substring(sep + 1);
 		} else {
@@ -125,6 +129,10 @@ public final class ClassInfo {
 		return pkg;
 	}
 
+	public boolean isDefaultPackage() {
+		return pkg.isEmpty();
+	}
+
 	public String getRawName() {
 		return type.getObject();
 	}
@@ -167,7 +175,7 @@ public final class ClassInfo {
 
 	@Override
 	public int hashCode() {
-		return fullName.hashCode();
+		return type.hashCode();
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/info/ConstStorage.java

@@ -0,0 +1,189 @@
+package jadx.core.dex.info;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.instructions.args.LiteralArg;
+import jadx.core.dex.instructions.args.PrimitiveType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.DexNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.ResRefField;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
+
+public class ConstStorage {
+
+	private static final class ValueStorage {
+		private final Map<Object, FieldNode> values = new HashMap<>();
+		private final Set<Object> duplicates = new HashSet<>();
+
+		public Map<Object, FieldNode> getValues() {
+			return values;
+		}
+
+		public FieldNode get(Object key) {
+			return values.get(key);
+		}
+
+		/**
+		 * @return true if this value is duplicated
+		 */
+		public boolean put(Object value, FieldNode fld) {
+			FieldNode prev = values.put(value, fld);
+			if (prev != null) {
+				values.remove(value);
+				duplicates.add(value);
+				return true;
+			}
+			if (duplicates.contains(value)) {
+				values.remove(value);
+				return true;
+			}
+			return false;
+		}
+
+		public boolean contains(Object value) {
+			return duplicates.contains(value) || values.containsKey(value);
+		}
+	}
+
+	private final boolean replaceEnabled;
+	private final ValueStorage globalValues = new ValueStorage();
+	private final Map<ClassNode, ValueStorage> classes = new HashMap<>();
+
+	private Map<Integer, String> resourcesNames = new HashMap<>();
+
+	public ConstStorage(JadxArgs args) {
+		this.replaceEnabled = args.isReplaceConsts();
+	}
+
+	public void processConstFields(ClassNode cls, List<FieldNode> staticFields) {
+		if (!replaceEnabled || staticFields.isEmpty()) {
+			return;
+		}
+		for (FieldNode f : staticFields) {
+			AccessInfo accFlags = f.getAccessFlags();
+			if (accFlags.isStatic() && accFlags.isFinal()) {
+				FieldInitAttr fv = f.get(AType.FIELD_INIT);
+				if (fv != null
+						&& fv.getValue() != null
+						&& fv.getValueType() == FieldInitAttr.InitType.CONST
+						&& fv != FieldInitAttr.NULL_VALUE) {
+					addConstField(cls, f, fv.getValue(), accFlags.isPublic());
+				}
+			}
+		}
+	}
+
+	private void addConstField(ClassNode cls, FieldNode fld, Object value, boolean isPublic) {
+		if (isPublic) {
+			globalValues.put(value, fld);
+		} else {
+			getClsValues(cls).put(value, fld);
+		}
+	}
+
+	private ValueStorage getClsValues(ClassNode cls) {
+		ValueStorage classValues = classes.get(cls);
+		if (classValues == null) {
+			classValues = new ValueStorage();
+			classes.put(cls, classValues);
+		}
+		return classValues;
+	}
+
+	@Nullable
+	public FieldNode getConstField(ClassNode cls, Object value, boolean searchGlobal) {
+		DexNode dex = cls.dex();
+		if (value instanceof Integer) {
+			String str = resourcesNames.get(value);
+			if (str != null) {
+				return new ResRefField(dex, str.replace('/', '.'));
+			}
+		}
+		if (!replaceEnabled) {
+			return null;
+		}
+		boolean foundInGlobal = globalValues.contains(value);
+		if (foundInGlobal && !searchGlobal) {
+			return null;
+		}
+		ClassNode current = cls;
+		while (current != null) {
+			ValueStorage classValues = classes.get(current);
+			if (classValues != null) {
+				FieldNode field = classValues.get(value);
+				if (field != null) {
+					if (foundInGlobal) {
+						return null;
+					}
+					return field;
+				}
+			}
+			ClassInfo parentClass = current.getClassInfo().getParentClass();
+			if (parentClass == null) {
+				break;
+			}
+			current = dex.resolveClass(parentClass);
+		}
+		if (searchGlobal) {
+			return globalValues.get(value);
+		}
+		return null;
+	}
+
+	@Nullable
+	public FieldNode getConstFieldByLiteralArg(ClassNode cls, LiteralArg arg) {
+		PrimitiveType type = arg.getType().getPrimitiveType();
+		if (type == null) {
+			return null;
+		}
+		long literal = arg.getLiteral();
+		switch (type) {
+			case BOOLEAN:
+				return getConstField(cls, literal == 1, false);
+			case CHAR:
+				return getConstField(cls, (char) literal, Math.abs(literal) > 10);
+			case BYTE:
+				return getConstField(cls, (byte) literal, Math.abs(literal) > 10);
+			case SHORT:
+				return getConstField(cls, (short) literal, Math.abs(literal) > 100);
+			case INT:
+				return getConstField(cls, (int) literal, Math.abs(literal) > 100);
+			case LONG:
+				return getConstField(cls, literal, Math.abs(literal) > 1000);
+			case FLOAT:
+				float f = Float.intBitsToFloat((int) literal);
+				return getConstField(cls, f, Float.compare(f, 0) == 0);
+			case DOUBLE:
+				double d = Double.longBitsToDouble(literal);
+				return getConstField(cls, d, Double.compare(d, 0) == 0);
+
+			default:
+				return null;
+		}
+	}
+
+	public void setResourcesNames(Map<Integer, String> resourcesNames) {
+		this.resourcesNames = resourcesNames;
+	}
+
+	public Map<Integer, String> getResourcesNames() {
+		return resourcesNames;
+	}
+
+	public Map<Object, FieldNode> getGlobalConstFields() {
+		return globalValues.getValues();
+	}
+
+	public boolean isReplaceEnabled() {
+		return replaceEnabled;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/info/FieldInfo.java

@@ -22,7 +22,7 @@ public final class FieldInfo {
 
 	public static FieldInfo from(DexNode dex, ClassInfo declClass, String name, ArgType type) {
 		FieldInfo field = new FieldInfo(declClass, name, type);
-		return dex.getInfoStorage().getField(field);
+		return dex.root().getInfoStorage().getField(field);
 	}
 
 	public static FieldInfo fromDex(DexNode dex, int index) {

jadx-core/src/main/java/jadx/core/dex/info/InfoStorage.java

@@ -1,15 +1,16 @@
 package jadx.core.dex.info;
 
 import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.DexNode;
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class InfoStorage {
 
-	private final Map<ArgType, ClassInfo> classes = new HashMap<ArgType, ClassInfo>();
-	private final Map<Integer, MethodInfo> methods = new HashMap<Integer, MethodInfo>();
-	private final Map<FieldInfo, FieldInfo> fields = new HashMap<FieldInfo, FieldInfo>();
+	private final Map<ArgType, ClassInfo> classes = new HashMap<>();
+	private final Map<Integer, MethodInfo> methods = new HashMap<>();
+	private final Map<FieldInfo, FieldInfo> fields = new HashMap<>();
 
 	public ClassInfo getCls(ArgType type) {
 		return classes.get(type);
@@ -22,13 +23,17 @@ public class InfoStorage {
 		}
 	}
 
-	public MethodInfo getMethod(int mtdId) {
-		return methods.get(mtdId);
+	private int generateMethodLookupId(DexNode dex, int mthId) {
+		return dex.getDexId() << 16 | mthId;
 	}
 
-	public MethodInfo putMethod(int mthId, MethodInfo mth) {
+	public MethodInfo getMethod(DexNode dex, int mtdId) {
+		return methods.get(generateMethodLookupId(dex, mtdId));
+	}
+
+	public MethodInfo putMethod(DexNode dex, int mthId, MethodInfo mth) {
 		synchronized (methods) {
-			MethodInfo prev = methods.put(mthId, mth);
+			MethodInfo prev = methods.put(generateMethodLookupId(dex, mthId), mth);
 			return prev == null ? mth : prev;
 		}
 	}

jadx-core/src/main/java/jadx/core/dex/info/MethodInfo.java

@@ -18,11 +18,13 @@ public final class MethodInfo {
 	private final ClassInfo declClass;
 	private final String shortId;
 	private String alias;
+	private boolean aliasFromPreset;
 
 	private MethodInfo(DexNode dex, int mthIndex) {
 		MethodId mthId = dex.getMethodId(mthIndex);
 		name = dex.getString(mthId.getNameIndex());
 		alias = name;
+		aliasFromPreset = false;
 		declClass = ClassInfo.fromDex(dex, mthId.getDeclaringClassIndex());
 
 		ProtoId proto = dex.getProtoId(mthId.getProtoIndex());
@@ -32,12 +34,12 @@ public final class MethodInfo {
 	}
 
 	public static MethodInfo fromDex(DexNode dex, int mthIndex) {
-		MethodInfo mth = dex.getInfoStorage().getMethod(mthIndex);
+		MethodInfo mth = dex.root().getInfoStorage().getMethod(dex, mthIndex);
 		if (mth != null) {
 			return mth;
 		}
 		mth = new MethodInfo(dex, mthIndex);
-		return dex.getInfoStorage().putMethod(mthIndex, mth);
+		return dex.root().getInfoStorage().putMethod(dex, mthIndex, mth);
 	}
 
 	public String makeSignature(boolean includeRetType) {
@@ -109,6 +111,14 @@ public final class MethodInfo {
 		return !name.equals(alias);
 	}
 
+	public boolean isAliasFromPreset() {
+		return aliasFromPreset;
+	}
+
+	public void setAliasFromPreset(boolean value) {
+		aliasFromPreset = value;
+	}
+
 	@Override
 	public int hashCode() {
 		int result = declClass.hashCode();
@@ -122,10 +132,7 @@ public final class MethodInfo {
 		if (this == obj) {
 			return true;
 		}
-		if (obj == null) {
-			return false;
-		}
-		if (getClass() != obj.getClass()) {
+		if (!(obj instanceof MethodInfo)) {
 			return false;
 		}
 		MethodInfo other = (MethodInfo) obj;

jadx-core/src/main/java/jadx/core/dex/instructions/ArithNode.java

@@ -40,7 +40,6 @@ public class ArithNode extends InsnNode {
 				addReg(insn, 2, type);
 			}
 		}
-		assert getArgsCount() == 2;
 	}
 
 	public ArithNode(ArithOp op, RegisterArg res, InsnArg a, InsnArg b) {

jadx-core/src/main/java/jadx/core/dex/instructions/ConstClassNode.java

@@ -16,6 +16,11 @@ public final class ConstClassNode extends InsnNode {
 		return clsType;
 	}
 
+	@Override
+	public InsnNode copy() {
+		return copyCommonParams(new ConstClassNode(clsType));
+	}
+
 	@Override
 	public boolean isSame(InsnNode obj) {
 		if (this == obj) {

jadx-core/src/main/java/jadx/core/dex/instructions/ConstStringNode.java

@@ -15,6 +15,11 @@ public final class ConstStringNode extends InsnNode {
 		return str;
 	}
 
+	@Override
+	public InsnNode copy() {
+		return copyCommonParams(new ConstStringNode(str));
+	}
+
 	@Override
 	public boolean isSame(InsnNode obj) {
 		if (this == obj) {

jadx-core/src/main/java/jadx/core/dex/instructions/FillArrayNode.java

@@ -66,7 +66,7 @@ public final class FillArrayNode extends InsnNode {
 	}
 
 	public List<LiteralArg> getLiteralArgs() {
-		List<LiteralArg> list = new ArrayList<LiteralArg>(size);
+		List<LiteralArg> list = new ArrayList<>(size);
 		Object array = data;
 		if (array instanceof int[]) {
 			for (int b : (int[]) array) {

jadx-core/src/main/java/jadx/core/dex/instructions/IfNode.java

@@ -14,9 +14,11 @@ import static jadx.core.utils.BlockUtils.selectOther;
 
 public class IfNode extends GotoNode {
 
+	// change default types priority
 	private static final ArgType ARG_TYPE = ArgType.unknown(
-			PrimitiveType.INT, PrimitiveType.OBJECT, PrimitiveType.ARRAY,
-			PrimitiveType.BOOLEAN, PrimitiveType.SHORT, PrimitiveType.CHAR);
+			PrimitiveType.INT,
+			PrimitiveType.OBJECT, PrimitiveType.ARRAY,
+			PrimitiveType.BOOLEAN, PrimitiveType.BYTE, PrimitiveType.SHORT, PrimitiveType.CHAR);
 
 	protected IfOp op;
 

jadx-core/src/main/java/jadx/core/dex/instructions/IndexInsnNode.java

@@ -16,6 +16,11 @@ public class IndexInsnNode extends InsnNode {
 		return index;
 	}
 
+	@Override
+	public IndexInsnNode copy() {
+		return copyCommonParams(new IndexInsnNode(insnType, index, getArgsCount()));
+	}
+
 	@Override
 	public boolean isSame(InsnNode obj) {
 		if (this == obj) {

jadx-core/src/main/java/jadx/core/dex/instructions/InsnDecoder.java

@@ -1,5 +1,19 @@
 package jadx.core.dex.instructions;
 
+import java.io.EOFException;
+
+import com.android.dex.Code;
+import com.android.dx.io.OpcodeInfo;
+import com.android.dx.io.Opcodes;
+import com.android.dx.io.instructions.DecodedInstruction;
+import com.android.dx.io.instructions.FillArrayDataPayloadDecodedInstruction;
+import com.android.dx.io.instructions.PackedSwitchPayloadDecodedInstruction;
+import com.android.dx.io.instructions.ShortArrayCodeInput;
+import com.android.dx.io.instructions.SparseSwitchPayloadDecodedInstruction;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import jadx.core.dex.info.FieldInfo;
 import jadx.core.dex.info.MethodInfo;
 import jadx.core.dex.instructions.args.ArgType;
@@ -12,16 +26,8 @@ import jadx.core.dex.nodes.MethodNode;
 import jadx.core.utils.InsnUtils;
 import jadx.core.utils.exceptions.DecodeException;
 
-import com.android.dex.Code;
-import com.android.dx.io.OpcodeInfo;
-import com.android.dx.io.Opcodes;
-import com.android.dx.io.instructions.DecodedInstruction;
-import com.android.dx.io.instructions.FillArrayDataPayloadDecodedInstruction;
-import com.android.dx.io.instructions.PackedSwitchPayloadDecodedInstruction;
-import com.android.dx.io.instructions.ShortArrayCodeInput;
-import com.android.dx.io.instructions.SparseSwitchPayloadDecodedInstruction;
-
 public class InsnDecoder {
+	private static final Logger LOG = LoggerFactory.getLogger(InsnDecoder.class);
 
 	private final MethodNode method;
 	private final DexNode dex;
@@ -37,26 +43,36 @@ public class InsnDecoder {
 		int size = encodedInstructions.length;
 		DecodedInstruction[] decoded = new DecodedInstruction[size];
 		ShortArrayCodeInput in = new ShortArrayCodeInput(encodedInstructions);
-
 		try {
 			while (in.hasMore()) {
-				decoded[in.cursor()] = DecodedInstruction.decode(in);
+				decoded[in.cursor()] = decodeRawInsn(in);
 			}
 		} catch (Exception e) {
-			throw new DecodeException(method, "", e);
+			throw new DecodeException(method, e.getMessage(), e);
 		}
 		insnArr = decoded;
 	}
 
+	private DecodedInstruction decodeRawInsn(ShortArrayCodeInput in) throws EOFException {
+		int opcodeUnit = in.read();
+		int opcode = Opcodes.extractOpcodeFromUnit(opcodeUnit);
+		OpcodeInfo.Info opcodeInfo;
+		try {
+			opcodeInfo = OpcodeInfo.get(opcode);
+		} catch (IllegalArgumentException e) {
+			LOG.warn("Ignore decode error: '{}', replace with NOP instruction", e.getMessage());
+			opcodeInfo = OpcodeInfo.NOP;
+		}
+		return opcodeInfo.getFormat().decode(opcodeUnit, in);
+	}
+
 	public InsnNode[] process() throws DecodeException {
 		InsnNode[] instructions = new InsnNode[insnArr.length];
 		for (int i = 0; i < insnArr.length; i++) {
 			DecodedInstruction rawInsn = insnArr[i];
 			if (rawInsn != null) {
 				InsnNode insn = decode(rawInsn, i);
-				if (insn != null) {
-					insn.setOffset(i);
-				}
+				insn.setOffset(i);
 				instructions[i] = insn;
 			} else {
 				instructions[i] = null;
@@ -66,13 +82,14 @@ public class InsnDecoder {
 		return instructions;
 	}
 
+	@NotNull
 	private InsnNode decode(DecodedInstruction insn, int offset) throws DecodeException {
 		switch (insn.getOpcode()) {
 			case Opcodes.NOP:
 			case Opcodes.PACKED_SWITCH_PAYLOAD:
 			case Opcodes.SPARSE_SWITCH_PAYLOAD:
 			case Opcodes.FILL_ARRAY_DATA_PAYLOAD:
-				return null;
+				return new InsnNode(InsnType.NOP, 0);
 
 			// move-result will be process in invoke and filled-new-array instructions
 			case Opcodes.MOVE_RESULT:
@@ -307,6 +324,11 @@ public class InsnDecoder {
 			case Opcodes.NEG_DOUBLE:
 				return neg(insn, ArgType.DOUBLE);
 
+			case Opcodes.NOT_INT:
+				return not(insn, ArgType.INT);
+			case Opcodes.NOT_LONG:
+				return not(insn, ArgType.LONG);
+
 			case Opcodes.INT_TO_BYTE:
 				return cast(insn, ArgType.INT, ArgType.BYTE);
 			case Opcodes.INT_TO_CHAR:
@@ -563,9 +585,10 @@ public class InsnDecoder {
 				return insn(InsnType.MONITOR_EXIT,
 						null,
 						InsnArg.reg(insn, 0, ArgType.UNKNOWN_OBJECT));
-		}
 
-		throw new DecodeException("Unknown instruction: " + OpcodeInfo.getName(insn.getOpcode()));
+			default:
+				throw new DecodeException("Unknown instruction: '" + OpcodeInfo.getName(insn.getOpcode()) + "'");
+		}
 	}
 
 	private InsnNode decodeSwitch(DecodedInstruction insn, int offset, boolean packed) {
@@ -681,6 +704,13 @@ public class InsnDecoder {
 		return inode;
 	}
 
+	private InsnNode not(DecodedInstruction insn, ArgType type) {
+		InsnNode inode = new InsnNode(InsnType.NOT, 1);
+		inode.setResult(InsnArg.reg(insn, 0, type));
+		inode.addArg(InsnArg.reg(insn, 1, type));
+		return inode;
+	}
+
 	private InsnNode insn(InsnType type, RegisterArg res) {
 		InsnNode node = new InsnNode(type, 0);
 		node.setResult(res);

jadx-core/src/main/java/jadx/core/dex/instructions/InsnType.java

@@ -8,6 +8,7 @@ public enum InsnType {
 
 	ARITH,
 	NEG,
+	NOT,
 
 	MOVE,
 	CAST,
@@ -65,6 +66,9 @@ public enum InsnType {
 	ONE_ARG,
 	PHI,
 
+	// merge all arguments in one
+	MERGE,
+
 	// TODO: now multidimensional arrays created using Array.newInstance function
 	NEW_MULTIDIM_ARRAY
 }

jadx-core/src/main/java/jadx/core/dex/instructions/InvokeNode.java

@@ -36,6 +36,12 @@ public class InvokeNode extends InsnNode {
 		}
 	}
 
+	private InvokeNode(MethodInfo mth, InvokeType invokeType, int argsCount) {
+		super(InsnType.INVOKE, argsCount);
+		this.mth = mth;
+		this.type = invokeType;
+	}
+
 	public InvokeType getInvokeType() {
 		return type;
 	}
@@ -44,6 +50,11 @@ public class InvokeNode extends InsnNode {
 		return mth;
 	}
 
+	@Override
+	public InsnNode copy() {
+		return copyCommonParams(new InvokeNode(mth, type, getArgsCount()));
+	}
+
 	@Override
 	public boolean isSame(InsnNode obj) {
 		if (this == obj) {

jadx-core/src/main/java/jadx/core/dex/instructions/PhiInsn.java

@@ -21,7 +21,7 @@ public final class PhiInsn extends InsnNode {
 
 	public PhiInsn(int regNum, int predecessors) {
 		super(InsnType.PHI, predecessors);
-		this.blockBinds = new IdentityHashMap<RegisterArg, BlockNode>(predecessors);
+		this.blockBinds = new IdentityHashMap<>(predecessors);
 		setResult(InsnArg.reg(regNum, ArgType.UNKNOWN));
 		add(AFlag.DONT_INLINE);
 	}

jadx-core/src/main/java/jadx/core/dex/instructions/args/ArgType.java

@@ -140,16 +140,16 @@ public abstract class ArgType {
 	}
 
 	private static class ObjectType extends KnownType {
-		private final String object;
+		private final String objName;
 
 		public ObjectType(String obj) {
-			this.object = Utils.cleanObjectName(obj);
-			this.hash = object.hashCode();
+			this.objName = Utils.cleanObjectName(obj);
+			this.hash = objName.hashCode();
 		}
 
 		@Override
 		public String getObject() {
-			return object;
+			return objName;
 		}
 
 		@Override
@@ -164,12 +164,12 @@ public abstract class ArgType {
 
 		@Override
 		boolean internalEquals(Object obj) {
-			return object.equals(((ObjectType) obj).object);
+			return objName.equals(((ObjectType) obj).objName);
 		}
 
 		@Override
 		public String toString() {
-			return object;
+			return objName;
 		}
 	}
 
@@ -280,7 +280,7 @@ public abstract class ArgType {
 	}
 
 	private static final class ArrayArg extends KnownType {
-		public static final PrimitiveType[] ARRAY_POSSIBLES = new PrimitiveType[]{PrimitiveType.ARRAY};
+		private static final PrimitiveType[] ARRAY_POSSIBLES = new PrimitiveType[]{PrimitiveType.ARRAY};
 		private final ArgType arrayElement;
 
 		public ArrayArg(ArgType arrayElement) {
@@ -495,7 +495,7 @@ public abstract class ArgType {
 				return null;
 			} else {
 				// both types unknown
-				List<PrimitiveType> types = new ArrayList<PrimitiveType>();
+				List<PrimitiveType> types = new ArrayList<>();
 				for (PrimitiveType type : a.getPossibleTypes()) {
 					if (b.contains(type)) {
 						types.add(type);
@@ -622,8 +622,10 @@ public abstract class ArgType {
 				return DOUBLE;
 			case 'V':
 				return VOID;
+
+			default:
+				return null;
 		}
-		return null;
 	}
 
 	public int getRegCount() {

jadx-core/src/main/java/jadx/core/dex/instructions/args/FieldArg.java

@@ -57,10 +57,7 @@ public final class FieldArg extends RegisterArg {
 		if (!field.equals(fieldArg.field)) {
 			return false;
 		}
-		if (instArg != null ? !instArg.equals(fieldArg.instArg) : fieldArg.instArg != null) {
-			return false;
-		}
-		return true;
+		return instArg != null ? instArg.equals(fieldArg.instArg) : fieldArg.instArg == null;
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/args/InsnArg.java

@@ -101,7 +101,7 @@ public abstract class InsnArg extends Typed {
 	}
 
 	public static void updateParentInsn(InsnNode fromInsn, InsnNode toInsn) {
-		List<RegisterArg> args = new ArrayList<RegisterArg>();
+		List<RegisterArg> args = new ArrayList<>();
 		fromInsn.getRegisterArgs(args);
 		for (RegisterArg reg : args) {
 			reg.setParentInsn(toInsn);

jadx-core/src/main/java/jadx/core/dex/instructions/args/InsnWrapArg.java

@@ -1,6 +1,7 @@
 package jadx.core.dex.instructions.args;
 
 import jadx.core.dex.nodes.InsnNode;
+import jadx.core.utils.exceptions.JadxRuntimeException;
 
 import org.jetbrains.annotations.NotNull;
 
@@ -20,7 +21,9 @@ public final class InsnWrapArg extends InsnArg {
 
 	@Override
 	public void setParentInsn(InsnNode parentInsn) {
-		assert parentInsn != wrappedInsn : "Can't wrap instruction info itself: " + parentInsn;
+		if (parentInsn == wrappedInsn) {
+			throw new JadxRuntimeException("Can't wrap instruction info itself: " + parentInsn);
+		}
 		this.parentInsn = parentInsn;
 	}
 

jadx-core/src/main/java/jadx/core/dex/instructions/args/RegisterArg.java

@@ -6,12 +6,11 @@ import jadx.core.dex.nodes.DexNode;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.utils.InsnUtils;
 
+import java.util.Objects;
+
 import org.jetbrains.annotations.NotNull;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class RegisterArg extends InsnArg implements Named {
-	private static final Logger LOG = LoggerFactory.getLogger(RegisterArg.class);
 
 	protected final int regNum;
 	// not null after SSATransform pass
@@ -77,8 +76,15 @@ public class RegisterArg extends InsnArg implements Named {
 	}
 
 	public RegisterArg duplicate() {
-		RegisterArg dup = new RegisterArg(getRegNum(), getType());
-		dup.setSVar(sVar);
+		return duplicate(getRegNum(), sVar);
+	}
+
+	public RegisterArg duplicate(int regNum, SSAVar sVar) {
+		RegisterArg dup = new RegisterArg(regNum, getType());
+		if (sVar != null) {
+			dup.setSVar(sVar);
+		}
+		dup.copyAttributesFrom(this);
 		return dup;
 	}
 
@@ -144,23 +150,13 @@ public class RegisterArg extends InsnArg implements Named {
 		if (this == obj) {
 			return true;
 		}
-		if (obj == null) {
-			return false;
-		}
 		if (!(obj instanceof RegisterArg)) {
 			return false;
 		}
 		RegisterArg other = (RegisterArg) obj;
-		if (regNum != other.regNum) {
-			return false;
-		}
-		if (!type.equals(other.type)) {
-			return false;
-		}
-		if (sVar != null && !sVar.equals(other.getSVar())) {
-			return false;
-		}
-		return true;
+		return regNum == other.regNum
+				&& type.equals(other.type)
+				&& Objects.equals(sVar, other.getSVar());
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/args/SSAVar.java

@@ -1,5 +1,6 @@
 package jadx.core.dex.instructions.args;
 
+import jadx.core.dex.attributes.AttrNode;
 import jadx.core.dex.instructions.PhiInsn;
 
 import java.util.ArrayList;
@@ -8,7 +9,7 @@ import java.util.List;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class SSAVar {
+public class SSAVar extends AttrNode {
 
 	private final int regNum;
 	private final int version;
@@ -19,7 +20,7 @@ public class SSAVar {
 
 	@NotNull
 	private RegisterArg assign;
-	private final List<RegisterArg> useList = new ArrayList<RegisterArg>(2);
+	private final List<RegisterArg> useList = new ArrayList<>(2);
 	@Nullable
 	private PhiInsn usedInPhi;
 

jadx-core/src/main/java/jadx/core/dex/instructions/args/Typed.java

@@ -1,8 +1,9 @@
 package jadx.core.dex.instructions.args;
 
+import jadx.core.dex.attributes.AttrNode;
 import jadx.core.dex.nodes.DexNode;
 
-public abstract class Typed {
+public abstract class Typed extends AttrNode {
 
 	protected ArgType type;
 

jadx-core/src/main/java/jadx/core/dex/instructions/mods/TernaryInsn.java

@@ -9,7 +9,7 @@ import jadx.core.dex.regions.conditions.IfCondition;
 import jadx.core.utils.InsnUtils;
 import jadx.core.utils.Utils;
 
-import java.util.List;
+import java.util.Collection;
 
 public final class TernaryInsn extends InsnNode {
 
@@ -54,7 +54,7 @@ public final class TernaryInsn extends InsnNode {
 	}
 
 	@Override
-	public void getRegisterArgs(List<RegisterArg> list) {
+	public void getRegisterArgs(Collection<RegisterArg> list) {
 		super.getRegisterArgs(list);
 		list.addAll(condition.getRegisterArgs());
 	}