fix: disable HTML rendering in labels if not needed

Add new text about logcat.

.editorconfig

@@ -0,0 +1,20 @@
+# EditorConfig is awesome: https://EditorConfig.org
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+indent_style = tab
+tab_width = 4
+continuation_indent_size = 8 #IntelliJ Idea specific workaround
+
+charset = utf-8
+trim_trailing_whitespace = true
+
+[*.yml]
+indent_style = space
+indent_size = 2
+
+[*.bat]
+end_of_line = crlf

.github/ISSUE_TEMPLATE/decompilation-error.md

@@ -0,0 +1,19 @@
+---
+name: Decompilation error
+about: Create a report to help us improve jadx decompiler
+title: "[core]"
+labels: Core, bug
+assignees: ''
+
+---
+
+**Checks before report**
+- check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+- search existing issues by exception message
+
+**Describe error**
+- full name of method or class with error
+- full java stacktrace (no need to copy method fallback code (commented pseudocode))
+- **IMPORTANT!** attach or provide link to apk file (double check apk version)
+
+  **Note**: GitHub don't allow attach files with `.apk` extension, but you can change extension by adding `.zip` at the end :)

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,10 @@
+---
+name: Feature Request
+about: Suggest an idea for jadx
+title: "[feature]"
+labels: new feature
+assignees: ''
+
+---
+
+*Describe your idea:*

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  # Set update schedule for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/pull_request_template.md

@@ -0,0 +1,5 @@
+:exclamation: Please review the [guidelines for contributing](https://github.com/skylot/jadx/blob/master/CONTRIBUTING.md#Pull-Request-Process)
+
+### Description
+Please describe your pull request.
+Reference issue it fixes.

.github/workflows/build-artifacts.yml

@@ -0,0 +1,88 @@
+name: Build Artifacts
+
+on:
+  push:
+    branches: [ master, build-test ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'adopt'
+          java-version: 8
+
+      - name: Set jadx version
+        run: |
+          JADX_LAST_TAG=$(git describe --abbrev=0 --tags)
+          JADX_VERSION="${JADX_LAST_TAG:1}.$GITHUB_RUN_NUMBER-${GITHUB_SHA:0:8}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - uses: burrunan/gradle-cache-action@v1
+        name: Build with Gradle
+        env:
+          TERM: dumb
+        with:
+          arguments: clean dist copyExe
+
+      - name: Save bundle artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ format('jadx-{0}', env.JADX_VERSION) }}
+          # Waiting fix for https://github.com/actions/upload-artifact/issues/39 to upload zip file
+          # Upload unpacked files for now
+          path: build/jadx/**/*
+          if-no-files-found: error
+          retention-days: 30
+
+      - name: Save exe artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ format('jadx-gui-{0}-no-jre-win.exe', env.JADX_VERSION) }}
+          path: build/*.exe
+          if-no-files-found: error
+          retention-days: 30
+
+  build-win-bundle:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: oracle-actions/setup-java@v1
+        with:
+          release: 18
+
+      - name: Print Java version
+        shell: bash
+        run: java -version
+
+      - name: Set jadx version
+        shell: bash
+        run: |
+          JADX_LAST_TAG=$(git describe --abbrev=0 --tags)
+          JADX_VERSION="${JADX_LAST_TAG:1}.$GITHUB_RUN_NUMBER-${GITHUB_SHA:0:8}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - uses: gradle/gradle-build-action@v2
+        name: Build with Gradle
+        env:
+          TERM: dumb
+        with:
+          arguments: clean dist -PbundleJRE=true
+
+      - name: Save exe bundle artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ format('jadx-gui-{0}-with-jre-win', env.JADX_VERSION) }}
+          path: jadx-gui/build/*-with-jre-win/*
+          if-no-files-found: error
+          retention-days: 30

.github/workflows/build-test.yml

@@ -0,0 +1,28 @@
+name: Build Test
+
+on:
+  push:
+    branches: [ master, build-test ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'adopt'
+          java-version: 8
+
+      - uses: burrunan/gradle-cache-action@v1
+        name: Build with Gradle
+        env:
+          TERM: dumb
+        with:
+          arguments: clean build dist copyExe --warning-mode=all

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,41 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [master]
+  schedule:
+    - cron: '0 9 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ['java']
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        queries: +security-extended
+        languages: ${{ matrix.language }}
+
+    # Don't build tests in jadx-core also skip tests execution and checkstyle tasks
+    - run: |
+        ./gradlew clean build -x checkstyleTest -x checkstyleMain -x test -x ':jadx-core:testClasses'
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/gradle-wrapper-validation.yml

@@ -0,0 +1,10 @@
+name: "Validate Gradle Wrapper"
+on: [push]
+
+jobs:
+  validation:
+    name: "Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: gradle/wrapper-validation-action@v1

.gitignore

@@ -5,23 +5,35 @@
 
 # IntelliJ Idea files
 .idea/
+.run/
 out/
 *.iml
 *.ipr
 *.iws
+.attach_pid*
+*.hprof
+
+**/.DS_Store
 
 bin/
 target/
 build/
+classes/
 idea/
 .gradle/
-gradle.properties
+node_modules/
 
+jadx-output/
 *-tmp/
+**/tmp/
+*.jobf
 
-*.dex
 *.class
 *.dump
 *.log
 *.cfg
+*.orig
+quark.json
 
+cliff.toml
+jadx-gui/src/main/resources/logback.xml

.gitlab-ci.yml

@@ -0,0 +1,24 @@
+variables:
+  GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+  TERM: "dumb"
+
+before_script:
+  - chmod +x gradlew
+
+stages:
+  - test
+
+java-8:
+  stage: test
+  image: openjdk:8
+  script: ./gradlew clean build dist copyExe --warning-mode=all
+
+java-11:
+  stage: test
+  image: openjdk:11
+  script: ./gradlew clean build dist copyExe --warning-mode=all
+
+java-latest:
+  stage: test
+  image: openjdk:latest
+  script: java -version && ./gradlew clean build dist --warning-mode=all

.jitpack.yml

@@ -0,0 +1,5 @@
+jdk:
+  - openjdk11
+install:
+  - echo "Jitpack is not supported. Use artifacts from Maven Central (https://search.maven.org/search?q=jadx), check usage help at https://github.com/skylot/jadx/wiki/Use-jadx-as-a-library"
+  - ./gradlew intentional-fail

.travis.yml

@@ -1,24 +0,0 @@
-language: java
-jdk:
-    - oraclejdk8
-    - oraclejdk7
-    - openjdk6
-
-before_install:
-    - chmod +x gradlew
-
-script:
-    - TERM=dumb ./gradlew clean build dist
-
-after_success:
-    - TERM=dumb ./gradlew jacocoTestReport coveralls
-
-sudo: false
-
-cache:
-    directories:
-        - $HOME/.gradle
-
-notifications:
-    email:
-        - skylot@gmail.com

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at skylot@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,32 @@
+# Contributing
+
+Please note we have a [code of conduct](CODE_OF_CONDUCT.md), please follow it in all your interactions with the project.
+
+## Open Issue
+
+1. Before proceed please do:
+    - check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+    - search existing issues by exception message
+
+2. Describe error
+    **Describe error**
+    - full name of method or class with error
+    - full java stacktrace (no need to copy method fallback code (commented pseudocode))
+    - **IMPORTANT!:** attach or provide link to apk file (double check apk version)
+
+      **Note**: GitHub don't allow attach files with `.apk` extension, but you can change extension by adding `.zip` at the end :)
+
+
+## Pull Request Process
+
+1. Please don't submit any code style fixes, dependencies updates or other changes which are not fixing any issues.
+
+1. Before start working on PR please discuss the change you wish to make via issue. PR without corresponding issue will be rejected.
+
+1. Use only features and API from Java 8 or below.
+
+1. If possible don't add additional dependencies especially if they are big.
+
+1. Make sure your code is correctly formatted, see description here: [Code Formatting](https://github.com/skylot/jadx/wiki/Code-Formatting).
+
+1. Make sure your changes is passing build: `./gradlew clean build dist`

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,89 +1,169 @@
+<img src="https://raw.githubusercontent.com/skylot/jadx/master/jadx-gui/src/main/resources/logos/jadx-logo.png" width="64" align="left" />
+
 ## 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)
+[![Build status](https://github.com/skylot/jadx/workflows/Build/badge.svg)](https://github.com/skylot/jadx/actions?query=workflow%3ABuild)
+![GitHub contributors](https://img.shields.io/github/contributors/skylot/jadx)
+![GitHub all releases](https://img.shields.io/github/downloads/skylot/jadx/total)
+![GitHub release (latest by SemVer)](https://img.shields.io/github/downloads/skylot/jadx/latest/total)
+![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)
+[![Maven Central](https://img.shields.io/maven-central/v/io.github.skylot/jadx-core)](https://search.maven.org/search?q=g:io.github.skylot%20AND%20jadx)
 [![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
+Command line and GUI tools for producing Java source code from Android Dex and Apk files
 
-![jadx-gui screenshot](http://skylot.github.io/jadx/jadx-gui.png)
+:exclamation::exclamation::exclamation: Please note that in most cases **jadx** can't decompile all 100% of the code, so errors will occur. Check [Troubleshooting guide](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A#decompilation-issues) for workarounds
 
-### 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/)
+**Main features:**
+- decompile Dalvik bytecode to java classes from APK, dex, aar, aab and zip files
+- decode `AndroidManifest.xml` and other resources from `resources.arsc`
+- deobfuscator included
 
+**jadx-gui features:**
+- view decompiled code with highlighted syntax
+- jump to declaration
+- find usage
+- full text search
+- smali debugger, check [wiki page](https://github.com/skylot/jadx/wiki/Smali-debugger) for setup and usage
 
-### Building from source
-    git clone https://github.com/skylot/jadx.git
-    cd jadx
-    ./gradlew dist
+Jadx-gui key bindings can be found [here](https://github.com/skylot/jadx/wiki/JADX-GUI-Key-bindings)
+
+See these features in action here: [jadx-gui features overview](https://github.com/skylot/jadx/wiki/jadx-gui-features-overview)
+
+<img src="https://user-images.githubusercontent.com/118523/142730720-839f017e-38db-423e-b53f-39f5f0a0316f.png" width="700"/>
+
+### Download
+- release
+  from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- latest [unstable build ![GitHub commits since tagged version (branch)](https://img.shields.io/github/commits-since/skylot/jadx/latest/master)](https://nightly.link/skylot/jadx/workflows/build-artifacts/master)
+
+After download unpack zip file go to `bin` directory and run:
+- `jadx` - command line version
+- `jadx-gui` - UI version
+
+On Windows run `.bat` files with double-click\
+**Note:** ensure you have installed Java 11 or later 64-bit version.
+For Windows, you can download it from [oracle.com](https://www.oracle.com/java/technologies/downloads/#jdk17-windows) (select x64 Installer).
+
+### Install
+1. Arch linux ![Arch Linux package](https://img.shields.io/archlinux/v/community/any/jadx?label=)
+    ```bash
+    sudo pacman -S jadx
+    ```
+2. macOS ![homebrew version](https://img.shields.io/homebrew/v/jadx?label=)
+    ```bash
+    brew install jadx
+    ```
+3. [Flathub ![Flathub](https://img.shields.io/flathub/v/com.github.skylot.jadx?label=)](https://flathub.org/apps/details/com.github.skylot.jadx)
+   ```bash
+   flatpak install flathub com.github.skylot.jadx
+   ```
+
+### Use jadx as a library
+You can use jadx in your java projects, check details on [wiki page](https://github.com/skylot/jadx/wiki/Use-jadx-as-a-library)
+
+### Build from source
+JDK 8 or higher must be installed:
+```
+git clone https://github.com/skylot/jadx.git
+cd jadx
+./gradlew dist
+```
 
 (on Windows, use `gradlew.bat` instead of `./gradlew`)
 
 Scripts for run jadx will be placed in `build/jadx/bin`
 and also packed to `build/jadx-<version>.zip`
 
-
-### Run
-Run **jadx** on itself:
-
-    cd build/jadx/
-    bin/jadx -d out lib/jadx-core-*.jar
-    #or
-    bin/jadx-gui lib/jadx-core-*.jar
-
-
 ### Usage
 ```
-jadx[-gui] [options] <input file> (.dex, .apk, .jar or .class)
+jadx[-gui] [options] <input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab)
 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
-Example:
- jadx -d out classes.dex
+  -d, --output-dir                    - output directory
+  -ds, --output-dir-src               - output directory for sources
+  -dr, --output-dir-res               - output directory for resources
+  -r, --no-res                        - do not decode resources
+  -s, --no-src                        - do not decompile source code
+  --single-class                      - decompile a single class, full name, raw or alias
+  --single-class-output               - file or dir for write if decompile a single class
+  --output-format                     - can be 'java' or 'json', default: java
+  -e, --export-gradle                 - save as android gradle project
+  -j, --threads-count                 - processing threads count, default: 4
+  -m, --decompilation-mode            - code output mode:
+                                         'auto' - trying best options (default)
+                                         'restructure' - restore code structure (normal java code)
+                                         'simple' - simplified instructions (linear, with goto's)
+                                         'fallback' - raw instructions without modifications
+  --show-bad-code                     - show inconsistent code (incorrectly decompiled)
+  --no-imports                        - disable use of imports, always write entire package name
+  --no-debug-info                     - disable debug info
+  --add-debug-lines                   - add comments with debug line numbers if available
+  --no-inline-anonymous               - disable anonymous classes inline
+  --no-inline-methods                 - disable methods inline
+  --no-finally                        - don't extract finally block
+  --no-replace-consts                 - don't replace constant value with matching constant field
+  --escape-unicode                    - escape non latin characters in strings (with \u)
+  --respect-bytecode-access-modifiers - don't change original access modifiers
+  --deobf                             - activate deobfuscation
+  --deobf-min                         - min length of name, renamed if shorter, default: 3
+  --deobf-max                         - max length of name, renamed if longer, default: 64
+  --deobf-cfg-file                    - deobfuscation map file, default: same dir and name as input file with '.jobf' extension
+  --deobf-cfg-file-mode               - set mode for handle deobfuscation map file:
+                                         'read' - read if found, don't save (default)
+                                         'read-or-save' - read if found, save otherwise (don't overwrite)
+                                         'overwrite' - don't read, always save
+                                         'ignore' - don't read and don't save
+  --deobf-use-sourcename              - use source file name as class name alias
+  --deobf-parse-kotlin-metadata       - parse kotlin metadata to class and package names
+  --deobf-res-name-source             - better name source for resources:
+                                         'auto' - automatically select best name (default)
+                                         'resources' - use resources names
+                                         'code' - use R class fields names
+  --use-kotlin-methods-for-var-names  - use kotlin intrinsic methods to rename variables, values: disable, apply, apply-and-hide, default: apply
+  --rename-flags                      - fix options (comma-separated list of):
+                                         'case' - fix case sensitivity issues (according to --fs-case-sensitive option),
+                                         'valid' - rename java identifiers to make them valid,
+                                         'printable' - remove non-printable chars from identifiers,
+                                        or single 'none' - to disable all renames
+                                        or single 'all' - to enable all (default)
+  --fs-case-sensitive                 - treat filesystem as case sensitive, false by default
+  --cfg                               - save methods control flow graph to dot file
+  --raw-cfg                           - save methods control flow graph (use raw instructions)
+  -f, --fallback                      - set '--decompilation-mode' to 'fallback' (deprecated)
+  --use-dx                            - use dx/d8 to convert java bytecode
+  --comments-level                    - set code comments level, values: error, warn, info, debug, user-only, none, default: info
+  --log-level                         - set log level, values: quiet, progress, error, warn, info, debug, default: progress
+  -v, --verbose                       - verbose output (set --log-level to DEBUG)
+  -q, --quiet                         - turn off output (set --log-level to QUIET)
+  --version                           - print jadx version
+  -h, --help                          - print this help
+
+Plugin options (-P<name>=<value>):
+ 1) dex-input: Load .dex and .apk files
+    - dex-input.verify-checksum       - verify dex file checksum before load, values: [yes, no], default: yes
+ 2) java-convert: Convert .class, .jar and .aar files to dex
+    - java-convert.mode               - convert mode, values: [dx, d8, both], default: both
+    - java-convert.d8-desugar         - use desugar in d8, values: [yes, no], default: no
+
+Examples:
+  jadx -d out classes.dex
+  jadx --rename-flags "none" classes.dex
+  jadx --rename-flags "valid, printable" classes.dex
+  jadx --log-level ERROR app.apk
+  jadx -Pdex-input.verify-checksum=no app.apk
 ```
+These options also worked on jadx-gui running from command line and override options from preferences dialog
 
 ### Troubleshooting
-##### Out of memory error:
-  - Reduce processing threads count (`-j` option)
-  - Increase maximum java heap size:
-    * command line (example for linux):
-      `JAVA_OPTS="-Xmx4G" jadx -j 1 some.apk`
-    * edit 'jadx' script (jadx.bat on Windows) and setup bigger heap size:
-      `DEFAULT_JVM_OPTS="-Xmx2500M"`
-
-
-### Contribution
+Please check wiki page [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A)
 
+### Contributing
 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.
+  - Submit decompilation issues, please read before proceed: [Open issue](CONTRIBUTING.md#Open-Issue)
+  - Open pull request, please follow these rules: [Pull Request Process](CONTRIBUTING.md#Pull-Request-Process)
 
 ---------------------------------------
 *Licensed under the Apache 2.0 License*
-
-*Copyright 2015 by Skylot*

SECURITY.md

@@ -0,0 +1,7 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+To report a security issue, please email `skylot@gmail.com` with a description of the issue, the steps you took to create the issue, affected versions, and, if known, mitigations for the issue.
+We will check and respond within 3 working days. If the issue is confirmed as a vulnerability, we will apply required mitigations at the next release.
+This project follows a 90 day disclosure timeline.

build.gradle

@@ -1,109 +1,160 @@
-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.ben-manes.versions' version '0.43.0'
+	id 'com.diffplug.spotless' version '6.11.0'
 }
 
-apply plugin: 'sonar-runner'
-
-ext.jadxVersion = file('version').readLines().get(0)
+ext.jadxVersion = System.getenv('JADX_VERSION') ?: "dev"
 version = jadxVersion
+println("jadx version: ${jadxVersion}")
 
-subprojects {
-    apply plugin: 'java'
-    apply plugin: 'groovy'
-    apply plugin: 'jacoco'
-    apply plugin: 'com.github.kt3k.coveralls'
+allprojects {
+	apply plugin: 'java'
+	apply plugin: 'checkstyle'
 
-    version = jadxVersion
+	version = jadxVersion
 
-    tasks.withType(JavaCompile) {
-        sourceCompatibility = JavaVersion.VERSION_1_6
-        targetCompatibility = JavaVersion.VERSION_1_6
+	sourceCompatibility = 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 {
-            mainAttributes('jadx-version': jadxVersion)
-        }
-    }
+	jar {
+		manifest {
+			mainAttributes('jadx-version': jadxVersion)
+		}
+	}
 
-    dependencies {
-        compile 'org.slf4j:slf4j-api:1.7.10'
+	dependencies {
+		implementation 'org.slf4j:slf4j-api:2.0.3'
+		compileOnly 'org.jetbrains:annotations:23.0.0'
 
-        testCompile 'ch.qos.logback:logback-classic:1.1.2'
-        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'
-    }
+		testImplementation 'ch.qos.logback:logback-classic:1.3.4'
+		testImplementation 'org.hamcrest:hamcrest-library:2.2'
+		testImplementation 'org.mockito:mockito-core:4.8.0'
+		testImplementation 'org.assertj:assertj-core:3.23.1'
 
-    repositories {
-        mavenCentral()
-        mavenLocal()
-        jcenter()
-    }
+		testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.1'
+		testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.1'
 
-    jacocoTestReport {
-        reports {
-            xml.enabled = true // coveralls plugin depends on xml format report
-            html.enabled = true
-        }
-    }
+		testCompileOnly 'org.jetbrains:annotations:23.0.0'
+	}
+
+	test {
+		useJUnitPlatform()
+		maxParallelForks = Runtime.runtime.availableProcessors()
+	}
+
+	repositories {
+		mavenLocal()
+		mavenCentral()
+		google()
+		// Commented out for now since we're using a local mapping-io fork atm.
+        // maven {
+		// 	name 'FabricMC'
+		// 	url 'https://maven.fabricmc.net/'
+		// }
+	}
 }
 
-/* Sonar runner configuration */
-repositories {
-    mavenCentral()
-}
-sonarRunner {
-    toolVersion = '2.4'
+spotless {
+	java {
+		target fileTree(rootDir).matching {
+			include 'jadx-cli/src/**/java/**/*.java'
+			include 'jadx-core/src/**/java/**/*.java'
+			include 'jadx-gui/src/**/java/**/*.java'
+			include 'jadx-plugins/**/java/**/*.java'
+		}
+
+		importOrderFile 'config/code-formatter/eclipse.importorder'
+		eclipse().configFile 'config/code-formatter/eclipse.xml'
+		removeUnusedImports()
+
+		lineEndings(com.diffplug.spotless.LineEnding.UNIX)
+		encoding("UTF-8")
+		trimTrailingWhitespace()
+		endWithNewline()
+	}
+	format 'misc', {
+		target '**/*.gradle', '**/*.md', '**/*.xml', '**/.gitignore', '**/.properties'
+		targetExclude ".gradle/**", ".idea/**", "*/build/**"
+
+		lineEndings(com.diffplug.spotless.LineEnding.UNIX)
+		encoding("UTF-8")
+		trimTrailingWhitespace()
+		endWithNewline()
+	}
 }
 
-task copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installDist', 'jadx-gui:installDist']) {
-    destinationDir file("$buildDir/jadx")
-    ['jadx-cli', 'jadx-gui'].each {
-        from tasks.getByPath(":${it}:installDist").destinationDir
-    }
+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 pack(type: Zip, dependsOn: copyArtifacts) {
-    destinationDir buildDir
-    archiveName "jadx-${jadxVersion}.zip"
-    from copyArtifacts.destinationDir
+task copyArtifacts(type: Copy) {
+	from tasks.getByPath(":jadx-cli:installDist")
+	from tasks.getByPath(":jadx-gui:installDist")
+	into layout.buildDirectory.dir("jadx")
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 }
 
-task dist(dependsOn: pack) {
-    description = 'Build jadx distribution zip'
+task pack(type: Zip) {
+	from copyArtifacts
+	archiveFileName = "jadx-${jadxVersion}.zip"
+	destinationDirectory = layout.buildDirectory
 }
 
-task samples(dependsOn: 'jadx-samples:samples') {
+task copyExe(type: Copy) {
+	group 'jadx'
+	description = 'Copy exe to build dir'
+	mustRunAfter pack // not needed, but gradle throws warning because of same output dir
+
+	from tasks.getByPath('jadx-gui:createExe')
+	include '*.exe'
+	into layout.buildDirectory
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 }
 
-task pitest(overwrite: true, dependsOn: 'jadx-core:pitest') {
+task distWinBundle(type: Copy, dependsOn: 'jadx-gui:distWinWithJre') {
+	group 'jadx'
+	description = 'Copy bundle to build dir'
+	destinationDir buildDir
+	from(tasks.getByPath('jadx-gui:distWinWithJre').outputs) {
+		include '*.zip'
+	}
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+task dist {
+	group 'jadx'
+	description = 'Build jadx distribution zip'
+
+	dependsOn(pack)
+
+	OperatingSystem os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem;
+	if (os.isWindows()) {
+		if (project.hasProperty("bundleJRE")) {
+			println("Build win bundle with JRE")
+			dependsOn('distWinBundle')
+		} else {
+			dependsOn('copyExe')
+		}
+	}
 }
 
 task cleanBuildDir(type: Delete) {
-    delete buildDir
+	group 'jadx'
+	delete buildDir
 }
 
-build.dependsOn(dist, samples)
-
 clean.dependsOn(cleanBuildDir)
-
-task wrapper(type: Wrapper) {
-    gradleVersion = '2.3'
-}

buildSrc/build.gradle

@@ -0,0 +1,3 @@
+plugins {
+	id 'groovy-gradle-plugin'
+}

buildSrc/src/main/groovy/jadx-library.gradle

@@ -0,0 +1,79 @@
+plugins {
+	id 'java-library'
+	id 'maven-publish'
+	id 'signing'
+}
+
+
+group = 'io.github.skylot'
+version = jadxVersion
+
+java {
+	withJavadocJar()
+	withSourcesJar()
+}
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifactId = project.name
+			from components.java
+			versionMapping {
+				usage('java-api') {
+					fromResolutionOf('runtimeClasspath')
+				}
+				usage('java-runtime') {
+					fromResolutionResult()
+				}
+			}
+			pom {
+				name = project.name
+				description = 'Dex to Java decompiler'
+				url = 'https://github.com/skylot/jadx'
+				licenses {
+					license {
+						name = 'The Apache License, Version 2.0'
+						url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+					}
+				}
+				developers {
+					developer {
+						id = 'skylot'
+						name = 'Skylot'
+						email = 'skylot@gmail.com'
+						url = 'https://github.com/skylot'
+					}
+				}
+				scm {
+					connection = 'scm:git:git://github.com/skylot/jadx.git'
+					developerConnection = 'scm:git:ssh://github.com:skylot/jadx.git'
+					url = 'https://github.com/skylot/jadx'
+				}
+			}
+		}
+	}
+	repositories {
+		maven {
+			def releasesRepoUrl = uri('https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/')
+			def snapshotsRepoUrl = uri('https://s01.oss.sonatype.org/content/repositories/snapshots/')
+			url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
+			credentials {
+				username = project.properties['ossrhUser'].toString()
+				password = project.properties['ossrhPassword'].toString()
+			}
+		}
+	}
+}
+
+signing {
+	required { gradle.taskGraph.hasTask("publish") }
+	sign publishing.publications.mavenJava
+}
+
+javadoc {
+	if (JavaVersion.current().isJava9Compatible()) {
+		options.addBooleanOption('html5', true)
+	}
+	// disable 'missing' warnings
+	options.addStringOption('Xdoclint:all,-missing', '-quiet')
+}

config/checkstyle/checkstyle.xml

@@ -0,0 +1,137 @@
+<?xml version="1.0" ?>
+
+<!DOCTYPE module PUBLIC
+		"-//Puppy Crawl//DTD Check Configuration 1.2//EN"
+		"http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
+
+<module name="Checker">
+	<property name="fileExtensions" value="java, properties, xml"/>
+	<property name="charset" value="UTF-8"/>
+
+	<module name="TreeWalker">
+		<property name="tabWidth" value="4"/>
+		<module name="RegexpSinglelineJava">
+			<property name="format" value="^\t* "/>
+			<property name="message" value="Indent must use tab characters"/>
+			<property name="ignoreComments" value="true"/>
+		</module>
+		<module name="RegexpSinglelineJava">
+			<property name="format" value="^(?!\s+\* $).*?\s+$"/>
+			<property name="message" value="Line has trailing spaces."/>
+		</module>
+		<module name="AvoidEscapedUnicodeCharacters">
+			<property name="allowEscapesForControlCharacters" value="true"/>
+			<property name="allowByTailComment" value="true"/>
+			<property name="allowNonPrintableEscapes" value="true"/>
+		</module>
+
+		<module name="EmptyLineSeparator">
+			<property name="allowNoEmptyLineBetweenFields" value="true"/>
+			<property name="allowMultipleEmptyLines" value="false"/>
+		</module>
+
+		<!-- whitespaces -->
+		<module name="SingleSpaceSeparator"/>
+		<module name="GenericWhitespace"/>
+		<module name="MethodParamPad"/>
+		<module name="NoWhitespaceBefore"/>
+		<module name="OperatorWrap"/>
+		<module name="ParenPad"/>
+		<module name="TypecastParenPad"/>
+		<module name="WhitespaceAfter"/>
+		<module name="WhitespaceAround">
+			<property name="allowEmptyMethods" value="true"/>
+		</module>
+		<!-- <module name="EmptyForIteratorPad"/> -->
+		<!-- <module name="NoWhitespaceAfter"/>-->
+
+		<module name="NoLineWrap"/>
+
+		<module name="IllegalImport"/> <!-- defaults to sun.* packages -->
+		<module name="RedundantImport"/>
+		<module name="UnusedImports"/>
+		<!-- <module name="AvoidStarImport"/> -->
+
+		<module name="NeedBraces"/>
+		<module name="LeftCurly"/>
+		<module name="RightCurly"/>
+		<module name="EmptyCatchBlock">
+			<property name="exceptionVariableName" value="expected|ignore"/>
+		</module>
+
+		<!-- naming -->
+		<module name="PackageName"/>
+		<module name="TypeName"/>
+		<module name="InterfaceTypeParameterName"/>
+		<module name="ClassTypeParameterName"/>
+		<module name="StaticVariableName"/>
+		<module name="ConstantName"/>
+		<module name="MemberName"/>
+		<module name="MethodName"/>
+		<module name="MethodTypeParameterName"/>
+		<module name="ParameterName"/>
+		<module name="LambdaParameterName"/>
+		<module name="LocalVariableName"/>
+		<module name="LocalFinalVariableName"/>
+		<module name="CatchParameterName"/>
+		<!-- <module name="HiddenField"/> -->
+
+		<!-- annotations -->
+		<module name="AnnotationLocation"/>
+		<module name="AnnotationUseStyle">
+			<property name="elementStyle" value="compact"/>
+		</module>
+		<module name="MissingOverride"/>
+		<!-- <module name="MissingDeprecated"/> -->
+
+		<module name="ModifierOrder"/>
+		<!-- <module name="RedundantModifier"/> -->
+		<!-- <module name="ParameterNumber"/> -->
+
+		<module name="EmptyStatement"/>
+		<module name="DefaultComesLast"/>
+		<module name="EqualsHashCode"/>
+		<module name="FallThrough"/>
+		<!-- <module name="IllegalCatch"/> -->
+		<module name="IllegalThrows"/>
+		<module name="IllegalType"/>
+		<module name="InnerAssignment"/>
+		<module name="MultipleVariableDeclarations"/>
+		<module name="NoClone"/>
+		<module name="NoFinalizer"/>
+		<module name="OneStatementPerLine"/>
+		<module name="PackageDeclaration"/>
+		<module name="StringLiteralEquality"/>
+
+		<!-- design -->
+		<module name="OneTopLevelClass"/>
+		<module name="MutableException"/>
+		<module name="InterfaceIsType"/>
+		<module name="ThrowsCount">
+			<property name="max" value="2"/>
+		</module>
+
+		<!-- misc -->
+		<module name="ArrayTypeStyle"/>
+		<module name="OuterTypeFilename"/>
+
+		<!-- sizes -->
+		<module name="OuterTypeNumber"/>
+
+		<module name="SuppressWarningsHolder"/>
+
+		<module name="IllegalType"/>
+		<module name="IllegalImport">
+			<property name="illegalClasses" value="jadx.core.utils.DebugUtils"/>
+		</module>
+		<module name="RegexpSinglelineJava">
+			<property name="id" value="printstacktrace"/>
+			<property name="format" value="\.printStackTrace\(\)"/>
+			<property name="ignoreComments" value="true"/>
+			<property name="message" value="Using Throwable.printStackTrace() is forbidden. Use logger to print exception"/>
+		</module>
+	</module>
+
+	<module name="NewlineAtEndOfFile"/>
+	<module name="SuppressWarningsFilter"/>
+</module>

config/code-formatter/eclipse.importorder

@@ -0,0 +1,8 @@
+#Import Order
+0=java
+1=javax
+2=org
+3=com
+4=
+5=jadx
+6=\#

config/code-formatter/eclipse.xml

@@ -0,0 +1,348 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="16">
+    <profile kind="CodeFormatterProfile" name="jadx eclipse" version="16">
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_with_spaces" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.disabling_tag" value="@formatter:off"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="48"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.enabling_tag" value="@formatter:on"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_logical_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="100"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_on_off_tags" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_method_body_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_additive_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_shift_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_lambda_body" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_parameters" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_loops" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_relational_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation" value="separate_lines_if_wrapped"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_module_statements" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="48"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_method_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_wrapped_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_conditional_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_shift_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines" value="2147483647"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_code_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assignment_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_arguments" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_label" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_relational_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_tag_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_string_concatenation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_logical_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_additive_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_lines_in_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="tab"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_string_concatenation" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.lineSplit" value="140"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+    </profile>
+</profiles>

config/jflex/.gitignore

@@ -0,0 +1 @@
+SmaliTokenMaker.java

config/jflex/README.md

@@ -0,0 +1,5 @@
+Refer to the following instructions to modify and use to generate SmaliTokenMarker
+
+```shell
+jflex SmaliTokenMaker.flex --skel skeleton.default
+```

config/jflex/SmaliTokenMaker.flex

@@ -0,0 +1,681 @@
+/*
+ * Generated on 11/22/21, 8:58 PM
+ */
+package jadx.gui.ui.codeearea;
+
+import java.io.*;
+import javax.swing.text.Segment;
+
+import org.fife.ui.rsyntaxtextarea.*;
+
+
+/**
+ * 用于Smali代码高亮
+ * MartinKay@qq.com
+ */
+%%
+
+%public
+%class SmaliTokenMaker
+%extends AbstractJFlexCTokenMaker
+%unicode
+/* Case sensitive */
+%type org.fife.ui.rsyntaxtextarea.Token
+
+
+%{
+
+
+	/**
+	 * Constructor.  This must be here because JFlex does not generate a
+	 * no-parameter constructor.
+	 */
+	public SmaliTokenMaker() {
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param tokenType The token's type.
+	 * @see #addToken(int, int, int)
+	 */
+	private void addHyperlinkToken(int start, int end, int tokenType) {
+		int so = start + offsetShift;
+		addToken(zzBuffer, start,end, tokenType, so, true);
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param tokenType The token's type.
+	 */
+	private void addToken(int tokenType) {
+		addToken(zzStartRead, zzMarkedPos-1, tokenType);
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param tokenType The token's type.
+	 * @see #addHyperlinkToken(int, int, int)
+	 */
+	private void addToken(int start, int end, int tokenType) {
+		int so = start + offsetShift;
+		addToken(zzBuffer, start,end, tokenType, so, false);
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param array The character array.
+	 * @param start The starting offset in the array.
+	 * @param end The ending offset in the array.
+	 * @param tokenType The token's type.
+	 * @param startOffset The offset in the document at which this token
+	 *        occurs.
+	 * @param hyperlink Whether this token is a hyperlink.
+	 */
+	public void addToken(char[] array, int start, int end, int tokenType,
+						int startOffset, boolean hyperlink) {
+		super.addToken(array, start,end, tokenType, startOffset, hyperlink);
+		zzStartRead = zzMarkedPos;
+	}
+
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public String[] getLineCommentStartAndEnd(int languageIndex) {
+		return new String[] { "#", null };
+	}
+
+
+	/**
+	 * Returns the first token in the linked list of tokens generated
+	 * from <code>text</code>.  This method must be implemented by
+	 * subclasses so they can correctly implement syntax highlighting.
+	 *
+	 * @param text The text from which to get tokens.
+	 * @param initialTokenType The token type we should start with.
+	 * @param startOffset The offset into the document at which
+	 *        <code>text</code> starts.
+	 * @return The first <code>Token</code> in a linked list representing
+	 *         the syntax highlighted text.
+	 */
+	public Token getTokenList(Segment text, int initialTokenType, int startOffset) {
+
+		resetTokenList();
+		this.offsetShift = -text.offset + startOffset;
+
+		// Start off in the proper state.
+		int state = Token.NULL;
+		switch (initialTokenType) {
+			/* No multi-line comments */
+			/* No documentation comments */
+			default:
+				state = Token.NULL;
+		}
+
+		s = text;
+		try {
+			yyreset(zzReader);
+			yybegin(state);
+			return yylex();
+		} catch (IOException ioe) {
+			ioe.printStackTrace();
+			return new TokenImpl();
+		}
+
+	}
+
+
+	/**
+	 * Refills the input buffer.
+	 *
+	 * @return      <code>true</code> if EOF was reached, otherwise
+	 *              <code>false</code>.
+	 */
+	private boolean zzRefill() {
+		return zzCurrentPos>=s.offset+s.count;
+	}
+
+
+	/**
+	 * Resets the scanner to read from a new input stream.
+	 * Does not close the old reader.
+	 *
+	 * All internal variables are reset, the old input stream
+	 * <b>cannot</b> be reused (internal buffer is discarded and lost).
+	 * Lexical state is set to <tt>YY_INITIAL</tt>.
+	 *
+	 * @param reader   the new input stream
+	 */
+	public final void yyreset(Reader reader) {
+		// 's' has been updated.
+		zzBuffer = s.array;
+		/*
+		 * We replaced the line below with the two below it because zzRefill
+		 * no longer "refills" the buffer (since the way we do it, it's always
+		 * "full" the first time through, since it points to the segment's
+		 * array).  So, we assign zzEndRead here.
+		 */
+		//zzStartRead = zzEndRead = s.offset;
+		zzStartRead = s.offset;
+		zzEndRead = zzStartRead + s.count - 1;
+		zzCurrentPos = zzMarkedPos = zzPushbackPos = s.offset;
+		zzLexicalState = YYINITIAL;
+		zzReader = reader;
+		zzAtBOL  = true;
+		zzAtEOF  = false;
+	}
+
+
+%}
+
+Letter							= [A-Za-z]
+LetterOrUnderscore				= ({Letter}|"_")
+NonzeroDigit						= [1-9]
+Digit							= ("0"|{NonzeroDigit})
+HexDigit							= ({Digit}|[A-Fa-f])
+OctalDigit						= ([0-7])
+AnyCharacterButApostropheOrBackSlash	= ([^\\'])
+AnyCharacterButDoubleQuoteOrBackSlash	= ([^\\\"\n])
+EscapedSourceCharacter				= ("u"{HexDigit}{HexDigit}{HexDigit}{HexDigit})
+Escape							= ("\\"(([btnfr\"'\\])|([0123]{OctalDigit}?{OctalDigit}?)|({OctalDigit}{OctalDigit}?)|{EscapedSourceCharacter}))
+NonSeparator						= ([^\t\f\r\n\ \(\)\{\}\[\]\;\,\.\=\>\<\!\~\?\:\+\-\*\/\&\|\^\%\"\']|"#"|"\\")
+IdentifierStart					= ({LetterOrUnderscore}|"$")
+IdentifierPart						= ({IdentifierStart}|{Digit}|("\\"{EscapedSourceCharacter}))
+
+LineTerminator				= (\n)
+WhiteSpace				= ([ \t\f]+)
+
+CharLiteral	= ([\']({AnyCharacterButApostropheOrBackSlash}|{Escape})[\'])
+UnclosedCharLiteral			= ([\'][^\'\n]*)
+ErrorCharLiteral			= ({UnclosedCharLiteral}[\'])
+StringLiteral				= ([\"]({AnyCharacterButDoubleQuoteOrBackSlash}|{Escape})*[\"])
+UnclosedStringLiteral		= ([\"]([\\].|[^\\\"])*[^\"]?)
+ErrorStringLiteral			= ({UnclosedStringLiteral}[\"])
+
+/* No multi-line comments */
+/* No documentation comments */
+LineCommentBegin			= "#"
+
+IntegerLiteral			= ({Digit}+)
+HexLiteral			= (0x{HexDigit}+)
+FloatLiteral			= (({Digit}+)("."{Digit}+)?(e[+-]?{Digit}+)? | ({Digit}+)?("."{Digit}+)(e[+-]?{Digit}+)?)
+ErrorNumberFormat			= (({IntegerLiteral}|{HexLiteral}|{FloatLiteral}){NonSeparator}+)
+BooleanLiteral				= ("true"|"false")
+
+Separator					= ([\(\)\{\}\[\]])
+Separator2				= ([\;,.])
+
+Identifier				= ({IdentifierStart}{IdentifierPart}*)
+
+URLGenDelim				= ([:\/\?#\[\]@])
+URLSubDelim				= ([\!\$&'\(\)\*\+,;=])
+URLUnreserved			= ({LetterOrUnderscore}|{Digit}|[\-\.\~])
+URLCharacter			= ({URLGenDelim}|{URLSubDelim}|{URLUnreserved}|[%])
+URLCharacters			= ({URLCharacter}*)
+URLEndCharacter			= ([\/\$]|{Letter}|{Digit})
+URL						= (((https?|f(tp|ile))"://"|"www.")({URLCharacters}{URLEndCharacter})?)
+
+
+/*  Custom Regex  */
+/* fully-qualified name Rules  */
+SimpleName = ([a-zA-Z0-9_$]*)
+QUALIFIED_TYPE_NAME = ("L"({SimpleName}{SLASH})*{SimpleName}*";")
+/* Types */
+VOID_TYPE = ("V")
+BOOLEAN_TYPE = ("Z")
+BYTE_TYPE = ("B")
+SHORT_TYPE = ("S")
+CHAR_TYPE = ("C")
+INT_TYPE = ("I")
+LONG_TYPE = ("J")
+FLOAT_TYPE = ("F")
+DOUBLE_TYPE = ("D")
+/* Multi Args Types Highlight  */
+MULTI_ARGS_TYPES = (({BOOLEAN_TYPE}|{BYTE_TYPE}|{SHORT_TYPE}|{CHAR_TYPE}|{INT_TYPE}|{LONG_TYPE}|{FLOAT_TYPE}|{DOUBLE_TYPE})+);
+
+/* Types fully-qualified name */
+COMPOUND_METHOD_ARG_LITERAL = (({BOOLEAN_TYPE}|{BYTE_TYPE}|{SHORT_TYPE}|{CHAR_TYPE}|{INT_TYPE}|{LONG_TYPE}|{FLOAT_TYPE}|{DOUBLE_TYPE})+{QUALIFIED_TYPE_NAME})
+
+
+LBRACK = ("[")
+RBRACK = ("]")
+LPAREN = ("(")
+RPAREN = (")")
+LBRACE = ("{")
+RBRACE = ("}")
+COLON = (":")
+ASSIGN = ("=")
+DOT = (".")
+SUB = ("-")
+COMMA = (",")
+SLASH = ("/")
+LT = ("<")
+GT = (">")
+ARROW = ("->")
+SEMI = (";")
+ARROW_FUNCTION = ({ARROW}[a-zA-Z_$<>]*)
+CustomSeparator = ({Separator}|{ARROW_FUNCTION})
+
+/* Register */
+VREGISTER = ("v"("0"|[1-9])*)
+PREGISTER = ("p"("0"|[1-9])*)
+
+/* Flags  */
+FLAG_PSWITCH = (":pswitch_"{SimpleName})
+FLAG_PSWITCH_DATA = (":pswitch_data_"{SimpleName})
+FLAG_GOTO = (":goto_"{SimpleName})
+FLAG_COND = (":cond_"{SimpleName})
+FLAG_TRY_START = (":try_start_"{SimpleName})
+FLAG_TRY_END = (":try_end_"{SimpleName})
+FLAG_CATCH = (":catch_"{SimpleName})
+FLAG_CATCHALL = (":catchall_"{SimpleName})
+FLAG_ARRAY = (":array_"{SimpleName})
+
+/* No string state */
+/* No char state */
+/* No MLC state */
+/* No documentation comment state */
+%state EOL_COMMENT
+
+%%
+
+<YYINITIAL> {
+
+	/* Keywords Instructions Highlight */
+"nop" |
+"move" |
+"move/from16" |
+"move/16" |
+"move-wide" |
+"move-wide/from16" |
+"move-wide/16" |
+"move-object" |
+"move-object/from16" |
+"move-object/16" |
+"move-result" |
+"move-result-wide" |
+"move-result-object" |
+"move-exception" |
+"return-void" |
+"return" |
+"return-wide" |
+"return-object" |
+"const/4" |
+"const/16" |
+"const" |
+"const/high16" |
+"const-wide/16" |
+"const-wide/32" |
+"const-wide" |
+"const-wide/high16" |
+"const-string" |
+"const-string/jumbo" |
+"const-class" |
+"monitor-enter" |
+"monitor-exit" |
+"check-cast" |
+"instance-of" |
+"array-length" |
+"new-instance" |
+"new-array" |
+"filled-new-array" |
+"filled-new-array/range" |
+"fill-array-data" |
+"throw" |
+"goto" |
+"goto/16" |
+"goto/32" |
+"cmpl-float" |
+"cmpg-float" |
+"cmpl-double" |
+"cmpg-double" |
+"cmp-long" |
+"if-eq" |
+"if-ne" |
+"if-lt" |
+"if-ge" |
+"if-gt" |
+"if-le" |
+"if-eqz" |
+"if-nez" |
+"if-ltz" |
+"if-gez" |
+"if-gtz" |
+"if-lez" |
+"aget" |
+"aget-wide" |
+"aget-object" |
+"aget-boolean" |
+"aget-byte" |
+"aget-char" |
+"aget-short" |
+"aput" |
+"aput-wide" |
+"aput-object" |
+"aput-boolean" |
+"aput-byte" |
+"aput-char" |
+"aput-short" |
+"iget" |
+"iget-wide" |
+"iget-object" |
+"iget-boolean" |
+"iget-byte" |
+"iget-char" |
+"iget-short" |
+"iput" |
+"iput-wide" |
+"iput-object" |
+"iput-boolean" |
+"iput-byte" |
+"iput-char" |
+"iput-short" |
+"sget" |
+"sget-wide" |
+"sget-object" |
+"sget-boolean" |
+"sget-byte" |
+"sget-char" |
+"sget-short" |
+"sput" |
+"sput-wide" |
+"sput-object" |
+"sput-boolean" |
+"sput-byte" |
+"sput-char" |
+"sput-short" |
+"invoke-virtual" |
+"invoke-super" |
+"invoke-direct" |
+"invoke-static" |
+"invoke-interface" |
+"invoke-virtual/range" |
+"invoke-super/range" |
+"invoke-direct/range" |
+"invoke-static/range" |
+"invoke-interface/range" |
+"neg-int" |
+"not-int" |
+"neg-long" |
+"not-long" |
+"neg-float" |
+"neg-double" |
+"int-to-long" |
+"int-to-float" |
+"int-to-double" |
+"long-to-int" |
+"long-to-float" |
+"long-to-double" |
+"float-to-int" |
+"float-to-long" |
+"float-to-double" |
+"double-to-int" |
+"double-to-long" |
+"double-to-float" |
+"int-to-byte" |
+"int-to-char" |
+"int-to-short" |
+"add-int" |
+"sub-int" |
+"mul-int" |
+"div-int" |
+"rem-int" |
+"and-int" |
+"or-int" |
+"xor-int" |
+"shl-int" |
+"shr-int" |
+"ushr-int" |
+"add-long" |
+"sub-long" |
+"mul-long" |
+"div-long" |
+"rem-long" |
+"and-long" |
+"or-long" |
+"xor-long" |
+"shl-long" |
+"shr-long" |
+"ushr-long" |
+"add-float" |
+"sub-float" |
+"mul-float" |
+"div-float" |
+"rem-float" |
+"add-double" |
+"sub-double" |
+"mul-double" |
+"div-double" |
+"rem-double" |
+"add-int/2addr" |
+"sub-int/2addr" |
+"mul-int/2addr" |
+"div-int/2addr" |
+"rem-int/2addr" |
+"and-int/2addr" |
+"or-int/2addr" |
+"xor-int/2addr" |
+"shl-int/2addr" |
+"shr-int/2addr" |
+"ushr-int/2addr" |
+"add-long/2addr" |
+"sub-long/2addr" |
+"mul-long/2addr" |
+"div-long/2addr" |
+"rem-long/2addr" |
+"and-long/2addr" |
+"or-long/2addr" |
+"xor-long/2addr" |
+"shl-long/2addr" |
+"shr-long/2addr" |
+"ushr-long/2addr" |
+"add-float/2addr" |
+"sub-float/2addr" |
+"mul-float/2addr" |
+"div-float/2addr" |
+"rem-float/2addr" |
+"add-double/2addr" |
+"sub-double/2addr" |
+"mul-double/2addr" |
+"div-double/2addr" |
+"rem-double/2addr" |
+"add-int/lit16" |
+"rsub-int" |
+"mul-int/lit16" |
+"div-int/lit16" |
+"rem-int/lit16" |
+"and-int/lit16" |
+"or-int/lit16" |
+"xor-int/lit16" |
+"add-int/lit8" |
+"rsub-int/lit8" |
+"mul-int/lit8" |
+"div-int/lit8" |
+"rem-int/lit8" |
+"and-int/lit8" |
+"or-int/lit8" |
+"xor-int/lit8" |
+"shl-int/lit8" |
+"shr-int/lit8" |
+"ushr-int/lit8" |
+"invoke-polymorphic" |
+"invoke-polymorphic/range" |
+"invoke-custom" |
+"invoke-custom/range" |
+"const-method-handle" |
+"const-method-type" |
+"packed-switch" |
+"sparse-switch"		{ addToken(Token.FUNCTION); }
+
+	/* Keywords Modifiers(IDENTIFIER标识符、修饰符) Highlight */
+"public" |
+"private" |
+"protected" |
+"final" |
+"annotation" |
+"static" |
+"synthetic" |
+"constructor" |
+"abstract" |
+"enum" |
+"interface" |
+"transient" |
+"bridge" |
+"declared-synchronized" |
+"volatile" |
+"strictfp" |
+"varargs" |
+"native"		{ addToken(Token.RESERVED_WORD); }
+
+
+
+
+	/* Keywords Directives Highlight */
+".method" |
+".end method" |
+".implements" |
+".class" |
+".prologue" |
+".source" |
+".super" |
+".field" |
+".end field" |
+".registers" |
+".locals" |
+".param" |
+".line" |
+".catch" |
+".catchall" |
+".annotation" |
+".end annotation" |
+".local" |
+".end local" |
+".restart local" |
+".packed-switch" |
+".end packed-switch" |
+".array-data" |
+".end array-data" |
+".sparse-switch" |
+".end sparse-switch" |
+".end param"		{ addToken(Token.RESERVED_WORD_2); }
+
+
+	/* VARIABLE Register Highlight */
+{VREGISTER} |
+{PREGISTER}		{ addToken(Token.VARIABLE); }
+
+
+
+	/* Data types Highlight */
+{QUALIFIED_TYPE_NAME} |
+{COMPOUND_METHOD_ARG_LITERAL} |
+{MULTI_ARGS_TYPES} |
+{QUALIFIED_TYPE_NAME} |
+{VOID_TYPE} |
+{BOOLEAN_TYPE} |
+{BYTE_TYPE} |
+{SHORT_TYPE} |
+{CHAR_TYPE} |
+{INT_TYPE} |
+{LONG_TYPE} |
+{FLOAT_TYPE} |
+{DOUBLE_TYPE} 	{ addToken(Token.DATA_TYPE); }
+
+ /* FLAGS */
+{FLAG_PSWITCH} |
+{FLAG_PSWITCH_DATA} |
+{FLAG_GOTO} |
+{FLAG_COND} |
+{FLAG_TRY_START} |
+{FLAG_TRY_END} |
+{FLAG_CATCHALL} |
+{FLAG_ARRAY} |
+{FLAG_CATCH}  	{ addToken(Token.MARKUP_TAG_NAME); }
+
+	/* Functions */
+	/* No functions */
+
+	{BooleanLiteral}			{ addToken(Token.LITERAL_BOOLEAN); }
+
+	{LineTerminator}				{ addNullToken(); return firstToken; }
+
+	{Identifier}					{ addToken(Token.IDENTIFIER); }
+
+	{WhiteSpace}					{ addToken(Token.WHITESPACE); }
+
+	/* String/Character literals. */
+	{CharLiteral}				{ addToken(Token.LITERAL_CHAR); }
+{UnclosedCharLiteral}		{ addToken(Token.ERROR_CHAR); addNullToken(); return firstToken; }
+{ErrorCharLiteral}			{ addToken(Token.ERROR_CHAR); }
+	{StringLiteral}				{ addToken(Token.LITERAL_STRING_DOUBLE_QUOTE); }
+{UnclosedStringLiteral}		{ addToken(Token.ERROR_STRING_DOUBLE); addNullToken(); return firstToken; }
+{ErrorStringLiteral}			{ addToken(Token.ERROR_STRING_DOUBLE); }
+
+	/* Comment literals. */
+	/* No multi-line comments */
+	/* No documentation comments */
+	{LineCommentBegin}			{ start = zzMarkedPos-1; yybegin(EOL_COMMENT); }
+
+	/* Separators. */
+	{CustomSeparator}					{ addToken(Token.SEPARATOR); }
+	{Separator2}					{ addToken(Token.IDENTIFIER); }
+
+	/* Operators. */
+"!" |
+";" |
+"." |
+"=" |
+"/" |
+"'" |
+"(" |
+")" |
+"," |
+"->" |
+";->" |
+"<" |
+">" |
+"@" |
+"[" |
+"]" |
+"{" |
+"}"		{ addToken(Token.OPERATOR); }
+
+	/* Numbers */
+	{IntegerLiteral}				{ addToken(Token.LITERAL_NUMBER_DECIMAL_INT); }
+	{HexLiteral}					{ addToken(Token.LITERAL_NUMBER_HEXADECIMAL); }
+	{FloatLiteral}					{ addToken(Token.LITERAL_NUMBER_FLOAT); }
+	{ErrorNumberFormat}			{ addToken(Token.ERROR_NUMBER_FORMAT); }
+
+	/* Ended with a line not in a string or comment. */
+	<<EOF>>						{ addNullToken(); return firstToken; }
+
+	/* Catch any other (unhandled) characters. */
+	.							{ addToken(Token.IDENTIFIER); }
+
+}
+
+
+/* No char state */
+
+/* No string state */
+
+/* No multi-line comment state */
+
+/* No documentation comment state */
+
+<EOL_COMMENT> {
+	[^hwf\n]+				{}
+	{URL}					{ int temp=zzStartRead; addToken(start,zzStartRead-1, Token.COMMENT_EOL); addHyperlinkToken(temp,zzMarkedPos-1, Token.COMMENT_EOL); start = zzMarkedPos; }
+	[hwf]					{}
+	\n						{ addToken(start,zzStartRead-1, Token.COMMENT_EOL); addNullToken(); return firstToken; }
+	<<EOF>>					{ addToken(start,zzStartRead-1, Token.COMMENT_EOL); addNullToken(); return firstToken; }
+}
+

config/jflex/skeleton.default

@@ -0,0 +1,243 @@
+
+  /** This character denotes the end of file */
+  public static final int YYEOF = -1;
+
+  /** initial size of the lookahead buffer */
+--- private static final int ZZ_BUFFERSIZE = ...;
+
+  /** lexical states */
+---  lexical states, charmap
+
+  /* error codes */
+  private static final int ZZ_UNKNOWN_ERROR = 0;
+  private static final int ZZ_NO_MATCH = 1;
+  private static final int ZZ_PUSHBACK_2BIG = 2;
+
+  /* error messages for the codes above */
+  private static final String ZZ_ERROR_MSG[] = {
+    "Unkown internal scanner error",
+    "Error: could not match input",
+    "Error: pushback value was too large"
+  };
+
+--- isFinal list
+  /** the input device */
+  private java.io.Reader zzReader;
+
+  /** the current state of the DFA */
+  private int zzState;
+
+  /** the current lexical state */
+  private int zzLexicalState = YYINITIAL;
+
+  /** this buffer contains the current text to be matched and is
+      the source of the yytext() string */
+  private char zzBuffer[];
+
+  /** the textposition at the last accepting state */
+  private int zzMarkedPos;
+
+  /** the textposition at the last state to be included in yytext */
+  private int zzPushbackPos;
+
+  /** the current text position in the buffer */
+  private int zzCurrentPos;
+
+  /** startRead marks the beginning of the yytext() string in the buffer */
+  private int zzStartRead;
+
+  /** endRead marks the last character in the buffer, that has been read
+      from input */
+  private int zzEndRead;
+
+  /** number of newlines encountered up to the start of the matched text */
+  private int yyline;
+
+  /** the number of characters up to the start of the matched text */
+  private int yychar;
+
+  /**
+   * the number of characters from the last newline up to the start of the 
+   * matched text
+   */
+  private int yycolumn;
+
+  /** 
+   * zzAtBOL == true <=> the scanner is currently at the beginning of a line
+   */
+  private boolean zzAtBOL = true;
+
+  /** zzAtEOF == true <=> the scanner is at the EOF */
+  private boolean zzAtEOF;
+
+--- user class code
+
+  /**
+   * Creates a new scanner
+   * There is also a java.io.InputStream version of this constructor.
+   *
+   * @param   in  the java.io.Reader to read input from.
+   */
+--- constructor declaration
+
+
+  /**
+   * Closes the input stream.
+   */
+  public final void yyclose() throws java.io.IOException {
+    zzAtEOF = true;            /* indicate end of file */
+    zzEndRead = zzStartRead;  /* invalidate buffer    */
+
+    if (zzReader != null)
+      zzReader.close();
+  }
+
+
+  /**
+   * Enters a new lexical state
+   *
+   * @param newState the new lexical state
+   */
+  public final void yybegin(int newState) {
+    zzLexicalState = newState;
+  }
+
+
+  /**
+   * Returns the text matched by the current regular expression.
+   */
+  public final String yytext() {
+    return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
+  }
+
+
+  /**
+   * Returns the character at position <tt>pos</tt> from the 
+   * matched text. 
+   * 
+   * It is equivalent to yytext().charAt(pos), but faster
+   *
+   * @param pos the position of the character to fetch. 
+   *            A value from 0 to yylength()-1.
+   *
+   * @return the character at position pos
+   */
+  public final char yycharat(int pos) {
+    return zzBuffer[zzStartRead+pos];
+  }
+
+
+  /**
+   * Returns the length of the matched text region.
+   */
+  public final int yylength() {
+    return zzMarkedPos-zzStartRead;
+  }
+
+
+  /**
+   * Reports an error that occured while scanning.
+   *
+   * In a wellformed scanner (no or only correct usage of 
+   * yypushback(int) and a match-all fallback rule) this method 
+   * will only be called with things that "Can't Possibly Happen".
+   * If this method is called, something is seriously wrong
+   * (e.g. a JFlex bug producing a faulty scanner etc.).
+   *
+   * Usual syntax/scanner level error handling should be done
+   * in error fallback rules.
+   *
+   * @param   errorCode  the code of the errormessage to display
+   */
+--- zzScanError declaration
+    String message;
+    try {
+      message = ZZ_ERROR_MSG[errorCode];
+    }
+    catch (ArrayIndexOutOfBoundsException e) {
+      message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
+    }
+
+--- throws clause
+  } 
+
+
+  /**
+   * Pushes the specified amount of characters back into the input stream.
+   *
+   * They will be read again by then next call of the scanning method
+   *
+   * @param number  the number of characters to be read again.
+   *                This number must not be greater than yylength()!
+   */
+--- yypushback decl (contains zzScanError exception)
+    if ( number > yylength() )
+      zzScanError(ZZ_PUSHBACK_2BIG);
+
+    zzMarkedPos -= number;
+  }
+
+
+--- zzDoEOF
+  /**
+   * Resumes scanning until the next regular expression is matched,
+   * the end of input is encountered or an I/O-Error occurs.
+   *
+   * @return      the next token
+   * @exception   java.io.IOException  if any I/O-Error occurs
+   */
+--- yylex declaration
+    int zzInput;
+    int zzAction;
+
+    // cached fields:
+    int zzCurrentPosL;
+    int zzMarkedPosL;
+    int zzEndReadL = zzEndRead;
+    char [] zzBufferL = zzBuffer;
+    char [] zzCMapL = ZZ_CMAP;
+
+--- local declarations
+
+    while (true) {
+      zzMarkedPosL = zzMarkedPos;
+
+--- start admin (line, char, col count)
+      zzAction = -1;
+
+      zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
+  
+--- start admin (lexstate etc)
+
+      zzForAction: {
+        while (true) {
+    
+--- next input, line, col, char count, next transition, isFinal action
+            zzAction = zzState;
+            zzMarkedPosL = zzCurrentPosL;
+--- line count update
+          }
+
+        }
+      }
+
+      // store back cached position
+      zzMarkedPos = zzMarkedPosL;
+--- char count update
+
+--- actions
+        default: 
+          if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
+            zzAtEOF = true;
+--- eofvalue
+          } 
+          else {
+--- no match
+          }
+      }
+    }
+  }
+
+--- main
+
+}

gradle.properties

@@ -0,0 +1,11 @@
+org.gradle.warning.mode=all
+org.gradle.parallel=true
+
+# Flags for google-java-format (optimize imports by spotless) for Java >= 16.
+# Java < 9 will ignore unsupported flags (thanks to -XX:+IgnoreUnrecognizedVMOptions)
+org.gradle.jvmargs=-XX:+IgnoreUnrecognizedVMOptions \
+  --add-exports='jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED'

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionSha256Sum=f6b8596b10cce501591e92f229816aa4046424f3b24d771751b06779d58c8ec4
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-all.zip

gradlew

@@ -1,79 +1,129 @@
-#!/usr/bin/env bash
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# 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
+#
+#      https://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.
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${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='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
-warn ( ) {
+warn () {
     echo "$*"
-}
+} >&2
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # 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
-    ;;
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=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"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
-APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -82,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -90,75 +140,101 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     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=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    echo "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,4 +1,20 @@
-@if "%DEBUG%" == "" @echo off
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -8,20 +24,23 @@
 @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=.
+if "%DIRNAME%"=="" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@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="-Xmx64m" "-Xms64m"
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,44 +64,26 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windowz 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.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-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
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

jadx-cli/build.gradle

@@ -1,20 +1,30 @@
-apply plugin: 'application'
-
-mainClassName = 'jadx.cli.JadxCLI'
-applicationName = 'jadx'
+plugins {
+	id 'application'
+}
 
 dependencies {
-    compile(project(':jadx-core'))
-    compile 'com.beust:jcommander:1.47'
-    compile 'ch.qos.logback:logback-classic:1.1.2'
+	implementation(project(':jadx-core'))
+
+	runtimeOnly(project(':jadx-plugins:jadx-dex-input'))
+	runtimeOnly(project(':jadx-plugins:jadx-java-input'))
+	runtimeOnly(project(':jadx-plugins:jadx-java-convert'))
+	runtimeOnly(project(':jadx-plugins:jadx-smali-input'))
+
+	implementation 'com.beust:jcommander:1.82'
+	implementation 'ch.qos.logback:logback-classic:1.3.4'
+}
+
+application {
+	applicationName = 'jadx'
+	mainClass.set('jadx.cli.JadxCLI')
+	applicationDefaultJvmArgs = ['-Xms128M', '-XX:MaxRAMPercentage=70.0', '-XX:+UseG1GC']
 }
 
 applicationDistribution.with {
-    into('') {
-        from '../.'
-        include 'README.md'
-        include 'NOTICE'
-        include 'LICENSE'
-    }
+	into('') {
+		from '../.'
+		include 'README.md'
+		include 'NOTICE'
+		include 'LICENSE'
+	}
 }
-

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

@@ -0,0 +1,213 @@
+package jadx.cli;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.Supplier;
+
+import org.jetbrains.annotations.Nullable;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.ParameterDescription;
+import com.beust.jcommander.ParameterException;
+import com.beust.jcommander.Parameterized;
+
+import jadx.api.JadxDecompiler;
+import jadx.api.plugins.JadxPlugin;
+import jadx.api.plugins.JadxPluginInfo;
+import jadx.api.plugins.JadxPluginManager;
+import jadx.api.plugins.options.JadxPluginOptions;
+import jadx.api.plugins.options.OptionDescription;
+import jadx.core.utils.Utils;
+
+public class JCommanderWrapper<T> {
+	private final JCommander jc;
+
+	public JCommanderWrapper(T obj) {
+		this.jc = JCommander.newBuilder().addObject(obj).build();
+	}
+
+	public boolean parse(String[] args) {
+		try {
+			jc.parse(args);
+			return true;
+		} catch (ParameterException e) {
+			System.err.println("Arguments parse error: " + e.getMessage());
+			printUsage();
+			return false;
+		}
+	}
+
+	public void overrideProvided(T obj) {
+		List<ParameterDescription> fieldsParams = jc.getParameters();
+		List<ParameterDescription> parameters = new ArrayList<>(1 + fieldsParams.size());
+		parameters.add(jc.getMainParameterValue());
+		parameters.addAll(fieldsParams);
+		for (ParameterDescription parameter : parameters) {
+			if (parameter.isAssigned()) {
+				// copy assigned field value to obj
+				Parameterized parameterized = parameter.getParameterized();
+				Object providedValue = parameterized.get(parameter.getObject());
+				Object newValue = mergeValues(parameterized.getType(), providedValue, () -> parameterized.get(obj));
+				parameterized.set(obj, newValue);
+			}
+		}
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	private static Object mergeValues(Class<?> type, Object value, Supplier<Object> prevValueProvider) {
+		if (type.isAssignableFrom(Map.class)) {
+			// merge maps instead replacing whole map
+			Map prevMap = (Map) prevValueProvider.get();
+			return Utils.mergeMaps(prevMap, (Map) value); // value map will override keys in prevMap
+		}
+		// simple override
+		return value;
+	}
+
+	public void printUsage() {
+		// print usage in not sorted fields order (by default its sorted by description)
+		PrintStream out = System.out;
+		out.println();
+		out.println("jadx - dex to java decompiler, version: " + JadxDecompiler.getVersion());
+		out.println();
+		out.println("usage: jadx [options] " + jc.getMainParameterDescription());
+		out.println("options:");
+
+		List<ParameterDescription> params = jc.getParameters();
+		Map<String, ParameterDescription> paramsMap = new LinkedHashMap<>(params.size());
+		int maxNamesLen = 0;
+		for (ParameterDescription p : params) {
+			paramsMap.put(p.getParameterized().getName(), p);
+			int len = p.getNames().length();
+			if (len > maxNamesLen) {
+				maxNamesLen = len;
+			}
+		}
+		maxNamesLen += 3;
+
+		JadxCLIArgs args = (JadxCLIArgs) jc.getObjects().get(0);
+		for (Field f : getFields(args.getClass())) {
+			String name = f.getName();
+			ParameterDescription p = paramsMap.get(name);
+			if (p == null || p.getParameter().hidden()) {
+				continue;
+			}
+			StringBuilder opt = new StringBuilder();
+			opt.append("  ").append(p.getNames());
+			String description = p.getDescription();
+			addSpaces(opt, maxNamesLen - opt.length());
+			if (description.contains("\n")) {
+				String[] lines = description.split("\n");
+				opt.append("- ").append(lines[0]);
+				for (int i = 1; i < lines.length; i++) {
+					opt.append('\n');
+					addSpaces(opt, maxNamesLen + 2);
+					opt.append(lines[i]);
+				}
+			} else {
+				opt.append("- ").append(description);
+			}
+			String defaultValue = getDefaultValue(args, f, opt);
+			if (defaultValue != null && !description.contains("(default)")) {
+				opt.append(", default: ").append(defaultValue);
+			}
+			out.println(opt);
+		}
+		out.println(appendPluginOptions(maxNamesLen));
+		out.println();
+		out.println("Examples:");
+		out.println("  jadx -d out classes.dex");
+		out.println("  jadx --rename-flags \"none\" classes.dex");
+		out.println("  jadx --rename-flags \"valid, printable\" classes.dex");
+		out.println("  jadx --log-level ERROR app.apk");
+		out.println("  jadx -Pdex-input.verify-checksum=no app.apk");
+	}
+
+	/**
+	 * Get all declared fields of the specified class and all super classes
+	 */
+	private List<Field> getFields(Class<?> clazz) {
+		List<Field> fieldList = new ArrayList<>();
+		while (clazz != null) {
+			fieldList.addAll(Arrays.asList(clazz.getDeclaredFields()));
+			clazz = clazz.getSuperclass();
+		}
+		return fieldList;
+	}
+
+	@Nullable
+	private String getDefaultValue(JadxCLIArgs args, Field f, StringBuilder opt) {
+		try {
+			Class<?> fieldType = f.getType();
+			if (fieldType == int.class) {
+				return Integer.toString(f.getInt(args));
+			}
+			if (fieldType == String.class) {
+				return (String) f.get(args);
+			}
+			if (Enum.class.isAssignableFrom(fieldType)) {
+				Enum<?> val = (Enum<?>) f.get(args);
+				if (val != null) {
+					return val.name().toLowerCase(Locale.ROOT);
+				}
+			}
+		} catch (Exception e) {
+			// ignore
+		}
+		return null;
+	}
+
+	private static void addSpaces(StringBuilder str, int count) {
+		for (int i = 0; i < count; i++) {
+			str.append(' ');
+		}
+	}
+
+	private String appendPluginOptions(int maxNamesLen) {
+		StringBuilder sb = new StringBuilder();
+		JadxPluginManager pluginManager = new JadxPluginManager();
+		pluginManager.load();
+		int k = 1;
+		for (JadxPlugin plugin : pluginManager.getAllPlugins()) {
+			if (plugin instanceof JadxPluginOptions) {
+				if (appendPlugin(((JadxPluginOptions) plugin), sb, maxNamesLen, k)) {
+					k++;
+				}
+			}
+		}
+		if (sb.length() == 0) {
+			return "";
+		}
+		return "\nPlugin options (-P<name>=<value>):" + sb;
+	}
+
+	private boolean appendPlugin(JadxPluginOptions plugin, StringBuilder out, int maxNamesLen, int k) {
+		List<OptionDescription> descs = plugin.getOptionsDescriptions();
+		if (descs.isEmpty()) {
+			return false;
+		}
+		JadxPluginInfo pluginInfo = plugin.getPluginInfo();
+		out.append("\n ").append(k).append(") ");
+		out.append(pluginInfo.getPluginId()).append(": ").append(pluginInfo.getDescription());
+		for (OptionDescription desc : descs) {
+			StringBuilder opt = new StringBuilder();
+			opt.append("    - ").append(desc.name());
+			addSpaces(opt, maxNamesLen - opt.length());
+			opt.append("- ").append(desc.description());
+			if (!desc.values().isEmpty()) {
+				opt.append(", values: ").append(desc.values());
+			}
+			if (desc.defaultValue() != null) {
+				opt.append(", default: ").append(desc.defaultValue());
+			}
+			out.append("\n").append(opt);
+		}
+		return true;
+	}
+}

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

@@ -1,68 +1,98 @@
 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.JadxArgs;
+import jadx.api.JadxDecompiler;
+import jadx.api.impl.NoOpCodeCache;
+import jadx.api.impl.SimpleCodeWriter;
+import jadx.cli.LogHelper.LogLevelEnum;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+import jadx.core.utils.files.FileUtils;
+
 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) {
+		int result = 0;
 		try {
-			JadxCLIArgs jadxArgs = new JadxCLIArgs();
-			if (processArgs(jadxArgs, args)) {
-				processAndSave(jadxArgs);
-			}
+			result = execute(args);
+		} catch (JadxArgsValidateException e) {
+			LOG.error("Incorrect arguments: {}", e.getMessage());
+			result = 1;
 		} catch (Throwable e) {
-			LOG.error("jadx error: {}", e.getMessage(), e);
-			System.exit(1);
+			LOG.error("Process error:", e);
+			result = 1;
+		} finally {
+			FileUtils.deleteTempRootDir();
+			System.exit(result);
 		}
 	}
 
-	static void processAndSave(JadxCLIArgs jadxArgs) throws JadxException {
-		JadxDecompiler jadx = new JadxDecompiler(jadxArgs);
-		jadx.setOutputDir(jadxArgs.getOutDir());
-		jadx.loadFiles(jadxArgs.getInput());
-		jadx.save();
-		if (jadx.getErrorsCount() != 0) {
-			jadx.printErrorsReport();
-			LOG.error("finished with errors");
-		} else {
-			LOG.info("done");
+	public static int execute(String[] args) {
+		JadxCLIArgs jadxArgs = new JadxCLIArgs();
+		if (jadxArgs.processArgs(args)) {
+			return processAndSave(jadxArgs);
 		}
+		return 0;
 	}
 
-	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";
+	private static int processAndSave(JadxCLIArgs cliArgs) {
+		LogHelper.initLogLevel(cliArgs);
+		LogHelper.setLogLevelsForLoadingStage();
+		JadxArgs jadxArgs = cliArgs.toJadxArgs();
+		jadxArgs.setCodeCache(new NoOpCodeCache());
+		jadxArgs.setCodeWriterProvider(SimpleCodeWriter::new);
+		try (JadxDecompiler jadx = new JadxDecompiler(jadxArgs)) {
+			jadx.load();
+			if (checkForErrors(jadx)) {
+				return 1;
+			}
+			LogHelper.setLogLevelsForDecompileStage();
+			if (!SingleClassMode.process(jadx, cliArgs)) {
+				save(jadx);
+			}
+			int errorsCount = jadx.getErrorsCount();
+			if (errorsCount != 0) {
+				jadx.printErrorsReport();
+				LOG.error("finished with errors, count: {}", errorsCount);
+			} else {
+				LOG.info("done");
 			}
-			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 0;
+	}
+
+	private static boolean checkForErrors(JadxDecompiler jadx) {
+		if (jadx.getRoot().getClasses().isEmpty()) {
+			if (jadx.getArgs().isSkipResources()) {
+				LOG.error("Load failed! No classes for decompile!");
+				return true;
+			}
+			if (!jadx.getArgs().isSkipSources()) {
+				LOG.warn("No classes to decompile; decoding resources only");
+				jadx.getArgs().setSkipSources(true);
+			}
+		}
+		if (jadx.getErrorsCount() > 0) {
+			LOG.error("Load with errors! Check log for details");
+			// continue processing
+			return false;
+		}
+		return false;
+	}
+
+	private static void save(JadxDecompiler jadx) {
+		if (LogHelper.getLogLevel() == LogLevelEnum.QUIET) {
+			jadx.save();
+		} else {
+			jadx.save(500, (done, total) -> {
+				int progress = (int) (done * 100.0 / total);
+				System.out.printf("INFO  - progress: %d of %d (%d%%)\r", done, total, progress);
+			});
+			// dumb line clear :)
+			System.out.print("                                                             \r");
 		}
-		return true;
 	}
 }

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

@@ -1,245 +1,560 @@
 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.EnumSet;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.beust.jcommander.JCommander;
+import com.beust.jcommander.DynamicParameter;
+import com.beust.jcommander.IStringConverter;
 import com.beust.jcommander.Parameter;
-import com.beust.jcommander.ParameterDescription;
-import com.beust.jcommander.ParameterException;
 
-public class JadxCLIArgs implements IJadxArgs {
+import jadx.api.CommentsLevel;
+import jadx.api.DecompilationMode;
+import jadx.api.JadxArgs;
+import jadx.api.JadxArgs.RenameEnum;
+import jadx.api.JadxArgs.UseKotlinMethodsForVarNames;
+import jadx.api.JadxDecompiler;
+import jadx.api.args.DeobfuscationMapFileMode;
+import jadx.api.args.ResourceNameSource;
+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(names = {"-d", "--output-dir"}, description = "output directory")
-	protected String outDirName;
+	@Parameter(description = "<input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab)")
+	protected List<String> files = new ArrayList<>(1);
 
-	@Parameter(names = {"-j", "--threads-count"}, description = "processing threads count")
-	protected int threadsCount = Runtime.getRuntime().availableProcessors();
+	@Parameter(names = { "-d", "--output-dir" }, description = "output directory")
+	protected String outDir;
 
-	@Parameter(names = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)")
-	protected boolean fallbackMode = false;
+	@Parameter(names = { "-ds", "--output-dir-src" }, description = "output directory for sources")
+	protected String outDirSrc;
 
-	@Parameter(names = {"-r", "--no-res"}, description = "do not decode resources")
+	@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;
 
-	@Parameter(names = {"-s", "--no-src"}, description = "do not decompile source code")
+	@Parameter(names = { "-s", "--no-src" }, description = "do not decompile source code")
 	protected boolean skipSources = false;
 
-	@Parameter(names = {"--show-bad-code"}, description = "show inconsistent code (incorrectly decompiled)")
+	@Parameter(names = { "--single-class" }, description = "decompile a single class, full name, raw or alias")
+	protected String singleClass = null;
+
+	@Parameter(names = { "--single-class-output" }, description = "file or dir for write if decompile a single class")
+	protected String singleClassOutput = null;
+
+	@Parameter(names = { "--output-format" }, description = "can be 'java' or 'json'")
+	protected String outputFormat = "java";
+
+	@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 = { "-m", "--decompilation-mode" },
+			description = "code output mode:"
+					+ "\n 'auto' - trying best options (default)"
+					+ "\n 'restructure' - restore code structure (normal java code)"
+					+ "\n 'simple' - simplified instructions (linear, with goto's)"
+					+ "\n 'fallback' - raw instructions without modifications",
+			converter = DecompilationModeConverter.class
+	)
+	protected DecompilationMode decompilationMode = DecompilationMode.AUTO;
+
+	@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-debug-info" }, description = "disable debug info")
+	protected boolean debugInfo = true;
 
-	@Parameter(names = {"-v", "--verbose"}, description = "verbose output")
-	protected boolean verbose = false;
+	@Parameter(names = { "--add-debug-lines" }, description = "add comments with debug line numbers if available")
+	protected boolean addDebugLines = false;
 
-	@Parameter(names = {"--deobf"}, description = "activate deobfuscation")
+	@Parameter(names = { "--no-inline-anonymous" }, description = "disable anonymous classes inline")
+	protected boolean inlineAnonymousClasses = true;
+
+	@Parameter(names = { "--no-inline-methods" }, description = "disable methods inline")
+	protected boolean inlineMethods = true;
+
+	@Parameter(names = "--no-finally", description = "don't extract finally block")
+	protected boolean extractFinally = true;
+
+	@Parameter(names = "--no-replace-consts", description = "don't replace constant value with matching constant field")
+	protected boolean replaceConsts = true;
+
+	@Parameter(names = { "--escape-unicode" }, description = "escape non latin characters in strings (with \\u)")
+	protected boolean escapeUnicode = false;
+
+	@Parameter(names = { "--respect-bytecode-access-modifiers" }, description = "don't change original access modifiers")
+	protected boolean respectBytecodeAccessModifiers = false;
+
+	@Parameter(names = { "--deobf" }, description = "activate deobfuscation")
 	protected boolean deobfuscationOn = false;
 
-	@Parameter(names = {"--deobf-min"}, description = "min length of name")
-	protected int deobfuscationMinLength = 2;
+	@Parameter(names = { "--deobf-min" }, description = "min length of name, renamed if shorter")
+	protected int deobfuscationMinLength = 3;
 
-	@Parameter(names = {"--deobf-max"}, description = "max length of name")
+	@Parameter(names = { "--deobf-max" }, description = "max length of name, renamed if longer")
 	protected int deobfuscationMaxLength = 64;
 
-	@Parameter(names = {"--deobf-rewrite-cfg"}, description = "force to save deobfuscation map")
-	protected boolean deobfuscationForceSave = false;
+	@Parameter(
+			names = { "--deobf-cfg-file" },
+			description = "deobfuscation map file, default: same dir and name as input file with '.jobf' extension"
+	)
+	protected String deobfuscationMapFile;
 
-	@Parameter(names = {"-h", "--help"}, description = "print this help", help = true)
+	@Parameter(
+			names = { "--deobf-cfg-file-mode" },
+			description = "set mode for handle deobfuscation map file:"
+					+ "\n 'read' - read if found, don't save (default)"
+					+ "\n 'read-or-save' - read if found, save otherwise (don't overwrite)"
+					+ "\n 'overwrite' - don't read, always save"
+					+ "\n 'ignore' - don't read and don't save",
+			converter = DeobfuscationMapFileModeConverter.class
+	)
+	protected DeobfuscationMapFileMode deobfuscationMapFileMode = DeobfuscationMapFileMode.READ;
+
+	@Parameter(names = { "--deobf-use-sourcename" }, description = "use source file name as class name alias")
+	protected boolean deobfuscationUseSourceNameAsAlias = false;
+
+	@Parameter(names = { "--deobf-parse-kotlin-metadata" }, description = "parse kotlin metadata to class and package names")
+	protected boolean deobfuscationParseKotlinMetadata = false;
+
+	@Parameter(
+			names = { "--deobf-res-name-source" },
+			description = "better name source for resources:"
+					+ "\n 'auto' - automatically select best name (default)"
+					+ "\n 'resources' - use resources names"
+					+ "\n 'code' - use R class fields names",
+			converter = ResourceNameSourceConverter.class
+	)
+	protected ResourceNameSource resourceNameSource = ResourceNameSource.AUTO;
+
+	@Parameter(
+			names = { "--use-kotlin-methods-for-var-names" },
+			description = "use kotlin intrinsic methods to rename variables, values: disable, apply, apply-and-hide",
+			converter = UseKotlinMethodsForVarNamesConverter.class
+	)
+	protected UseKotlinMethodsForVarNames useKotlinMethodsForVarNames = UseKotlinMethodsForVarNames.APPLY;
+
+	@Parameter(
+			names = { "--rename-flags" },
+			description = "fix options (comma-separated list of):"
+					+ "\n 'case' - fix case sensitivity issues (according to --fs-case-sensitive option),"
+					+ "\n 'valid' - rename java identifiers to make them valid,"
+					+ "\n 'printable' - remove non-printable chars from identifiers,"
+					+ "\nor single 'none' - to disable all renames"
+					+ "\nor single 'all' - to enable all (default)",
+			converter = RenameConverter.class
+	)
+	protected Set<RenameEnum> renameFlags = EnumSet.allOf(RenameEnum.class);
+
+	@Parameter(names = { "--fs-case-sensitive" }, description = "treat filesystem as case sensitive, false by default")
+	protected boolean fsCaseSensitive = 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 = "set '--decompilation-mode' to 'fallback' (deprecated)")
+	protected boolean fallbackMode = false;
+
+	@Parameter(names = { "--use-dx" }, description = "use dx/d8 to convert java bytecode")
+	protected boolean useDx = false;
+
+	@Parameter(
+			names = { "--comments-level" },
+			description = "set code comments level, values: error, warn, info, debug, user-only, none",
+			converter = CommentsLevelConverter.class
+	)
+	protected CommentsLevel commentsLevel = CommentsLevel.INFO;
+
+	@Parameter(
+			names = { "--log-level" },
+			description = "set log level, values: quiet, progress, error, warn, info, debug",
+			converter = LogHelper.LogLevelConverter.class
+	)
+	protected LogHelper.LogLevelEnum logLevel = LogHelper.LogLevelEnum.PROGRESS;
+
+	@Parameter(names = { "-v", "--verbose" }, description = "verbose output (set --log-level to DEBUG)")
+	protected boolean verbose = false;
+
+	@Parameter(names = { "-q", "--quiet" }, description = "turn off output (set --log-level to QUIET)")
+	protected boolean quiet = 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;
+	@DynamicParameter(names = "-P", description = "Plugin options", hidden = true)
+	protected Map<String, String> pluginOptions = new HashMap<>();
 
 	public boolean processArgs(String[] args) {
-		return parse(args) && process();
+		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(this);
+		return jcw.parse(args) && process(jcw);
 	}
 
-	private boolean parse(String[] args) {
-		try {
-			new JCommander(this, args);
-			return true;
-		} catch (ParameterException e) {
-			System.err.println("Arguments parse error: " + e.getMessage());
-			printUsage();
+	/**
+	 * Set values only for options provided in cmd.
+	 * Used to merge saved options and options passed in command line.
+	 */
+	public boolean overrideProvided(String[] args) {
+		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(newInstance());
+		if (!jcw.parse(args)) {
 			return false;
 		}
+		jcw.overrideProvided(this);
+		return process(jcw);
 	}
 
-	private boolean process() {
-		if (isPrintHelp()) {
-			printUsage();
+	protected JadxCLIArgs newInstance() {
+		return new JadxCLIArgs();
+	}
+
+	private boolean process(JCommanderWrapper<JadxCLIArgs> jcw) {
+		if (printHelp) {
+			jcw.printUsage();
+			return false;
+		}
+		if (printVersion) {
+			System.out.println(JadxDecompiler.getVersion());
 			return false;
 		}
 		try {
 			if (threadsCount <= 0) {
-				throw new JadxException("Threads count must be positive");
-			}
-			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()) {
-				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);
+				throw new JadxException("Threads count must be positive, got: " + threadsCount);
 			}
 		} catch (JadxException e) {
 			System.err.println("ERROR: " + e.getMessage());
-			printUsage();
+			jcw.printUsage();
 			return false;
 		}
 		return true;
 	}
 
-	public void printUsage() {
-		JCommander jc = new JCommander(this);
-		// print usage in not sorted fields order (by default its sorted by description)
-		PrintStream out = System.out;
-		out.println();
-		out.println("jadx - dex to java decompiler, version: " + JadxDecompiler.getVersion());
-		out.println();
-		out.println("usage: jadx [options] " + jc.getMainParameterDescription());
-		out.println("options:");
-
-		List<ParameterDescription> params = jc.getParameters();
-		Map<String, ParameterDescription> paramsMap = new LinkedHashMap<String, ParameterDescription>(params.size());
-		int maxNamesLen = 0;
-		for (ParameterDescription p : params) {
-			paramsMap.put(p.getParameterized().getName(), p);
-			int len = p.getNames().length();
-			if (len > maxNamesLen) {
-				maxNamesLen = len;
-			}
+	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.setOutputFormat(JadxArgs.OutputFormatEnum.valueOf(outputFormat.toUpperCase()));
+		args.setThreadsCount(threadsCount);
+		args.setSkipSources(skipSources);
+		args.setSkipResources(skipResources);
+		if (fallbackMode) {
+			args.setDecompilationMode(DecompilationMode.FALLBACK);
+		} else {
+			args.setDecompilationMode(decompilationMode);
 		}
-		Field[] fields = JadxCLIArgs.class.getDeclaredFields();
-		for (Field f : fields) {
-			String name = f.getName();
-			ParameterDescription p = paramsMap.get(name);
-			if (p == null) {
-				continue;
-			}
-			StringBuilder opt = new StringBuilder();
-			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");
+		args.setShowInconsistentCode(showInconsistentCode);
+		args.setCfgOutput(cfgOutput);
+		args.setRawCFGOutput(rawCfgOutput);
+		args.setReplaceConsts(replaceConsts);
+		args.setDeobfuscationOn(deobfuscationOn);
+		args.setDeobfuscationMapFile(FileUtils.toFile(deobfuscationMapFile));
+		args.setDeobfuscationMapFileMode(deobfuscationMapFileMode);
+		args.setDeobfuscationMinLength(deobfuscationMinLength);
+		args.setDeobfuscationMaxLength(deobfuscationMaxLength);
+		args.setUseSourceNameAsClassAlias(deobfuscationUseSourceNameAsAlias);
+		args.setParseKotlinMetadata(deobfuscationParseKotlinMetadata);
+		args.setUseKotlinMethodsForVarNames(useKotlinMethodsForVarNames);
+		args.setResourceNameSource(resourceNameSource);
+		args.setEscapeUnicode(escapeUnicode);
+		args.setRespectBytecodeAccModifiers(respectBytecodeAccessModifiers);
+		args.setExportAsGradleProject(exportAsGradleProject);
+		args.setUseImports(useImports);
+		args.setDebugInfo(debugInfo);
+		args.setInsertDebugLines(addDebugLines);
+		args.setInlineAnonymousClasses(inlineAnonymousClasses);
+		args.setInlineMethods(inlineMethods);
+		args.setExtractFinally(extractFinally);
+		args.setRenameFlags(renameFlags);
+		args.setFsCaseSensitive(fsCaseSensitive);
+		args.setCommentsLevel(commentsLevel);
+		args.setUseDxInput(useDx);
+		args.setPluginOptions(pluginOptions);
+		return args;
 	}
 
-	private static void addSpaces(StringBuilder str, int count) {
-		for (int i = 0; i < count; i++) {
-			str.append(' ');
-		}
+	public List<String> getFiles() {
+		return files;
 	}
 
-	public List<File> getInput() {
-		return input;
+	public String getOutDir() {
+		return outDir;
 	}
 
-	@Override
-	public File getOutDir() {
-		return outputDir;
+	public String getOutDirSrc() {
+		return outDirSrc;
 	}
 
-	public void setOutputDir(File outputDir) {
-		this.outputDir = outputDir;
+	public String getOutDirRes() {
+		return outDirRes;
 	}
 
-	public boolean isPrintHelp() {
-		return printHelp;
+	public String getSingleClass() {
+		return singleClass;
+	}
+
+	public String getSingleClassOutput() {
+		return singleClassOutput;
 	}
 
-	@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 isUseDx() {
+		return useDx;
+	}
+
+	public DecompilationMode getDecompilationMode() {
+		return decompilationMode;
+	}
+
 	public boolean isShowInconsistentCode() {
 		return showInconsistentCode;
 	}
 
-	@Override
-	public boolean isVerbose() {
-		return verbose;
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public boolean isDebugInfo() {
+		return debugInfo;
+	}
+
+	public boolean isAddDebugLines() {
+		return addDebugLines;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
+	}
+
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public boolean isExtractFinally() {
+		return extractFinally;
 	}
 
-	@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 String getDeobfuscationMapFile() {
+		return deobfuscationMapFile;
+	}
+
+	public DeobfuscationMapFileMode getDeobfuscationMapFileMode() {
+		return deobfuscationMapFileMode;
+	}
+
+	public boolean isDeobfuscationUseSourceNameAsAlias() {
+		return deobfuscationUseSourceNameAsAlias;
+	}
+
+	public boolean isDeobfuscationParseKotlinMetadata() {
+		return deobfuscationParseKotlinMetadata;
+	}
+
+	public ResourceNameSource getResourceNameSource() {
+		return resourceNameSource;
+	}
+
+	public UseKotlinMethodsForVarNames getUseKotlinMethodsForVarNames() {
+		return useKotlinMethodsForVarNames;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public boolean isRawCfgOutput() {
+		return rawCfgOutput;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public boolean isRespectBytecodeAccessModifiers() {
+		return respectBytecodeAccessModifiers;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public boolean isRenameCaseSensitive() {
+		return renameFlags.contains(RenameEnum.CASE);
+	}
+
+	public boolean isRenameValid() {
+		return renameFlags.contains(RenameEnum.VALID);
+	}
+
+	public boolean isRenamePrintable() {
+		return renameFlags.contains(RenameEnum.PRINTABLE);
+	}
+
+	public boolean isFsCaseSensitive() {
+		return fsCaseSensitive;
+	}
+
+	public CommentsLevel getCommentsLevel() {
+		return commentsLevel;
+	}
+
+	public LogHelper.LogLevelEnum getLogLevel() {
+		return logLevel;
+	}
+
+	public Map<String, String> getPluginOptions() {
+		return pluginOptions;
+	}
+
+	static class RenameConverter implements IStringConverter<Set<RenameEnum>> {
+		private final String paramName;
+
+		RenameConverter(String paramName) {
+			this.paramName = paramName;
+		}
+
+		@Override
+		public Set<RenameEnum> convert(String value) {
+			if (value.equalsIgnoreCase("NONE")) {
+				return EnumSet.noneOf(RenameEnum.class);
+			}
+			if (value.equalsIgnoreCase("ALL")) {
+				return EnumSet.allOf(RenameEnum.class);
+			}
+			Set<RenameEnum> set = EnumSet.noneOf(RenameEnum.class);
+			for (String s : value.split(",")) {
+				try {
+					set.add(RenameEnum.valueOf(s.trim().toUpperCase(Locale.ROOT)));
+				} catch (IllegalArgumentException e) {
+					throw new IllegalArgumentException(
+							'\'' + s + "' is unknown for parameter " + paramName
+									+ ", possible values are " + enumValuesString(RenameEnum.values()));
+				}
+			}
+			return set;
+		}
+	}
+
+	public static class CommentsLevelConverter implements IStringConverter<CommentsLevel> {
+		@Override
+		public CommentsLevel convert(String value) {
+			try {
+				return CommentsLevel.valueOf(value.toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown comments level, possible values are: "
+								+ JadxCLIArgs.enumValuesString(CommentsLevel.values()));
+			}
+		}
+	}
+
+	public static class UseKotlinMethodsForVarNamesConverter implements IStringConverter<UseKotlinMethodsForVarNames> {
+		@Override
+		public UseKotlinMethodsForVarNames convert(String value) {
+			try {
+				return UseKotlinMethodsForVarNames.valueOf(value.replace('-', '_').toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown, possible values are: "
+								+ JadxCLIArgs.enumValuesString(CommentsLevel.values()));
+			}
+		}
+	}
+
+	public static class DeobfuscationMapFileModeConverter implements IStringConverter<DeobfuscationMapFileMode> {
+		@Override
+		public DeobfuscationMapFileMode convert(String value) {
+			try {
+				return DeobfuscationMapFileMode.valueOf(value.toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown, possible values are: "
+								+ JadxCLIArgs.enumValuesString(DeobfuscationMapFileMode.values()));
+			}
+		}
+	}
+
+	public static class ResourceNameSourceConverter implements IStringConverter<ResourceNameSource> {
+		@Override
+		public ResourceNameSource convert(String value) {
+			try {
+				return ResourceNameSource.valueOf(value.toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown, possible values are: "
+								+ JadxCLIArgs.enumValuesString(ResourceNameSource.values()));
+			}
+		}
+	}
+
+	public static class DecompilationModeConverter implements IStringConverter<DecompilationMode> {
+		@Override
+		public DecompilationMode convert(String value) {
+			try {
+				return DecompilationMode.valueOf(value.toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown, possible values are: "
+								+ JadxCLIArgs.enumValuesString(DecompilationMode.values()));
+			}
+		}
+	}
+
+	public static String enumValuesString(Enum<?>[] values) {
+		return Stream.of(values)
+				.map(v -> v.name().replace('_', '-').toLowerCase(Locale.ROOT))
+				.collect(Collectors.joining(", "));
 	}
 }

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

@@ -0,0 +1,136 @@
+package jadx.cli;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.LoggerFactory;
+
+import com.beust.jcommander.IStringConverter;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+
+import jadx.api.JadxDecompiler;
+
+public class LogHelper {
+	private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(LogHelper.class);
+
+	public enum LogLevelEnum {
+		QUIET(Level.OFF),
+		PROGRESS(Level.OFF),
+		ERROR(Level.ERROR),
+		WARN(Level.WARN),
+		INFO(Level.INFO),
+		DEBUG(Level.DEBUG);
+
+		private final Level level;
+
+		LogLevelEnum(Level level) {
+			this.level = level;
+		}
+
+		public Level getLevel() {
+			return level;
+		}
+	}
+
+	@Nullable("For disable log level control")
+	private static LogLevelEnum logLevelValue;
+
+	public static void initLogLevel(JadxCLIArgs args) {
+		logLevelValue = getLogLevelFromArgs(args);
+	}
+
+	private static LogLevelEnum getLogLevelFromArgs(JadxCLIArgs args) {
+		if (isCustomLogConfig()) {
+			return null;
+		}
+		if (args.quiet) {
+			return LogLevelEnum.QUIET;
+		}
+		if (args.verbose) {
+			return LogLevelEnum.DEBUG;
+		}
+		return args.logLevel;
+	}
+
+	public static void setLogLevelsForLoadingStage() {
+		if (logLevelValue == null) {
+			return;
+		}
+		if (logLevelValue == LogLevelEnum.PROGRESS) {
+			// show load errors
+			LogHelper.applyLogLevel(LogLevelEnum.ERROR);
+			fixForShowProgress();
+			return;
+		}
+		applyLogLevel(logLevelValue);
+	}
+
+	public static void setLogLevelsForDecompileStage() {
+		if (logLevelValue == null) {
+			return;
+		}
+		applyLogLevel(logLevelValue);
+		if (logLevelValue == LogLevelEnum.PROGRESS) {
+			fixForShowProgress();
+		}
+	}
+
+	/**
+	 * Show progress: change to 'INFO' for control classes
+	 */
+	private static void fixForShowProgress() {
+		setLevelForClass(JadxCLI.class, Level.INFO);
+		setLevelForClass(JadxDecompiler.class, Level.INFO);
+		setLevelForClass(SingleClassMode.class, Level.INFO);
+	}
+
+	private static void applyLogLevel(@NotNull LogLevelEnum logLevel) {
+		Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+		rootLogger.setLevel(logLevel.getLevel());
+	}
+
+	@Nullable
+	public static LogLevelEnum getLogLevel() {
+		return logLevelValue;
+	}
+
+	public static void setLevelForClass(Class<?> cls, Level level) {
+		((Logger) LoggerFactory.getLogger(cls)).setLevel(level);
+	}
+
+	public static void setLevelForPackage(String pkgName, Level level) {
+		((Logger) LoggerFactory.getLogger(pkgName)).setLevel(level);
+	}
+
+	/**
+	 * Try to detect if user provide custom logback config via -Dlogback.configurationFile=
+	 */
+	private static boolean isCustomLogConfig() {
+		try {
+			String logbackConfig = System.getProperty("logback.configurationFile");
+			if (logbackConfig == null) {
+				return false;
+			}
+			LOG.debug("Use custom log config: {}", logbackConfig);
+			return true;
+		} catch (Exception e) {
+			LOG.error("Failed to detect custom log config", e);
+		}
+		return false;
+	}
+
+	public static class LogLevelConverter implements IStringConverter<LogLevelEnum> {
+
+		@Override
+		public LogLevelEnum convert(String value) {
+			try {
+				return LogLevelEnum.valueOf(value.toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown log level, possible values are "
+								+ JadxCLIArgs.enumValuesString(LogLevelEnum.values()));
+			}
+		}
+	}
+}

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

@@ -0,0 +1,87 @@
+package jadx.cli;
+
+import java.io.File;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.ICodeInfo;
+import jadx.api.JadxDecompiler;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.visitors.SaveCode;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+
+public class SingleClassMode {
+	private static final Logger LOG = LoggerFactory.getLogger(SingleClassMode.class);
+
+	public static boolean process(JadxDecompiler jadx, JadxCLIArgs cliArgs) {
+		String singleClass = cliArgs.getSingleClass();
+		String singleClassOutput = cliArgs.getSingleClassOutput();
+		if (singleClass == null && singleClassOutput == null) {
+			return false;
+		}
+		ClassNode clsForProcess;
+		if (singleClass != null) {
+			clsForProcess = jadx.getRoot().resolveClass(singleClass);
+			if (clsForProcess == null) {
+				clsForProcess = jadx.getRoot().getClasses().stream()
+						.filter(cls -> cls.getClassInfo().getAliasFullName().equals(singleClass))
+						.findFirst().orElse(null);
+			}
+			if (clsForProcess == null) {
+				throw new JadxRuntimeException("Input class not found: " + singleClass);
+			}
+			if (clsForProcess.contains(AFlag.DONT_GENERATE)) {
+				throw new JadxRuntimeException("Input class can't be saved by currect jadx settings (marked as DONT_GENERATE)");
+			}
+			if (clsForProcess.isInner()) {
+				clsForProcess = clsForProcess.getTopParentClass();
+				LOG.warn("Input class is inner, parent class will be saved: {}", clsForProcess.getFullName());
+			}
+		} else {
+			// singleClassOutput is set
+			// expect only one class to be loaded
+			List<ClassNode> classes = jadx.getRoot().getClasses().stream()
+					.filter(c -> !c.isInner() && !c.contains(AFlag.DONT_GENERATE))
+					.collect(Collectors.toList());
+			int size = classes.size();
+			if (size == 1) {
+				clsForProcess = classes.get(0);
+			} else {
+				throw new JadxRuntimeException("Found " + size + " classes, single class output can't be used");
+			}
+		}
+		ICodeInfo codeInfo;
+		try {
+			codeInfo = clsForProcess.decompile();
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Class decompilation failed", e);
+		}
+		String fileExt = SaveCode.getFileExtension(jadx.getRoot());
+		File out;
+		if (singleClassOutput == null) {
+			out = new File(jadx.getArgs().getOutDirSrc(), clsForProcess.getClassInfo().getAliasFullPath() + fileExt);
+		} else {
+			if (singleClassOutput.endsWith(fileExt)) {
+				// treat as file name
+				out = new File(singleClassOutput);
+			} else {
+				// treat as directory
+				out = new File(singleClassOutput, clsForProcess.getShortName() + fileExt);
+			}
+		}
+		File resultOut = FileUtils.prepareFile(out);
+		if (clsForProcess.getClassInfo().hasAlias()) {
+			LOG.info("Saving class '{}' (alias: '{}') to file '{}'",
+					clsForProcess.getClassInfo().getFullName(), clsForProcess.getFullName(), resultOut.getAbsolutePath());
+		} else {
+			LOG.info("Saving class '{}' to file '{}'", clsForProcess.getFullName(), resultOut.getAbsolutePath());
+		}
+		SaveCode.save(codeInfo.getCodeStr(), resultOut);
+		return true;
+	}
+}

jadx-cli/src/main/java/jadx/cli/clst/ConvertToClsSet.java

@@ -0,0 +1,67 @@
+package jadx.cli.clst;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.api.plugins.JadxPluginManager;
+import jadx.api.plugins.input.JadxInputPlugin;
+import jadx.api.plugins.input.data.ILoadResult;
+import jadx.core.clsp.ClsSet;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.dex.visitors.SignatureProcessor;
+
+/**
+ * Utility class for convert dex or jar to jadx classes set (.jcst)
+ */
+public class ConvertToClsSet {
+	private static final Logger LOG = LoggerFactory.getLogger(ConvertToClsSet.class);
+
+	public static void usage() {
+		LOG.info("<output .jcst or .jar file> <several input dex or jar files> ");
+	}
+
+	public static void main(String[] args) throws Exception {
+		if (args.length < 2) {
+			usage();
+			System.exit(1);
+		}
+		List<Path> inputPaths = Stream.of(args).map(Paths::get).collect(Collectors.toList());
+		Path output = inputPaths.remove(0);
+
+		JadxPluginManager pluginManager = new JadxPluginManager();
+		pluginManager.load();
+		List<ILoadResult> loadedInputs = new ArrayList<>();
+		for (JadxInputPlugin inputPlugin : pluginManager.getInputPlugins()) {
+			loadedInputs.add(inputPlugin.loadFiles(inputPaths));
+		}
+
+		JadxArgs jadxArgs = new JadxArgs();
+		jadxArgs.setRenameFlags(EnumSet.noneOf(JadxArgs.RenameEnum.class));
+		RootNode root = new RootNode(jadxArgs);
+		root.loadClasses(loadedInputs);
+
+		// from pre-decompilation stage run only SignatureProcessor
+		SignatureProcessor signatureProcessor = new SignatureProcessor();
+		signatureProcessor.init(root);
+		for (ClassNode classNode : root.getClasses()) {
+			signatureProcessor.visit(classNode);
+		}
+
+		ClsSet set = new ClsSet(root);
+		set.loadFrom(root);
+		set.save(output);
+
+		LOG.info("Output: {}", output);
+		LOG.info("done");
+	}
+}

jadx-cli/src/main/java/jadx/cli/tools/ConvertArscFile.java

@@ -0,0 +1,98 @@
+package jadx.cli.tools;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.android.TextResMapFile;
+import jadx.core.xmlgen.ResTableParser;
+
+/**
+ * Utility class for convert '.arsc' to simple text file with mapping id to resource name
+ */
+public class ConvertArscFile {
+	private static final Logger LOG = LoggerFactory.getLogger(ConvertArscFile.class);
+	private static int rewritesCount;
+
+	public static void usage() {
+		LOG.info("<res-map file> <input .arsc files>");
+		LOG.info("");
+		LOG.info("Note: If res-map already exists - it will be merged and updated");
+	}
+
+	public static void main(String[] args) throws IOException {
+		if (args.length < 2) {
+			usage();
+			System.exit(1);
+		}
+		List<Path> inputPaths = Stream.of(args).map(Paths::get).collect(Collectors.toList());
+		Path resMapFile = inputPaths.remove(0);
+		Map<Integer, String> resMap;
+		if (Files.isReadable(resMapFile)) {
+			resMap = TextResMapFile.read(resMapFile);
+		} else {
+			resMap = new HashMap<>();
+		}
+		LOG.info("Input entries count: {}", resMap.size());
+
+		RootNode root = new RootNode(new JadxArgs()); // not really needed
+		rewritesCount = 0;
+		for (Path resFile : inputPaths) {
+			LOG.info("Processing {}", resFile);
+			ResTableParser resTableParser = new ResTableParser(root, true);
+			if (resFile.getFileName().toString().endsWith(".jar")) {
+				// Load resources.arsc from android.jar
+				try (ZipFile zip = new ZipFile(resFile.toFile())) {
+					ZipEntry entry = zip.getEntry("resources.arsc");
+					if (entry == null) {
+						LOG.error("Failed to load \"resources.arsc\" from {}", resFile);
+						continue;
+					}
+					try (InputStream inputStream = zip.getInputStream(entry)) {
+						resTableParser.decode(inputStream);
+					}
+				}
+			} else {
+				// Load resources.arsc from extracted file
+				try (InputStream inputStream = new BufferedInputStream(Files.newInputStream(resFile))) {
+					resTableParser.decode(inputStream);
+				}
+			}
+			Map<Integer, String> singleResMap = resTableParser.getResStorage().getResourcesNames();
+			mergeResMaps(resMap, singleResMap);
+			LOG.info("{} entries count: {}, after merge: {}", resFile.getFileName(), singleResMap.size(), resMap.size());
+		}
+		LOG.info("Output entries count: {}", resMap.size());
+		LOG.info("Total rewrites count: {}", rewritesCount);
+		TextResMapFile.write(resMapFile, resMap);
+		LOG.info("Result file size: {} B", resMapFile.toFile().length());
+		LOG.info("done");
+	}
+
+	private static void mergeResMaps(Map<Integer, String> mainResMap, Map<Integer, String> newResMap) {
+		for (Map.Entry<Integer, String> entry : newResMap.entrySet()) {
+			Integer id = entry.getKey();
+			String name = entry.getValue();
+			String prevName = mainResMap.put(id, name);
+			if (prevName != null && !name.equals(prevName)) {
+				LOG.debug("Rewrite id: {} from: '{}' to: '{}'", Integer.toHexString(id), prevName, name);
+				rewritesCount++;
+			}
+		}
+	}
+}

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

@@ -1,13 +1,11 @@
 <configuration>
+	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+		<encoder>
+			<pattern>%-5level - %msg%n</pattern>
+		</encoder>
+	</appender>
 
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%-5level - %msg%n</pattern>
-        </encoder>
-    </appender>
-
-    <root level="INFO">
-        <appender-ref ref="STDOUT"/>
-    </root>
-
+	<root level="INFO">
+		<appender-ref ref="STDOUT"/>
+	</root>
 </configuration>

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

@@ -0,0 +1,106 @@
+package jadx.cli;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static jadx.core.utils.Utils.newConstStringMap;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+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));
+	}
+
+	@Test
+	public void testOptionsOverride() {
+		assertThat(override(new JadxCLIArgs(), "--no-imports").isUseImports(), is(false));
+		assertThat(override(new JadxCLIArgs(), "--no-debug-info").isDebugInfo(), is(false));
+		assertThat(override(new JadxCLIArgs(), "").isUseImports(), is(true));
+
+		JadxCLIArgs args = new JadxCLIArgs();
+		args.useImports = false;
+		assertThat(override(args, "--no-imports").isUseImports(), is(false));
+		args.debugInfo = false;
+		assertThat(override(args, "--no-debug-info").isDebugInfo(), is(false));
+
+		args = new JadxCLIArgs();
+		args.useImports = false;
+		assertThat(override(args, "").isUseImports(), is(false));
+	}
+
+	@Test
+	public void testPluginOptionsOverride() {
+		// add key to empty base map
+		checkPluginOptionsMerge(
+				Collections.emptyMap(),
+				"-Poption=otherValue",
+				newConstStringMap("option", "otherValue"));
+
+		// override one key
+		checkPluginOptionsMerge(
+				newConstStringMap("option", "value"),
+				"-Poption=otherValue",
+				newConstStringMap("option", "otherValue"));
+
+		// merge different keys
+		checkPluginOptionsMerge(
+				Collections.singletonMap("option1", "value1"),
+				"-Poption2=otherValue2",
+				newConstStringMap("option1", "value1", "option2", "otherValue2"));
+
+		// merge and override
+		checkPluginOptionsMerge(
+				newConstStringMap("option1", "value1", "option2", "value2"),
+				"-Poption2=otherValue2",
+				newConstStringMap("option1", "value1", "option2", "otherValue2"));
+	}
+
+	private void checkPluginOptionsMerge(Map<String, String> baseMap, String providedArgs, Map<String, String> expectedMap) {
+		JadxCLIArgs args = new JadxCLIArgs();
+		args.pluginOptions = baseMap;
+		Map<String, String> resultMap = override(args, providedArgs).getPluginOptions();
+		assertThat(resultMap, Matchers.equalTo(expectedMap));
+	}
+
+	private JadxCLIArgs parse(String... args) {
+		return parse(new JadxCLIArgs(), args);
+	}
+
+	private JadxCLIArgs parse(JadxCLIArgs jadxArgs, String... args) {
+		boolean res = jadxArgs.processArgs(args);
+		assertThat(res, is(true));
+		LOG.info("Jadx args: {}", jadxArgs.toJadxArgs());
+		return jadxArgs;
+	}
+
+	private JadxCLIArgs override(JadxCLIArgs jadxArgs, String... args) {
+		boolean res = jadxArgs.overrideProvided(args);
+		assertThat(res, is(true));
+		LOG.info("Jadx args: {}", jadxArgs.toJadxArgs());
+		return jadxArgs;
+	}
+}

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

@@ -0,0 +1,48 @@
+package jadx.cli;
+
+import java.util.Set;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import jadx.api.JadxArgs.RenameEnum;
+import jadx.cli.JadxCLIArgs.RenameConverter;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class RenameConverterTest {
+
+	private RenameConverter converter;
+
+	@BeforeEach
+	public void init() {
+		converter = new RenameConverter("someParam");
+	}
+
+	@Test
+	public void all() {
+		Set<RenameEnum> set = converter.convert("all");
+		assertEquals(3, set.size());
+		assertTrue(set.contains(RenameEnum.CASE));
+		assertTrue(set.contains(RenameEnum.VALID));
+		assertTrue(set.contains(RenameEnum.PRINTABLE));
+	}
+
+	@Test
+	public void none() {
+		Set<RenameEnum> set = converter.convert("none");
+		assertTrue(set.isEmpty());
+	}
+
+	@Test
+	public void wrong() {
+		IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
+				() -> converter.convert("wrong"),
+				"Expected convert() to throw, but it didn't");
+
+		assertEquals("'wrong' is unknown for parameter someParam, possible values are case, valid, printable",
+				thrown.getMessage());
+	}
+}

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

@@ -0,0 +1,123 @@
+package jadx.cli;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.utils.files.FileUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestInput {
+	private static final Logger LOG = LoggerFactory.getLogger(TestInput.class);
+
+	@Test
+	public void testDexInput() throws Exception {
+		decompile("dex", "samples/hello.dex");
+	}
+
+	@Test
+	public void testSmaliInput() throws Exception {
+		decompile("smali", "samples/HelloWorld.smali");
+	}
+
+	@Test
+	public void testClassInput() throws Exception {
+		decompile("class", "samples/HelloWorld.class");
+	}
+
+	@Test
+	public void testMultipleInput() throws Exception {
+		decompile("multi", "samples/hello.dex", "samples/HelloWorld.smali");
+	}
+
+	@Test
+	public void testResourceOnly() throws Exception {
+		decode("resourceOnly", "samples/resources-only.apk");
+	}
+
+	private void decode(String tmpDirName, String apkSample) throws URISyntaxException, IOException {
+		List<String> args = new ArrayList<>();
+		Path tempDir = FileUtils.createTempDir(tmpDirName);
+		args.add("-v");
+		args.add("-d");
+		args.add(tempDir.toAbsolutePath().toString());
+
+		URL resource = getClass().getClassLoader().getResource(apkSample);
+		assertThat(resource).isNotNull();
+		String sampleFile = resource.toURI().getRawPath();
+		args.add(sampleFile);
+
+		int result = JadxCLI.execute(args.toArray(new String[0]));
+		assertThat(result).isEqualTo(0);
+		List<Path> files = Files.find(
+				tempDir,
+				3,
+				(file, attr) -> file.getFileName().toString().equalsIgnoreCase("AndroidManifest.xml"))
+				.collect(Collectors.toList());
+		assertThat(files.isEmpty()).isFalse();
+	}
+
+	private void decompile(String tmpDirName, String... inputSamples) throws URISyntaxException, IOException {
+		List<String> args = new ArrayList<>();
+		Path tempDir = FileUtils.createTempDir(tmpDirName);
+		args.add("-v");
+		args.add("-d");
+		args.add(tempDir.toAbsolutePath().toString());
+
+		for (String inputSample : inputSamples) {
+			URL resource = getClass().getClassLoader().getResource(inputSample);
+			assertThat(resource).isNotNull();
+			String sampleFile = resource.toURI().getRawPath();
+			args.add(sampleFile);
+		}
+
+		int result = JadxCLI.execute(args.toArray(new String[0]));
+		assertThat(result).isEqualTo(0);
+		List<Path> resultJavaFiles = collectJavaFilesInDir(tempDir);
+		assertThat(resultJavaFiles).isNotEmpty();
+
+		// do not copy input files as resources
+		PathMatcher logAllFiles = path -> {
+			LOG.debug("File in result dir: {}", path);
+			return true;
+		};
+		for (Path path : collectFilesInDir(tempDir, logAllFiles)) {
+			for (String inputSample : inputSamples) {
+				assertThat(path.toAbsolutePath().toString()).doesNotContain(inputSample);
+			}
+		}
+	}
+
+	private static List<Path> collectJavaFilesInDir(Path dir) throws IOException {
+		PathMatcher javaMatcher = dir.getFileSystem().getPathMatcher("glob:**.java");
+		return collectFilesInDir(dir, javaMatcher);
+	}
+
+	private static List<Path> collectFilesInDir(Path dir, PathMatcher matcher) throws IOException {
+		try (Stream<Path> pathStream = Files.walk(dir)) {
+			return pathStream
+					.filter(p -> Files.isRegularFile(p, LinkOption.NOFOLLOW_LINKS))
+					.filter(matcher::matches)
+					.collect(Collectors.toList());
+		}
+	}
+
+	@AfterAll
+	public static void cleanup() {
+		FileUtils.clearTempRootDir();
+	}
+}

jadx-cli/src/test/resources/samples/HelloWorld.smali

@@ -0,0 +1,26 @@
+.class Lsmali/HelloWorld;
+.super Ljava/lang/Object;
+.source "HelloWorld.java"
+
+.method constructor <init>()V
+    .registers 1
+
+    .line 1
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    return-void
+.end method
+
+.method public static main([Ljava/lang/String;)V
+    .registers 2
+
+    .line 3
+    sget-object p0, Ljava/lang/System;->out:Ljava/io/PrintStream;
+
+    const-string v0, "Hello, World"
+
+    invoke-virtual {p0, v0}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
+
+    .line 4
+    return-void
+.end method

jadx-core/build.gradle

@@ -1,27 +1,28 @@
-ext.jadxClasspath = 'clsp-data/android-5.1.jar'
-
-apply plugin: "info.solidsoft.pitest"
+plugins {
+	id 'jadx-library'
+}
 
 dependencies {
-    runtime files(jadxClasspath)
+	api(project(':jadx-plugins:jadx-plugins-api'))
 
-    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'
+	implementation 'com.google.code.gson:gson:2.9.1'
 
-    testCompile 'org.smali:smali:2.0.3'
+	// TODO: move resources decoding to separate plugin module
+	implementation 'com.android.tools.build:aapt2-proto:7.3.1-8691043'
+	implementation 'com.google.protobuf:protobuf-java:3.21.8' // forcing latest version
+
+	testImplementation 'org.apache.commons:commons-lang3:3.12.0'
+
+	testImplementation(project(':jadx-plugins:jadx-dex-input'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-smali-input'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-java-convert'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-java-input'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-raung-input'))
+
+	testImplementation 'org.eclipse.jdt:ecj:3.31.0'
+	testImplementation 'tools.profiler:async-profiler:1.8.3'
 }
 
-task packTests(type: Jar) {
-    classifier = 'tests'
-    from sourceSets.test.output
-}
-
-pitest {
-    excludedMethods = ['toString']
-    threads = 4
-    enableDefaultIncrementalAnalysis = true
-    outputFormats = ['XML', 'HTML']
-    jvmArgs = ['-Xmx12G']
+test {
+	exclude '**/tmp/*'
 }

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

@@ -1,58 +0,0 @@
-package jadx.api;
-
-public final class CodePosition {
-
-	private final JavaClass cls;
-	private final int line;
-	private final int offset;
-
-	public CodePosition(JavaClass cls, int line, int offset) {
-		this.cls = cls;
-		this.line = line;
-		this.offset = offset;
-	}
-
-	public CodePosition(int line, int offset) {
-		this.cls = null;
-		this.line = line;
-		this.offset = offset;
-	}
-
-	public JavaClass getJavaClass() {
-		return cls;
-	}
-
-	public int getLine() {
-		return line;
-	}
-
-	public int getOffset() {
-		return offset;
-	}
-
-	public boolean isSet() {
-		return line != 0 || offset != 0;
-	}
-
-	@Override
-	public boolean equals(Object o) {
-		if (this == o) {
-			return true;
-		}
-		if (o == null || getClass() != o.getClass()) {
-			return false;
-		}
-		CodePosition that = (CodePosition) o;
-		return line == that.line && offset == that.offset;
-	}
-
-	@Override
-	public int hashCode() {
-		return line + 31 * offset;
-	}
-
-	@Override
-	public String toString() {
-		return line + ":" + offset + (cls != null ? " " + cls : "");
-	}
-}

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

@@ -0,0 +1,14 @@
+package jadx.api;
+
+public enum CommentsLevel {
+	NONE,
+	USER_ONLY,
+	ERROR,
+	WARN,
+	INFO,
+	DEBUG;
+
+	public boolean filter(CommentsLevel limit) {
+		return this.ordinal() <= limit.ordinal();
+	}
+}

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

@@ -0,0 +1,23 @@
+package jadx.api;
+
+public enum DecompilationMode {
+	/**
+	 * Trying best options (default)
+	 */
+	AUTO,
+
+	/**
+	 * Restore code structure (normal java code)
+	 */
+	RESTRUCTURE,
+
+	/**
+	 * Simplified instructions (linear with goto's)
+	 */
+	SIMPLE,
+
+	/**
+	 * Raw instructions without modifications
+	 */
+	FALLBACK
+}

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/ICodeCache.java

@@ -0,0 +1,21 @@
+package jadx.api;
+
+import java.io.Closeable;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface ICodeCache extends Closeable {
+
+	void add(String clsFullName, ICodeInfo codeInfo);
+
+	void remove(String clsFullName);
+
+	@NotNull
+	ICodeInfo get(String clsFullName);
+
+	@Nullable
+	String getCode(String clsFullName);
+
+	boolean contains(String clsFullName);
+}

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

@@ -0,0 +1,15 @@
+package jadx.api;
+
+import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.metadata.ICodeMetadata;
+
+public interface ICodeInfo {
+
+	ICodeInfo EMPTY = new SimpleCodeInfo("");
+
+	String getCodeStr();
+
+	ICodeMetadata getCodeMetadata();
+
+	boolean hasMetadata();
+}

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

@@ -0,0 +1,72 @@
+package jadx.api;
+
+import java.util.Map;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+
+public interface ICodeWriter {
+	String NL = System.getProperty("line.separator");
+	String INDENT_STR = "    ";
+
+	boolean isMetadataSupported();
+
+	ICodeWriter startLine();
+
+	ICodeWriter startLine(char c);
+
+	ICodeWriter startLine(String str);
+
+	ICodeWriter startLineWithNum(int sourceLine);
+
+	ICodeWriter addMultiLine(String str);
+
+	ICodeWriter add(String str);
+
+	ICodeWriter add(char c);
+
+	ICodeWriter add(ICodeWriter code);
+
+	ICodeWriter newLine();
+
+	ICodeWriter addIndent();
+
+	void incIndent();
+
+	void decIndent();
+
+	int getIndent();
+
+	void setIndent(int indent);
+
+	/**
+	 * Return current line (only if metadata is supported)
+	 */
+	int getLine();
+
+	/**
+	 * Return start line position (only if metadata is supported)
+	 */
+	int getLineStartPos();
+
+	void attachDefinition(ICodeNodeRef obj);
+
+	void attachAnnotation(ICodeAnnotation obj);
+
+	void attachLineAnnotation(ICodeAnnotation obj);
+
+	void attachSourceLine(int sourceLine);
+
+	ICodeInfo finish();
+
+	String getCodeStr();
+
+	int getLength();
+
+	StringBuilder getRawBuf();
+
+	@ApiStatus.Internal
+	Map<Integer, ICodeAnnotation> getRawAnnotations();
+}

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

@@ -0,0 +1,7 @@
+package jadx.api;
+
+import java.util.List;
+
+public interface IDecompileScheduler {
+	List<List<JavaClass>> buildBatches(List<JavaClass> classes);
+}

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,602 @@
+package jadx.api;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.args.DeobfuscationMapFileMode;
+import jadx.api.args.ResourceNameSource;
+import jadx.api.data.ICodeData;
+import jadx.api.impl.AnnotatedCodeWriter;
+import jadx.api.impl.InMemoryCodeCache;
+import jadx.core.utils.files.FileUtils;
+
+public class JadxArgs {
+	private static final Logger LOG = LoggerFactory.getLogger(JadxArgs.class);
+
+	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 ICodeCache codeCache = new InMemoryCodeCache();
+	private Function<JadxArgs, ICodeWriter> codeWriterProvider = AnnotatedCodeWriter::new;
+
+	private int threadsCount = DEFAULT_THREADS_COUNT;
+
+	private boolean cfgOutput = false;
+	private boolean rawCFGOutput = false;
+
+	private boolean showInconsistentCode = false;
+
+	private boolean useImports = true;
+	private boolean debugInfo = true;
+	private boolean insertDebugLines = false;
+	private boolean extractFinally = true;
+	private boolean inlineAnonymousClasses = true;
+	private boolean inlineMethods = true;
+
+	private boolean skipResources = false;
+	private boolean skipSources = false;
+
+	/**
+	 * Predicate that allows to filter the classes to be process based on their full name
+	 */
+	private Predicate<String> classFilter = null;
+
+	/**
+	 * Save dependencies for classes accepted by {@code classFilter}
+	 */
+	private boolean includeDependencies = false;
+
+	private boolean deobfuscationOn = false;
+	private boolean useSourceNameAsClassAlias = false;
+	private boolean parseKotlinMetadata = false;
+	private File deobfuscationMapFile = null;
+
+	private DeobfuscationMapFileMode deobfuscationMapFileMode = DeobfuscationMapFileMode.READ;
+	private ResourceNameSource resourceNameSource = ResourceNameSource.AUTO;
+
+	private int deobfuscationMinLength = 0;
+	private int deobfuscationMaxLength = Integer.MAX_VALUE;
+
+	private boolean escapeUnicode = false;
+	private boolean replaceConsts = true;
+	private boolean respectBytecodeAccModifiers = false;
+	private boolean exportAsGradleProject = false;
+
+	private boolean fsCaseSensitive;
+
+	public enum RenameEnum {
+		CASE, VALID, PRINTABLE
+	}
+
+	private Set<RenameEnum> renameFlags = EnumSet.allOf(RenameEnum.class);
+
+	public enum OutputFormatEnum {
+		JAVA, JSON
+	}
+
+	private OutputFormatEnum outputFormat = OutputFormatEnum.JAVA;
+
+	private DecompilationMode decompilationMode = DecompilationMode.AUTO;
+
+	private ICodeData codeData;
+
+	private CommentsLevel commentsLevel = CommentsLevel.INFO;
+
+	private boolean useDxInput = false;
+
+	public enum UseKotlinMethodsForVarNames {
+		DISABLE, APPLY, APPLY_AND_HIDE
+	}
+
+	private UseKotlinMethodsForVarNames useKotlinMethodsForVarNames = UseKotlinMethodsForVarNames.APPLY;
+
+	/**
+	 * Don't save files (can be using for performance testing)
+	 */
+	private boolean skipFilesSave = false;
+
+	private Map<String, String> pluginOptions = new HashMap<>();
+
+	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 void close() {
+		try {
+			inputFiles = null;
+			if (codeCache != null) {
+				codeCache.close();
+			}
+		} catch (Exception e) {
+			LOG.error("Failed to close JadxArgs", e);
+		} finally {
+			codeCache = null;
+		}
+	}
+
+	public List<File> getInputFiles() {
+		return inputFiles;
+	}
+
+	public void setInputFile(File inputFile) {
+		this.inputFiles = Collections.singletonList(inputFile);
+	}
+
+	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 = Math.max(1, threadsCount); // make sure threadsCount >= 1
+	}
+
+	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 decompilationMode == DecompilationMode.FALLBACK;
+	}
+
+	/**
+	 * Deprecated: use 'decompilation mode' property
+	 */
+	@Deprecated
+	public void setFallbackMode(boolean fallbackMode) {
+		if (fallbackMode) {
+			this.decompilationMode = DecompilationMode.FALLBACK;
+		}
+	}
+
+	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 isDebugInfo() {
+		return debugInfo;
+	}
+
+	public void setDebugInfo(boolean debugInfo) {
+		this.debugInfo = debugInfo;
+	}
+
+	public boolean isInsertDebugLines() {
+		return insertDebugLines;
+	}
+
+	public void setInsertDebugLines(boolean insertDebugLines) {
+		this.insertDebugLines = insertDebugLines;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
+	}
+
+	public void setInlineAnonymousClasses(boolean inlineAnonymousClasses) {
+		this.inlineAnonymousClasses = inlineAnonymousClasses;
+	}
+
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public void setInlineMethods(boolean inlineMethods) {
+		this.inlineMethods = inlineMethods;
+	}
+
+	public boolean isExtractFinally() {
+		return extractFinally;
+	}
+
+	public void setExtractFinally(boolean extractFinally) {
+		this.extractFinally = extractFinally;
+	}
+
+	public boolean isSkipResources() {
+		return skipResources;
+	}
+
+	public void setSkipResources(boolean skipResources) {
+		this.skipResources = skipResources;
+	}
+
+	public boolean isSkipSources() {
+		return skipSources;
+	}
+
+	public void setSkipSources(boolean skipSources) {
+		this.skipSources = skipSources;
+	}
+
+	public void setIncludeDependencies(boolean includeDependencies) {
+		this.includeDependencies = includeDependencies;
+	}
+
+	public boolean isIncludeDependencies() {
+		return includeDependencies;
+	}
+
+	public Predicate<String> getClassFilter() {
+		return classFilter;
+	}
+
+	public void setClassFilter(Predicate<String> classFilter) {
+		this.classFilter = classFilter;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return deobfuscationOn;
+	}
+
+	public void setDeobfuscationOn(boolean deobfuscationOn) {
+		this.deobfuscationOn = deobfuscationOn;
+	}
+
+	@Deprecated
+	public boolean isDeobfuscationForceSave() {
+		return deobfuscationMapFileMode == DeobfuscationMapFileMode.OVERWRITE;
+	}
+
+	@Deprecated
+	public void setDeobfuscationForceSave(boolean deobfuscationForceSave) {
+		if (deobfuscationForceSave) {
+			this.deobfuscationMapFileMode = DeobfuscationMapFileMode.OVERWRITE;
+		}
+	}
+
+	public DeobfuscationMapFileMode getDeobfuscationMapFileMode() {
+		return deobfuscationMapFileMode;
+	}
+
+	public void setDeobfuscationMapFileMode(DeobfuscationMapFileMode deobfuscationMapFileMode) {
+		this.deobfuscationMapFileMode = deobfuscationMapFileMode;
+	}
+
+	public boolean isUseSourceNameAsClassAlias() {
+		return useSourceNameAsClassAlias;
+	}
+
+	public void setUseSourceNameAsClassAlias(boolean useSourceNameAsClassAlias) {
+		this.useSourceNameAsClassAlias = useSourceNameAsClassAlias;
+	}
+
+	public boolean isParseKotlinMetadata() {
+		return parseKotlinMetadata;
+	}
+
+	public void setParseKotlinMetadata(boolean parseKotlinMetadata) {
+		this.parseKotlinMetadata = parseKotlinMetadata;
+	}
+
+	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 File getDeobfuscationMapFile() {
+		return deobfuscationMapFile;
+	}
+
+	public void setDeobfuscationMapFile(File deobfuscationMapFile) {
+		this.deobfuscationMapFile = deobfuscationMapFile;
+	}
+
+	public ResourceNameSource getResourceNameSource() {
+		return resourceNameSource;
+	}
+
+	public void setResourceNameSource(ResourceNameSource resourceNameSource) {
+		this.resourceNameSource = resourceNameSource;
+	}
+
+	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 isRespectBytecodeAccModifiers() {
+		return respectBytecodeAccModifiers;
+	}
+
+	public void setRespectBytecodeAccModifiers(boolean respectBytecodeAccModifiers) {
+		this.respectBytecodeAccModifiers = respectBytecodeAccModifiers;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public void setExportAsGradleProject(boolean exportAsGradleProject) {
+		this.exportAsGradleProject = exportAsGradleProject;
+	}
+
+	public boolean isFsCaseSensitive() {
+		return fsCaseSensitive;
+	}
+
+	public void setFsCaseSensitive(boolean fsCaseSensitive) {
+		this.fsCaseSensitive = fsCaseSensitive;
+	}
+
+	public boolean isRenameCaseSensitive() {
+		return renameFlags.contains(RenameEnum.CASE);
+	}
+
+	public void setRenameCaseSensitive(boolean renameCaseSensitive) {
+		updateRenameFlag(renameCaseSensitive, RenameEnum.CASE);
+	}
+
+	public boolean isRenameValid() {
+		return renameFlags.contains(RenameEnum.VALID);
+	}
+
+	public void setRenameValid(boolean renameValid) {
+		updateRenameFlag(renameValid, RenameEnum.VALID);
+	}
+
+	public boolean isRenamePrintable() {
+		return renameFlags.contains(RenameEnum.PRINTABLE);
+	}
+
+	public void setRenamePrintable(boolean renamePrintable) {
+		updateRenameFlag(renamePrintable, RenameEnum.PRINTABLE);
+	}
+
+	private void updateRenameFlag(boolean enabled, RenameEnum flag) {
+		if (enabled) {
+			renameFlags.add(flag);
+		} else {
+			renameFlags.remove(flag);
+		}
+	}
+
+	public void setRenameFlags(Set<RenameEnum> renameFlags) {
+		this.renameFlags = renameFlags;
+	}
+
+	public Set<RenameEnum> getRenameFlags() {
+		return renameFlags;
+	}
+
+	public OutputFormatEnum getOutputFormat() {
+		return outputFormat;
+	}
+
+	public boolean isJsonOutput() {
+		return outputFormat == OutputFormatEnum.JSON;
+	}
+
+	public void setOutputFormat(OutputFormatEnum outputFormat) {
+		this.outputFormat = outputFormat;
+	}
+
+	public DecompilationMode getDecompilationMode() {
+		return decompilationMode;
+	}
+
+	public void setDecompilationMode(DecompilationMode decompilationMode) {
+		this.decompilationMode = decompilationMode;
+	}
+
+	public ICodeCache getCodeCache() {
+		return codeCache;
+	}
+
+	public void setCodeCache(ICodeCache codeCache) {
+		this.codeCache = codeCache;
+	}
+
+	public Function<JadxArgs, ICodeWriter> getCodeWriterProvider() {
+		return codeWriterProvider;
+	}
+
+	public void setCodeWriterProvider(Function<JadxArgs, ICodeWriter> codeWriterProvider) {
+		this.codeWriterProvider = codeWriterProvider;
+	}
+
+	public ICodeData getCodeData() {
+		return codeData;
+	}
+
+	public void setCodeData(ICodeData codeData) {
+		this.codeData = codeData;
+	}
+
+	public CommentsLevel getCommentsLevel() {
+		return commentsLevel;
+	}
+
+	public void setCommentsLevel(CommentsLevel commentsLevel) {
+		this.commentsLevel = commentsLevel;
+	}
+
+	public boolean isUseDxInput() {
+		return useDxInput;
+	}
+
+	public void setUseDxInput(boolean useDxInput) {
+		this.useDxInput = useDxInput;
+	}
+
+	public UseKotlinMethodsForVarNames getUseKotlinMethodsForVarNames() {
+		return useKotlinMethodsForVarNames;
+	}
+
+	public void setUseKotlinMethodsForVarNames(UseKotlinMethodsForVarNames useKotlinMethodsForVarNames) {
+		this.useKotlinMethodsForVarNames = useKotlinMethodsForVarNames;
+	}
+
+	public boolean isSkipFilesSave() {
+		return skipFilesSave;
+	}
+
+	public void setSkipFilesSave(boolean skipFilesSave) {
+		this.skipFilesSave = skipFilesSave;
+	}
+
+	public Map<String, String> getPluginOptions() {
+		return pluginOptions;
+	}
+
+	public void setPluginOptions(Map<String, String> pluginOptions) {
+		this.pluginOptions = pluginOptions;
+	}
+
+	/**
+	 * Hash of all options that can change result code
+	 */
+	public String makeCodeArgsHash() {
+		String argStr = "args:" + decompilationMode + useImports + showInconsistentCode
+				+ inlineAnonymousClasses + inlineMethods
+				+ deobfuscationOn + deobfuscationMinLength + deobfuscationMaxLength
+				+ resourceNameSource
+				+ parseKotlinMetadata + useKotlinMethodsForVarNames
+				+ insertDebugLines + extractFinally
+				+ debugInfo + useSourceNameAsClassAlias + escapeUnicode + replaceConsts
+				+ respectBytecodeAccModifiers + fsCaseSensitive + renameFlags
+				+ commentsLevel + useDxInput + pluginOptions;
+		return FileUtils.md5Sum(argStr.getBytes(StandardCharsets.US_ASCII));
+	}
+
+	@Override
+	public String toString() {
+		return "JadxArgs{" + "inputFiles=" + inputFiles
+				+ ", outDir=" + outDir
+				+ ", outDirSrc=" + outDirSrc
+				+ ", outDirRes=" + outDirRes
+				+ ", threadsCount=" + threadsCount
+				+ ", decompilationMode=" + decompilationMode
+				+ ", showInconsistentCode=" + showInconsistentCode
+				+ ", useImports=" + useImports
+				+ ", skipResources=" + skipResources
+				+ ", skipSources=" + skipSources
+				+ ", includeDependencies=" + includeDependencies
+				+ ", deobfuscationOn=" + deobfuscationOn
+				+ ", deobfuscationMapFile=" + deobfuscationMapFile
+				+ ", deobfuscationMapFileMode=" + deobfuscationMapFileMode
+				+ ", resourceNameSource=" + resourceNameSource
+				+ ", useSourceNameAsClassAlias=" + useSourceNameAsClassAlias
+				+ ", parseKotlinMetadata=" + parseKotlinMetadata
+				+ ", useKotlinMethodsForVarNames=" + useKotlinMethodsForVarNames
+				+ ", insertDebugLines=" + insertDebugLines
+				+ ", extractFinally=" + extractFinally
+				+ ", deobfuscationMinLength=" + deobfuscationMinLength
+				+ ", deobfuscationMaxLength=" + deobfuscationMaxLength
+				+ ", escapeUnicode=" + escapeUnicode
+				+ ", replaceConsts=" + replaceConsts
+				+ ", respectBytecodeAccModifiers=" + respectBytecodeAccModifiers
+				+ ", exportAsGradleProject=" + exportAsGradleProject
+				+ ", fsCaseSensitive=" + fsCaseSensitive
+				+ ", renameFlags=" + renameFlags
+				+ ", outputFormat=" + outputFormat
+				+ ", commentsLevel=" + commentsLevel
+				+ ", codeCache=" + codeCache
+				+ ", codeWriter=" + codeWriterProvider.apply(this).getClass().getSimpleName()
+				+ ", useDxInput=" + useDxInput
+				+ ", pluginOptions=" + pluginOptions
+				+ ", cfgOutput=" + cfgOutput
+				+ ", rawCFGOutput=" + rawCFGOutput
+				+ '}';
+	}
+}

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

@@ -0,0 +1,102 @@
+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(JadxDecompiler jadx) {
+		JadxArgs args = jadx.getArgs();
+		checkInputFiles(jadx, args);
+		validateOutDirs(args);
+
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Effective jadx args: {}", args);
+		}
+	}
+
+	private static void checkInputFiles(JadxDecompiler jadx, JadxArgs args) {
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty() && jadx.getCustomLoads().isEmpty()) {
+			throw new JadxArgsValidateException("Please specify input file");
+		}
+		for (File inputFile : inputFiles) {
+			String fileName = inputFile.getName();
+			if (fileName.startsWith("--")) {
+				throw new JadxArgsValidateException("Unknown argument: " + fileName);
+			}
+		}
+		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);
+		}
+		if (srcDir == null) {
+			args.setOutDirSrc(new File(args.getOutDir(), JadxArgs.DEFAULT_SRC_DIR));
+		}
+		if (resDir == null) {
+			args.setOutDirRes(new File(args.getOutDir(), JadxArgs.DEFAULT_RES_DIR));
+		}
+
+		checkDir(args.getOutDir(), "Output");
+		checkDir(args.getOutDirSrc(), "Source output");
+		checkDir(args.getOutDirRes(), "Resources output");
+	}
+
+	@NotNull
+	private static File makeDirFromInput(JadxArgs args) {
+		String outDirName;
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty()) {
+			outDirName = JadxArgs.DEFAULT_OUT_DIR;
+		} else {
+			File file = inputFiles.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);
+		return new File(outDirName);
+	}
+
+	private static void checkFile(File file) {
+		if (!file.exists()) {
+			throw new JadxArgsValidateException("File not found " + file.getAbsolutePath());
+		}
+	}
+
+	private static void checkDir(File dir, String desc) {
+		if (dir != null && dir.exists() && !dir.isDirectory()) {
+			throw new JadxArgsValidateException(desc + " directory exists as file " + dir);
+		}
+	}
+
+	private JadxArgsValidator() {
+	}
+}

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

@@ -1,127 +1,239 @@
 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.Closeable;
 import java.io.File;
-import java.io.IOException;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.NodeDeclareRef;
+import jadx.api.metadata.annotations.VarNode;
+import jadx.api.metadata.annotations.VarRef;
+import jadx.api.plugins.JadxPlugin;
+import jadx.api.plugins.JadxPluginManager;
+import jadx.api.plugins.input.JadxInputPlugin;
+import jadx.api.plugins.input.data.ILoadResult;
+import jadx.api.plugins.options.JadxPluginOptions;
+import jadx.core.Jadx;
+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.SaveCode;
+import jadx.core.export.ExportGradleProject;
+import jadx.core.utils.DecompilerScheduler;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.xmlgen.BinaryXMLParser;
+import jadx.core.xmlgen.ProtoXMLParser;
+import jadx.core.xmlgen.ResContainer;
+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();
- * </code></pre>
- * <p/>
- * Instead of 'save()' you can get list of decompiled classes:
- * <pre><code>
+ *
+ * <pre>
+ * <code>
+ *
+ * JadxArgs args = new JadxArgs();
+ * args.getInputFiles().add(new File("test.apk"));
+ * args.setOutDir(new File("jadx-test-output"));
+ * try (JadxDecompiler jadx = new JadxDecompiler(args)) {
+ *    jadx.load();
+ *    jadx.save();
+ * }
+ * </code>
+ * </pre>
+ * <p>
+ * Instead of 'save()' you can iterate over decompiled classes:
+ *
+ * <pre>
+ * <code>
+ *
  *  for(JavaClass cls : jadx.getClasses()) {
  *      System.out.println(cls.getCode());
  *  }
- * </code></pre>
+ * </code>
+ * </pre>
  */
-public final class JadxDecompiler {
+public final class JadxDecompiler implements Closeable {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxDecompiler.class);
 
-	private final IJadxArgs args;
-	private final List<InputFile> inputFiles = new ArrayList<InputFile>();
-
-	private File outDir;
+	private final JadxArgs args;
+	private final JadxPluginManager pluginManager = new JadxPluginManager();
+	private final List<ILoadResult> loadedInputs = new ArrayList<>();
 
 	private RootNode root;
-	private List<IDexTreeVisitor> passes;
-	private CodeGen codeGen;
-
 	private List<JavaClass> classes;
 	private List<ResourceFile> resources;
 
-	private BinaryXMLParser xmlParser;
+	private BinaryXMLParser binaryXmlParser;
+	private ProtoXMLParser protoXmlParser;
+
+	private final Map<ClassNode, JavaClass> classesMap = new ConcurrentHashMap<>();
+	private final Map<MethodNode, JavaMethod> methodsMap = new ConcurrentHashMap<>();
+	private final Map<FieldNode, JavaField> fieldsMap = new ConcurrentHashMap<>();
+
+	private final IDecompileScheduler decompileScheduler = new DecompilerScheduler();
+
+	private final List<ILoadResult> customLoads = new ArrayList<>();
 
 	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();
-		init();
+		JadxArgsValidator.validate(this);
+		LOG.info("loading ...");
+		loadPlugins(args);
+		loadInputFiles();
+
+		root = new RootNode(args);
+		root.loadClasses(loadedInputs);
+		root.initClassPath();
+		root.loadResources(getResources());
+		root.runPreDecompileStage();
+		root.initPasses();
 	}
 
-	public void setOutputDir(File outDir) {
-		this.outDir = outDir;
-		init();
-	}
-
-	void init() {
-		if (outDir == null) {
-			outDir = new DefaultJadxArgs().getOutDir();
+	private void loadInputFiles() {
+		loadedInputs.clear();
+		List<Path> inputPaths = Utils.collectionMap(args.getInputFiles(), File::toPath);
+		List<Path> inputFiles = FileUtils.expandDirs(inputPaths);
+		long start = System.currentTimeMillis();
+		for (JadxInputPlugin inputPlugin : pluginManager.getInputPlugins()) {
+			ILoadResult loadResult = inputPlugin.loadFiles(inputFiles);
+			if (loadResult != null && !loadResult.isEmpty()) {
+				loadedInputs.add(loadResult);
+			}
+		}
+		loadedInputs.addAll(customLoads);
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Loaded using {} inputs plugin in {} ms", loadedInputs.size(), System.currentTimeMillis() - start);
 		}
-		this.passes = Jadx.getPassesList(args, outDir);
-		this.codeGen = new CodeGen(args);
 	}
 
-	void reset() {
+	public void addCustomLoad(ILoadResult customLoad) {
+		customLoads.add(customLoad);
+	}
+
+	public List<ILoadResult> getCustomLoads() {
+		return customLoads;
+	}
+
+	private void reset() {
+		root = null;
 		classes = null;
 		resources = null;
-		xmlParser = null;
-		root = null;
-		passes = null;
-		codeGen = null;
+		binaryXmlParser = null;
+		protoXmlParser = null;
+
+		classesMap.clear();
+		methodsMap.clear();
+		fieldsMap.clear();
+	}
+
+	@Override
+	public void close() {
+		reset();
+		closeInputs();
+		args.close();
+	}
+
+	private void closeInputs() {
+		loadedInputs.forEach(load -> {
+			try {
+				load.close();
+			} catch (Exception e) {
+				LOG.error("Failed to close input", e);
+			}
+		});
+		loadedInputs.clear();
+	}
+
+	private void loadPlugins(JadxArgs args) {
+		pluginManager.providesSuggestion("java-input", args.isUseDxInput() ? "java-convert" : "java-input");
+		pluginManager.load();
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Resolved plugins: {}", Utils.collectionMap(pluginManager.getResolvedPlugins(),
+					p -> p.getPluginInfo().getPluginId()));
+		}
+		Map<String, String> pluginOptions = args.getPluginOptions();
+		if (!pluginOptions.isEmpty()) {
+			LOG.debug("Applying plugin options: {}", pluginOptions);
+			for (JadxPluginOptions plugin : pluginManager.getPluginsWithOptions()) {
+				try {
+					plugin.setOptions(pluginOptions);
+				} catch (Exception e) {
+					String pluginId = plugin.getPluginInfo().getPluginId();
+					throw new JadxRuntimeException("Failed to apply options for plugin: " + pluginId, e);
+				}
+			}
+		}
+	}
+
+	@SuppressWarnings("unused")
+	public void registerPlugin(JadxPlugin plugin) {
+		pluginManager.register(plugin);
 	}
 
 	public static String getVersion() {
 		return Jadx.getVersion();
 	}
 
-	public void loadFile(File file) throws JadxException {
-		loadFiles(Collections.singletonList(file));
-	}
-
-	public void loadFiles(List<File> files) throws JadxException {
-		if (files.isEmpty()) {
-			throw new JadxException("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);
-			}
-		}
-		parse();
-	}
-
 	public void save() {
 		save(!args.isSkipSources(), !args.isSkipResources());
 	}
 
+	public interface ProgressListener {
+		void progress(long done, long total);
+	}
+
+	@SuppressWarnings("BusyWait")
+	public void save(int intervalInMillis, ProgressListener listener) {
+		ThreadPoolExecutor ex = (ThreadPoolExecutor) getSaveExecutor();
+		ex.shutdown();
+		try {
+			long total = ex.getTaskCount();
+			while (ex.isTerminating()) {
+				long done = ex.getCompletedTaskCount();
+				listener.progress(done, total);
+				Thread.sleep(intervalInMillis);
+			}
+		} catch (InterruptedException e) {
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
+		}
+	}
+
 	public void saveSources() {
 		save(true, false);
 	}
@@ -130,13 +242,15 @@ public final class JadxDecompiler {
 		save(false, true);
 	}
 
+	@SuppressWarnings("ResultOfMethodCallIgnored")
 	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();
 		}
 	}
 
@@ -144,42 +258,113 @@ public final class JadxDecompiler {
 		return getSaveExecutor(!args.isSkipSources(), !args.isSkipResources());
 	}
 
+	public List<Runnable> getSaveTasks() {
+		return getSaveTasks(!args.isSkipSources(), !args.isSkipResources());
+	}
+
 	private ExecutorService getSaveExecutor(boolean saveSources, boolean saveResources) {
+		int threadsCount = args.getThreadsCount();
+		LOG.debug("processing threads count: {}", threadsCount);
+		LOG.info("processing ...");
+		ExecutorService executor = Executors.newFixedThreadPool(threadsCount);
+		List<Runnable> tasks = getSaveTasks(saveSources, saveResources);
+		tasks.forEach(executor::execute);
+		return executor;
+	}
+
+	private List<Runnable> getSaveTasks(boolean saveSources, boolean saveResources) {
 		if (root == null) {
 			throw new JadxRuntimeException("No loaded files");
 		}
-		int threadsCount = args.getThreadsCount();
-		LOG.debug("processing threads count: {}", threadsCount);
+		File sourcesOutDir;
+		File resOutDir;
+		if (args.isExportAsGradleProject()) {
+			ResourceFile androidManifest = resources.stream()
+					.filter(resourceFile -> resourceFile.getType() == ResourceType.MANIFEST)
+					.findFirst()
+					.orElseThrow(IllegalStateException::new);
 
-		LOG.info("processing ...");
-		ExecutorService executor = Executors.newFixedThreadPool(threadsCount);
-		if (saveSources) {
-			for (final JavaClass cls : getClasses()) {
-				executor.execute(new Runnable() {
-					@Override
-					public void run() {
-						cls.decompile();
-						SaveCode.save(outDir, args, cls.getClassNode());
-					}
-				});
-			}
+			ResContainer strings = resources.stream()
+					.filter(resourceFile -> resourceFile.getType() == ResourceType.ARSC)
+					.findFirst()
+					.orElseThrow(IllegalStateException::new)
+					.loadContent()
+					.getSubFiles()
+					.stream()
+					.filter(resContainer -> resContainer.getFileName().contains("strings.xml"))
+					.findFirst()
+					.orElseThrow(IllegalStateException::new);
+
+			ExportGradleProject export = new ExportGradleProject(root, args.getOutDir(), androidManifest, strings);
+			export.init();
+			sourcesOutDir = export.getSrcOutDir();
+			resOutDir = export.getResOutDir();
+		} else {
+			sourcesOutDir = args.getOutDirSrc();
+			resOutDir = args.getOutDirRes();
 		}
+		List<Runnable> tasks = new ArrayList<>();
+		// save resources first because decompilation can hang or fail
 		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()));
-							}
-						}
-					}
-				});
-			}
+			appendResourcesSaveTasks(tasks, resOutDir);
+		}
+		if (saveSources) {
+			appendSourcesSave(tasks, sourcesOutDir);
+		}
+		return tasks;
+	}
+
+	private void appendResourcesSaveTasks(List<Runnable> tasks, File outDir) {
+		if (args.isSkipFilesSave()) {
+			return;
+		}
+		Set<String> inputFileNames = args.getInputFiles().stream().map(File::getAbsolutePath).collect(Collectors.toSet());
+		for (ResourceFile resourceFile : getResources()) {
+			if (resourceFile.getType() != ResourceType.ARSC
+					&& inputFileNames.contains(resourceFile.getOriginalName())) {
+				// ignore resource made from input file
+				continue;
+			}
+			tasks.add(new ResourcesSaver(outDir, resourceFile));
+		}
+	}
+
+	private void appendSourcesSave(List<Runnable> tasks, File outDir) {
+		Predicate<String> classFilter = args.getClassFilter();
+		List<JavaClass> classes = getClasses();
+		List<JavaClass> processQueue = new ArrayList<>(classes.size());
+		for (JavaClass cls : classes) {
+			ClassNode clsNode = cls.getClassNode();
+			if (clsNode.contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			if (classFilter != null && !classFilter.test(clsNode.getClassInfo().getFullName())) {
+				if (!args.isIncludeDependencies()) {
+					clsNode.add(AFlag.DONT_GENERATE);
+				}
+				continue;
+			}
+			processQueue.add(cls);
+		}
+		List<List<JavaClass>> batches;
+		try {
+			batches = decompileScheduler.buildBatches(processQueue);
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Decompilation batches build failed", e);
+		}
+		for (List<JavaClass> decompileBatch : batches) {
+			tasks.add(() -> {
+				for (JavaClass cls : decompileBatch) {
+					try {
+						ClassNode clsNode = cls.getClassNode();
+						ICodeInfo code = clsNode.getCode();
+						SaveCode.save(outDir, clsNode, code);
+					} catch (Exception e) {
+						LOG.error("Error saving class: {}", cls, e);
+					}
+				}
+			});
 		}
-		return executor;
 	}
 
 	public List<JavaClass> getClasses() {
@@ -187,22 +372,31 @@ public final class JadxDecompiler {
 			return Collections.emptyList();
 		}
 		if (classes == null) {
-			List<ClassNode> classNodeList = root.getClasses(false);
-			List<JavaClass> clsList = new ArrayList<JavaClass>(classNodeList.size());
+			List<ClassNode> classNodeList = root.getClasses();
+			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
 			for (ClassNode classNode : classNodeList) {
-				clsList.add(new JavaClass(classNode, this));
+				if (classNode.contains(AFlag.DONT_GENERATE)) {
+					continue;
+				}
+				if (!classNode.getClassInfo().isInner()) {
+					clsList.add(convertClassNode(classNode));
+				}
 			}
 			classes = Collections.unmodifiableList(clsList);
 		}
 		return classes;
 	}
 
+	public List<JavaClass> getClassesWithInners() {
+		return Utils.collectionMap(root.getClasses(), this::convertClassNode);
+	}
+
 	public List<ResourceFile> getResources() {
 		if (resources == null) {
 			if (root == null) {
 				return Collections.emptyList();
 			}
-			resources = new ResourcesLoader(this).load(inputFiles);
+			resources = new ResourcesLoader(this).load();
 		}
 		return resources;
 	}
@@ -212,28 +406,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, String.CASE_INSENSITIVE_ORDER));
 		}
 		return Collections.unmodifiableList(packages);
 	}
@@ -245,69 +430,219 @@ public final class JadxDecompiler {
 		return root.getErrorsCounter().getErrorCount();
 	}
 
+	public int getWarnsCount() {
+		if (root == null) {
+			return 0;
+		}
+		return root.getErrorsCounter().getWarnsCount();
+	}
+
 	public void printErrorsReport() {
 		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 {
-				pass.init(root);
-			} catch (Exception e) {
-				LOG.error("Visitor init failed: {}", pass.getClass().getSimpleName(), e);
-			}
-		}
-	}
-
-	void processClass(ClassNode cls) {
-		ProcessClass.process(cls, passes, codeGen);
-	}
-
-	RootNode getRoot() {
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public RootNode getRoot() {
 		return root;
 	}
 
-	BinaryXMLParser getXmlParser() {
-		if (xmlParser == null) {
-			xmlParser = new BinaryXMLParser(root);
+	synchronized BinaryXMLParser getBinaryXmlParser() {
+		if (binaryXmlParser == null) {
+			binaryXmlParser = new BinaryXMLParser(root);
 		}
-		return xmlParser;
+		return binaryXmlParser;
 	}
 
-	JavaClass findJavaClass(ClassNode cls) {
-		if (cls == null) {
-			return null;
+	synchronized ProtoXMLParser getProtoXmlParser() {
+		if (protoXmlParser == null) {
+			protoXmlParser = new ProtoXMLParser(root);
 		}
-		for (JavaClass javaClass : getClasses()) {
-			if (javaClass.getClassNode().equals(cls)) {
-				return javaClass;
+		return protoXmlParser;
+	}
+
+	/**
+	 * Get JavaClass by ClassNode without loading and decompilation
+	 */
+	@ApiStatus.Internal
+	JavaClass convertClassNode(ClassNode cls) {
+		return classesMap.compute(cls, (node, prevJavaCls) -> {
+			if (prevJavaCls != null && prevJavaCls.getClassNode() == cls) {
+				// keep previous variable
+				return prevJavaCls;
+			}
+			if (cls.isInner()) {
+				return new JavaClass(cls, convertClassNode(cls.getParentClass()));
+			}
+			return new JavaClass(cls, this);
+		});
+	}
+
+	@ApiStatus.Internal
+	JavaField convertFieldNode(FieldNode field) {
+		return fieldsMap.computeIfAbsent(field, fldNode -> {
+			JavaClass parentCls = convertClassNode(fldNode.getParentClass());
+			return new JavaField(parentCls, fldNode);
+		});
+	}
+
+	@ApiStatus.Internal
+	JavaMethod convertMethodNode(MethodNode method) {
+		return methodsMap.computeIfAbsent(method, mthNode -> {
+			ClassNode parentCls = mthNode.getParentClass();
+			return new JavaMethod(convertClassNode(parentCls), mthNode);
+		});
+	}
+
+	@Nullable
+	public JavaClass searchJavaClassByOrigFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.map(this::convertClassNode)
+				.orElse(null);
+	}
+
+	@Nullable
+	public ClassNode searchClassNodeByOrigFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.orElse(null);
+	}
+
+	// returns parent if class contains DONT_GENERATE flag.
+	@Nullable
+	public JavaClass searchJavaClassOrItsParentByOrigFullName(String fullName) {
+		ClassNode node = getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.orElse(null);
+		if (node != null) {
+			if (node.contains(AFlag.DONT_GENERATE)) {
+				return convertClassNode(node.getTopParentClass());
+			} else {
+				return convertClassNode(node);
 			}
 		}
 		return null;
 	}
 
-	public IJadxArgs getArgs() {
+	@Nullable
+	public JavaClass searchJavaClassByAliasFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getAliasFullName().equals(fullName))
+				.findFirst()
+				.map(this::convertClassNode)
+				.orElse(null);
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeByRef(ICodeNodeRef ann) {
+		return getJavaNodeByCodeAnnotation(null, ann);
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeByCodeAnnotation(@Nullable ICodeInfo codeInfo, @Nullable ICodeAnnotation ann) {
+		if (ann == null) {
+			return null;
+		}
+		switch (ann.getAnnType()) {
+			case CLASS:
+				return convertClassNode((ClassNode) ann);
+			case METHOD:
+				return convertMethodNode((MethodNode) ann);
+			case FIELD:
+				return convertFieldNode((FieldNode) ann);
+			case DECLARATION:
+				return getJavaNodeByCodeAnnotation(codeInfo, ((NodeDeclareRef) ann).getNode());
+			case VAR:
+				return resolveVarNode((VarNode) ann);
+			case VAR_REF:
+				return resolveVarRef(codeInfo, (VarRef) ann);
+			case OFFSET:
+				// offset annotation don't have java node object
+				return null;
+			default:
+				throw new JadxRuntimeException("Unknown annotation type: " + ann.getAnnType() + ", class: " + ann.getClass());
+		}
+	}
+
+	@Nullable
+	private JavaVariable resolveVarNode(VarNode varNode) {
+		MethodNode mthNode = varNode.getMth();
+		JavaMethod mth = convertMethodNode(mthNode);
+		if (mth == null) {
+			return null;
+		}
+		return new JavaVariable(mth, varNode);
+	}
+
+	@Nullable
+	private JavaVariable resolveVarRef(ICodeInfo codeInfo, VarRef varRef) {
+		if (codeInfo == null) {
+			throw new JadxRuntimeException("Missing code info for resolve VarRef: " + varRef);
+		}
+		ICodeAnnotation varNodeAnn = codeInfo.getCodeMetadata().getAt(varRef.getRefPos());
+		if (varNodeAnn != null && varNodeAnn.getAnnType() == ICodeAnnotation.AnnType.DECLARATION) {
+			ICodeNodeRef nodeRef = ((NodeDeclareRef) varNodeAnn).getNode();
+			if (nodeRef.getAnnType() == ICodeAnnotation.AnnType.VAR) {
+				return resolveVarNode((VarNode) nodeRef);
+			}
+		}
+		return null;
+	}
+
+	List<JavaNode> convertNodes(Collection<? extends ICodeNodeRef> nodesList) {
+		return nodesList.stream()
+				.map(this::getJavaNodeByRef)
+				.filter(Objects::nonNull)
+				.collect(Collectors.toList());
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeAtPosition(ICodeInfo codeInfo, int pos) {
+		ICodeAnnotation ann = codeInfo.getCodeMetadata().getAt(pos);
+		return getJavaNodeByCodeAnnotation(codeInfo, ann);
+	}
+
+	@Nullable
+	public JavaNode getClosestJavaNode(ICodeInfo codeInfo, int pos) {
+		ICodeAnnotation ann = codeInfo.getCodeMetadata().getClosestUp(pos);
+		return getJavaNodeByCodeAnnotation(codeInfo, ann);
+	}
+
+	@Nullable
+	public JavaNode getEnclosingNode(ICodeInfo codeInfo, int pos) {
+		ICodeNodeRef obj = codeInfo.getCodeMetadata().getNodeAt(pos);
+		if (obj == null) {
+			return null;
+		}
+		return getJavaNodeByRef(obj);
+	}
+
+	public void reloadCodeData() {
+		root.notifyCodeDataListeners();
+	}
+
+	public JadxArgs getArgs() {
 		return args;
 	}
 
+	public JadxPluginManager getPluginManager() {
+		return pluginManager;
+	}
+
+	public IDecompileScheduler getDecompileScheduler() {
+		return decompileScheduler;
+	}
+
 	@Override
 	public String toString() {
 		return "jadx decompiler " + getVersion();

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

@@ -1,28 +1,42 @@
 package jadx.api;
 
-import jadx.core.codegen.CodeWriter;
-import jadx.core.dex.attributes.AFlag;
-import jadx.core.dex.attributes.nodes.LineAttrNode;
-import jadx.core.dex.info.AccessInfo;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.FieldNode;
-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.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.nodes.AnonymousClassAttr;
+import jadx.core.dex.attributes.nodes.InlinedAttr;
+import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.utils.ListUtils;
+
 public final class JavaClass implements JavaNode {
+	private static final Logger LOG = LoggerFactory.getLogger(JavaClass.class);
 
 	private final JadxDecompiler decompiler;
 	private final ClassNode cls;
 	private final JavaClass parent;
 
 	private List<JavaClass> innerClasses = Collections.emptyList();
+	private List<JavaClass> inlinedClasses = Collections.emptyList();
 	private List<JavaField> fields = Collections.emptyList();
 	private List<JavaMethod> methods = Collections.emptyList();
+	private boolean listsLoaded;
 
 	JavaClass(ClassNode classNode, JadxDecompiler decompiler) {
 		this.decompiler = decompiler;
@@ -40,51 +54,109 @@ public final class JavaClass implements JavaNode {
 	}
 
 	public String getCode() {
-		CodeWriter code = cls.getCode();
-		if (code == null) {
-			decompile();
-			code = cls.getCode();
+		return getCodeInfo().getCodeStr();
+	}
+
+	public @NotNull ICodeInfo getCodeInfo() {
+		ICodeInfo code = load();
+		if (code != null) {
+			return code;
 		}
-		if (code == null) {
-			return "";
-		}
-		return code.toString();
+		return cls.decompile();
 	}
 
 	public void decompile() {
-		if (decompiler == null) {
-			return;
-		}
-		if (cls.getCode() == null) {
-			decompiler.processClass(cls);
-			load();
-		}
+		load();
 	}
 
-	ClassNode getClassNode() {
+	public synchronized ICodeInfo reload() {
+		listsLoaded = false;
+		return cls.reloadCode();
+	}
+
+	public void unload() {
+		listsLoaded = false;
+		cls.unloadCode();
+	}
+
+	public boolean isNoCode() {
+		return cls.contains(AFlag.DONT_GENERATE);
+	}
+
+	public boolean isInner() {
+		return cls.isInner();
+	}
+
+	public synchronized String getSmali() {
+		return cls.getDisassembledCode();
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.CLASS) {
+			return ann.equals(cls);
+		}
+		return false;
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public ClassNode getClassNode() {
 		return cls;
 	}
 
-	private void load() {
+	/**
+	 * Decompile class and loads internal lists of fields, methods, etc.
+	 * Do nothing if already loaded.
+	 *
+	 * @return code info if decompilation was executed, null otherwise
+	 */
+	private synchronized @Nullable ICodeInfo load() {
+		if (listsLoaded) {
+			return null;
+		}
+		listsLoaded = true;
+
+		ICodeInfo code;
+		if (cls.getState().isProcessComplete()) {
+			// already decompiled -> class internals loaded
+			code = null;
+		} else {
+			code = cls.decompile();
+		}
+
+		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 javaClass = rootDecompiler.convertClassNode(inner);
 					javaClass.load();
 					list.add(javaClass);
 				}
 			}
 			this.innerClasses = Collections.unmodifiableList(list);
 		}
+		int inlinedClsCount = cls.getInlinedClasses().size();
+		if (inlinedClsCount != 0) {
+			List<JavaClass> list = new ArrayList<>(inlinedClsCount);
+			for (ClassNode inner : cls.getInlinedClasses()) {
+				JavaClass javaClass = rootDecompiler.convertClassNode(inner);
+				javaClass.load();
+				list.add(javaClass);
+			}
+			this.inlinedClasses = Collections.unmodifiableList(list);
+		}
 
 		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));
+					flds.add(rootDecompiler.convertFieldNode(f));
 				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
@@ -92,63 +164,69 @@ 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));
+					mths.add(rootDecompiler.convertMethodNode(m));
 				}
 			}
-			Collections.sort(mths, new Comparator<JavaMethod>() {
-				@Override
-				public int compare(JavaMethod o1, JavaMethod o2) {
-					return o1.getName().compareTo(o2.getName());
-				}
-			});
+			mths.sort(Comparator.comparing(JavaMethod::getName));
 			this.methods = Collections.unmodifiableList(mths);
 		}
+		return code;
 	}
 
-	private Map<CodePosition, Object> getCodeAnnotations() {
-		decompile();
-		return cls.getCode().getAnnotations();
+	JadxDecompiler getRootDecompiler() {
+		if (parent != null) {
+			return parent.getRootDecompiler();
+		}
+		return decompiler;
 	}
 
-	public CodePosition getDefinitionPosition(int line, int offset) {
-		Map<CodePosition, Object> map = getCodeAnnotations();
-		if (map.isEmpty()) {
+	public ICodeAnnotation getAnnotationAt(int pos) {
+		return getCodeInfo().getCodeMetadata().getAt(pos);
+	}
+
+	public Map<Integer, JavaNode> getUsageMap() {
+		Map<Integer, ICodeAnnotation> map = getCodeInfo().getCodeMetadata().getAsMap();
+		if (map.isEmpty() || decompiler == null) {
+			return Collections.emptyMap();
+		}
+		Map<Integer, JavaNode> resultMap = new HashMap<>(map.size());
+		for (Map.Entry<Integer, ICodeAnnotation> entry : map.entrySet()) {
+			int codePosition = entry.getKey();
+			ICodeAnnotation obj = entry.getValue();
+			if (obj instanceof ICodeNodeRef) {
+				JavaNode node = getRootDecompiler().getJavaNodeByRef((ICodeNodeRef) obj);
+				if (node != null) {
+					resultMap.put(codePosition, node);
+				}
+			}
+		}
+		return resultMap;
+	}
+
+	public List<Integer> getUsePlacesFor(ICodeInfo codeInfo, JavaNode javaNode) {
+		if (!codeInfo.hasMetadata()) {
+			return Collections.emptyList();
+		}
+		List<Integer> result = new ArrayList<>();
+		codeInfo.getCodeMetadata().searchDown(0, (pos, ann) -> {
+			if (javaNode.isOwnCodeAnnotation(ann)) {
+				result.add(pos);
+			}
 			return null;
-		}
-		Object obj = map.get(new CodePosition(line, offset));
-		if (!(obj instanceof LineAttrNode)) {
-			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 null;
-		}
-		jCls.decompile();
-		int defLine = ((LineAttrNode) obj).getDecompiledLine();
-		if (defLine == 0) {
-			return null;
-		}
-		return new CodePosition(jCls, defLine, 0);
+		});
+		return result;
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getRootDecompiler().convertNodes(cls.getUseIn());
 	}
 
 	public Integer getSourceLine(int decompiledLine) {
-		decompile();
-		return cls.getCode().getLineMapping().get(decompiledLine);
+		return getCodeInfo().getCodeMetadata().getLineMapping().get(decompiledLine);
 	}
 
 	@Override
@@ -161,6 +239,10 @@ public final class JavaClass implements JavaNode {
 		return cls.getFullName();
 	}
 
+	public String getRawName() {
+		return cls.getRawName();
+	}
+
 	public String getPackage() {
 		return cls.getPackage();
 	}
@@ -170,27 +252,89 @@ public final class JavaClass implements JavaNode {
 		return parent;
 	}
 
+	public JavaClass getOriginalTopParentClass() {
+		return parent == null ? this : parent.getOriginalTopParentClass();
+	}
+
+	/**
+	 * Return top parent class which contains code of this class.
+	 * Code parent can be different from original parent after move or inline
+	 *
+	 * @return this if already a top class
+	 */
+	@Override
+	public JavaClass getTopParentClass() {
+		JavaClass codeParent = getCodeParent();
+		return codeParent == null ? this : codeParent.getTopParentClass();
+	}
+
+	/**
+	 * Return parent class which contains code of this class.
+	 * Code parent can be different for original parent after move or inline
+	 */
+	public @Nullable JavaClass getCodeParent() {
+		AnonymousClassAttr anonymousClsAttr = cls.get(AType.ANONYMOUS_CLASS);
+		if (anonymousClsAttr != null) {
+			// moved to usage class
+			return getRootDecompiler().convertClassNode(anonymousClsAttr.getOuterCls());
+		}
+		InlinedAttr inlinedAttr = cls.get(AType.INLINED);
+		if (inlinedAttr != null) {
+			return getRootDecompiler().convertClassNode(inlinedAttr.getInlineCls());
+		}
+		return parent;
+	}
+
 	public AccessInfo getAccessInfo() {
 		return cls.getAccessFlags();
 	}
 
 	public List<JavaClass> getInnerClasses() {
-		decompile();
+		load();
 		return innerClasses;
 	}
 
+	public List<JavaClass> getInlinedClasses() {
+		load();
+		return inlinedClasses;
+	}
+
 	public List<JavaField> getFields() {
-		decompile();
+		load();
 		return fields;
 	}
 
 	public List<JavaMethod> getMethods() {
-		decompile();
+		load();
 		return methods;
 	}
 
-	public int getDecompiledLine() {
-		return cls.getDecompiledLine();
+	@Nullable
+	public JavaMethod searchMethodByShortId(String shortId) {
+		MethodNode methodNode = cls.searchMethodByShortId(shortId);
+		if (methodNode == null) {
+			return null;
+		}
+		return getRootDecompiler().convertMethodNode(methodNode);
+	}
+
+	public List<JavaClass> getDependencies() {
+		JadxDecompiler d = getRootDecompiler();
+		return ListUtils.map(cls.getDependencies(), d::convertClassNode);
+	}
+
+	public int getTotalDepsCount() {
+		return cls.getTotalDepsCount();
+	}
+
+	@Override
+	public void removeAlias() {
+		this.cls.getClassInfo().removeAlias();
+	}
+
+	@Override
+	public int getDefPos() {
+		return cls.getDefPosition();
 	}
 
 	@Override
@@ -205,6 +349,6 @@ public final class JavaClass implements JavaNode {
 
 	@Override
 	public String toString() {
-		return cls.getFullName() + "[ " + getFullName() + " ]";
+		return getFullName();
 	}
 }

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

@@ -1,5 +1,10 @@
 package jadx.api;
 
+import java.util.List;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.api.metadata.ICodeAnnotation;
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.FieldNode;
@@ -9,7 +14,7 @@ public final class JavaField implements JavaNode {
 	private final FieldNode field;
 	private final JavaClass parent;
 
-	JavaField(FieldNode f, JavaClass cls) {
+	JavaField(JavaClass cls, FieldNode f) {
 		this.field = f;
 		this.parent = cls;
 	}
@@ -21,7 +26,11 @@ public final class JavaField implements JavaNode {
 
 	@Override
 	public String getFullName() {
-		return parent.getFullName() + "." + getName();
+		return parent.getFullName() + '.' + getName();
+	}
+
+	public String getRawName() {
+		return field.getName();
 	}
 
 	@Override
@@ -29,15 +38,62 @@ public final class JavaField implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessFlags() {
 		return field.getAccessFlags();
 	}
 
 	public ArgType getType() {
-		return field.getType();
+		return ArgType.tryToResolveClassAlias(field.root(), field.getType());
 	}
 
-	public int getDecompiledLine() {
-		return field.getDecompiledLine();
+	@Override
+	public int getDefPos() {
+		return field.getDefPosition();
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getDeclaringClass().getRootDecompiler().convertNodes(field.getUseIn());
+	}
+
+	@Override
+	public void removeAlias() {
+		this.field.getFieldInfo().removeAlias();
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.FIELD) {
+			return ann.equals(field);
+		}
+		return false;
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public FieldNode getFieldNode() {
+		return field;
+	}
+
+	@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

@@ -1,12 +1,25 @@
 package jadx.api;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.nodes.MethodOverrideAttr;
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.MethodNode;
-
-import java.util.List;
+import jadx.core.utils.Utils;
 
 public final class JavaMethod implements JavaNode {
+	private static final Logger LOG = LoggerFactory.getLogger(JavaMethod.class);
+
 	private final MethodNode mth;
 	private final JavaClass parent;
 
@@ -30,16 +43,51 @@ public final class JavaMethod implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessFlags() {
 		return mth.getAccessFlags();
 	}
 
 	public List<ArgType> getArguments() {
-		return mth.getMethodInfo().getArgumentsTypes();
+		List<ArgType> infoArgTypes = mth.getMethodInfo().getArgumentsTypes();
+		if (infoArgTypes.isEmpty()) {
+			return Collections.emptyList();
+		}
+		List<ArgType> arguments = mth.getArgTypes();
+		return Utils.collectionMap(arguments,
+				type -> ArgType.tryToResolveClassAlias(mth.root(), type));
 	}
 
 	public ArgType getReturnType() {
-		return mth.getReturnType();
+		ArgType retType = mth.getReturnType();
+		return ArgType.tryToResolveClassAlias(mth.root(), retType);
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getDeclaringClass().getRootDecompiler().convertNodes(mth.getUseIn());
+	}
+
+	public List<JavaMethod> getOverrideRelatedMethods() {
+		MethodOverrideAttr ovrdAttr = mth.get(AType.METHOD_OVERRIDE);
+		if (ovrdAttr == null) {
+			return Collections.emptyList();
+		}
+		JadxDecompiler decompiler = getDeclaringClass().getRootDecompiler();
+		return ovrdAttr.getRelatedMthNodes().stream()
+				.map(m -> {
+					JavaMethod javaMth = decompiler.convertMethodNode(m);
+					if (javaMth == null) {
+						LOG.warn("Failed convert to java method: {}", m);
+					}
+					return javaMth;
+				})
+				.filter(Objects::nonNull)
+				.collect(Collectors.toList());
 	}
 
 	public boolean isConstructor() {
@@ -50,7 +98,44 @@ public final class JavaMethod implements JavaNode {
 		return mth.getMethodInfo().isClassInit();
 	}
 
-	public int getDecompiledLine() {
-		return mth.getDecompiledLine();
+	@Override
+	public int getDefPos() {
+		return mth.getDefPosition();
+	}
+
+	@Override
+	public void removeAlias() {
+		this.mth.getMethodInfo().removeAlias();
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.METHOD) {
+			return ann.equals(mth);
+		}
+		return false;
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public MethodNode getMethodNode() {
+		return mth;
+	}
+
+	@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

@@ -1,5 +1,9 @@
 package jadx.api;
 
+import java.util.List;
+
+import jadx.api.metadata.ICodeAnnotation;
+
 public interface JavaNode {
 
 	String getName();
@@ -7,4 +11,15 @@ public interface JavaNode {
 	String getFullName();
 
 	JavaClass getDeclaringClass();
+
+	JavaClass getTopParentClass();
+
+	int getDefPos();
+
+	List<JavaNode> getUseIn();
+
+	default void removeAlias() {
+	}
+
+	boolean isOwnCodeAnnotation(ICodeAnnotation ann);
 }

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

@@ -1,9 +1,12 @@
 package jadx.api;
 
+import java.util.Collections;
 import java.util.List;
 
 import org.jetbrains.annotations.NotNull;
 
+import jadx.api.metadata.ICodeAnnotation;
+
 public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 	private final String name;
 	private final List<JavaClass> classes;
@@ -33,6 +36,26 @@ public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 		return null;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return null;
+	}
+
+	@Override
+	public int getDefPos() {
+		return 0;
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return Collections.emptyList();
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		return false;
+	}
+
 	@Override
 	public int compareTo(@NotNull JavaPackage o) {
 		return name.compareTo(o.name);

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

@@ -0,0 +1,98 @@
+package jadx.api;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.annotations.VarNode;
+import jadx.api.metadata.annotations.VarRef;
+import jadx.core.dex.instructions.args.ArgType;
+
+public class JavaVariable implements JavaNode {
+	private final JavaMethod mth;
+	private final VarNode varNode;
+
+	public JavaVariable(JavaMethod mth, VarNode varNode) {
+		this.mth = mth;
+		this.varNode = varNode;
+	}
+
+	public JavaMethod getMth() {
+		return mth;
+	}
+
+	public int getReg() {
+		return varNode.getReg();
+	}
+
+	public int getSsa() {
+		return varNode.getSsa();
+	}
+
+	@Override
+	public @Nullable String getName() {
+		return varNode.getName();
+	}
+
+	@ApiStatus.Internal
+	public VarNode getVarNode() {
+		return varNode;
+	}
+
+	@Override
+	public String getFullName() {
+		return varNode.getType() + " " + varNode.getName() + " (r" + varNode.getReg() + "v" + varNode.getSsa() + ")";
+	}
+
+	public ArgType getType() {
+		return ArgType.tryToResolveClassAlias(mth.getMethodNode().root(), varNode.getType());
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return mth.getDeclaringClass();
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return mth.getTopParentClass();
+	}
+
+	@Override
+	public int getDefPos() {
+		return varNode.getDefPosition();
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return Collections.singletonList(mth);
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.VAR_REF) {
+			VarRef varRef = (VarRef) ann;
+			return varRef.getRefPos() == getDefPos();
+		}
+		return false;
+	}
+
+	@Override
+	public int hashCode() {
+		return varNode.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof JavaVariable)) {
+			return false;
+		}
+		return varNode.equals(((JavaVariable) o).varNode);
+	}
+}

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

@@ -1,9 +1,11 @@
 package jadx.api;
 
-import jadx.core.codegen.CodeWriter;
-
 import java.io.File;
 
+import jadx.api.plugins.utils.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.entry.ResourceEntry;
+
 public class ResourceFile {
 
 	public static final class ZipRef {
@@ -33,22 +35,38 @@ public class ResourceFile {
 	private final String name;
 	private final ResourceType type;
 	private ZipRef zipRef;
+	private String deobfName;
 
-	ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+	public static ResourceFile createResourceFile(JadxDecompiler decompiler, File file, ResourceType type) {
+		return new ResourceFile(decompiler, file.getAbsolutePath(), type);
+	}
+
+	public static ResourceFile createResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+		if (!ZipSecurity.isValidZipEntryName(name)) {
+			return null;
+		}
+		return new ResourceFile(decompiler, name, type);
+	}
+
+	protected ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
 		this.decompiler = decompiler;
 		this.name = name;
 		this.type = type;
 	}
 
-	public String getName() {
+	public String getOriginalName() {
 		return name;
 	}
 
+	public String getDeobfName() {
+		return deobfName != null ? deobfName : name;
+	}
+
 	public ResourceType getType() {
 		return type;
 	}
 
-	public CodeWriter getContent() {
+	public ResContainer loadContent() {
 		return ResourcesLoader.loadContent(decompiler, this);
 	}
 
@@ -56,12 +74,21 @@ public class ResourceFile {
 		this.zipRef = zipRef;
 	}
 
-	ZipRef getZipRef() {
+	public void setAlias(ResourceEntry ri) {
+		int index = name.lastIndexOf('.');
+		deobfName = String.format("res/%s%s/%s%s",
+				ri.getTypeName(),
+				ri.getConfig(),
+				ri.getKeyName(),
+				index == -1 ? "" : name.substring(index));
+	}
+
+	public ZipRef getZipRef() {
 		return zipRef;
 	}
 
 	@Override
 	public String toString() {
-		return "ResourceFile{name='" + name + '\'' + ", type=" + type + "}";
+		return "ResourceFile{name='" + name + '\'' + ", type=" + type + '}';
 	}
 }

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

@@ -0,0 +1,17 @@
+package jadx.api;
+
+import jadx.core.xmlgen.ResContainer;
+
+public class ResourceFileContent extends ResourceFile {
+	private final ICodeInfo content;
+
+	public ResourceFileContent(String name, ResourceType type, ICodeInfo content) {
+		super(null, name, type);
+		this.content = content;
+	}
+
+	@Override
+	public ResContainer loadContent() {
+		return ResContainer.textResource(getDeobfName(), content);
+	}
+}

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

@@ -1,13 +1,20 @@
 package jadx.api;
 
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
 public enum ResourceType {
-	CODE(".dex", ".class"),
-	MANIFEST("AndroidManifest.xml"),
-	XML(".xml"), // TODO binary or not?
-	ARSC(".arsc"), // TODO decompile !!!
-	FONT(".ttf"),
+	CODE(".dex", ".jar", ".class"),
+	XML(".xml"),
+	ARSC(".arsc"),
+	FONT(".ttf", ".otf"),
 	IMG(".png", ".gif", ".jpg"),
+	MEDIA(".mp3", ".wav"),
 	LIB(".so"),
+	MANIFEST,
 	UNKNOWN;
 
 	private final String[] exts;
@@ -20,31 +27,34 @@ public enum ResourceType {
 		return exts;
 	}
 
-	public static ResourceType getFileType(String fileName) {
+	private static final Map<String, ResourceType> EXT_MAP = new HashMap<>();
+
+	static {
 		for (ResourceType type : ResourceType.values()) {
 			for (String ext : type.getExts()) {
-				if (fileName.endsWith(ext)) {
-					return type;
+				ResourceType prev = EXT_MAP.put(ext, type);
+				if (prev != null) {
+					throw new JadxRuntimeException("Duplicate extension in ResourceType: " + ext);
 				}
 			}
 		}
+	}
+
+	public static ResourceType getFileType(String fileName) {
+		if (fileName.endsWith("/resources.pb")) {
+			return ARSC;
+		}
+		int dot = fileName.lastIndexOf('.');
+		if (dot != -1) {
+			String ext = fileName.substring(dot).toLowerCase(Locale.ROOT);
+			ResourceType resType = EXT_MAP.get(ext);
+			if (resType != null) {
+				if (resType == XML && fileName.equals("AndroidManifest.xml")) {
+					return MANIFEST;
+				}
+				return resType;
+			}
+		}
 		return UNKNOWN;
 	}
-
-	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:
-				return true;
-		}
-		return false;
-	}
 }

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

@@ -1,19 +1,12 @@
 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;
-import java.util.Enumeration;
 import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
@@ -21,118 +14,140 @@ import java.util.zip.ZipFile;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.ResourceFile.ZipRef;
+import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.plugins.utils.ZipSecurity;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.Utils;
+import jadx.core.utils.android.Res9patchStreamDecoder;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.ResProtoParser;
+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;
 
 	ResourcesLoader(JadxDecompiler jadxRef) {
 		this.jadxRef = jadxRef;
 	}
 
-	List<ResourceFile> load(List<InputFile> inputFiles) {
-		List<ResourceFile> list = new ArrayList<ResourceFile>(inputFiles.size());
-		for (InputFile file : inputFiles) {
-			loadFile(list, file.getFile());
+	List<ResourceFile> load() {
+		List<File> inputFiles = jadxRef.getArgs().getInputFiles();
+		List<ResourceFile> list = new ArrayList<>(inputFiles.size());
+		for (File file : inputFiles) {
+			loadFile(list, file);
 		}
 		return list;
 	}
 
-	public interface ResourceDecoder {
-		Object decode(long size, InputStream is) throws IOException;
+	public interface ResourceDecoder<T> {
+		T 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 <T> T decodeStream(ResourceFile rf, ResourceDecoder<T> 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.getOriginalName());
+				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 = ZipSecurity.getInputStreamForEntry(zipFile, entry)) {
+						return decoder.decode(entry.getSize(), inputStream);
 					}
-					return loadContent(jadxRef, rf.getType(), is);
 				}
-			});
+			}
+		} catch (Exception e) {
+			throw new JadxException("Error decode: " + rf.getDeobfName(), e);
+		}
+	}
+
+	static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf) {
+		try {
+			return decodeStream(rf, (size, is) -> loadContent(jadxRef, rf, is));
 		} catch (JadxException e) {
 			LOG.error("Decode error", e);
-			CodeWriter cw = new CodeWriter();
+			ICodeWriter cw = jadxRef.getRoot().makeCodeWriter();
 			cw.add("Error decode ").add(rf.getType().toString().toLowerCase());
-			cw.startLine(Utils.getStackTrace(e.getCause()));
-			return cw;
+			Utils.appendStackTrace(cw, e.getCause());
+			return ResContainer.textResource(rf.getDeobfName(), cw.finish());
 		}
 	}
 
-	private static CodeWriter loadContent(JadxDecompiler jadxRef, ResourceType type,
+	private static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf,
 			InputStream inputStream) throws IOException {
-		switch (type) {
+		RootNode root = jadxRef.getRoot();
+		switch (rf.getType()) {
 			case MANIFEST:
-			case XML:
-				return jadxRef.getXmlParser().parse(inputStream);
+			case XML: {
+				ICodeInfo content;
+				if (root.isProto()) {
+					content = jadxRef.getProtoXmlParser().parse(inputStream);
+				} else {
+					content = jadxRef.getBinaryXmlParser().parse(inputStream);
+				}
+				return ResContainer.textResource(rf.getDeobfName(), content);
+			}
 
 			case ARSC:
-				return new ResTableParser().decodeToCodeWriter(inputStream);
+				if (root.isProto()) {
+					return new ResProtoParser(root).decodeFiles(inputStream);
+				} else {
+					return new ResTableParser(root).decodeFiles(inputStream);
+				}
+
+			case IMG:
+				return decodeImage(rf, inputStream);
+
+			default:
+				return ResContainer.resourceFileLink(rf);
 		}
-		return loadToCodeWriter(inputStream);
+	}
+
+	private static ResContainer decodeImage(ResourceFile rf, InputStream inputStream) {
+		String name = rf.getOriginalName();
+		if (name.endsWith(".9.png")) {
+			try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
+				Res9patchStreamDecoder decoder = new Res9patchStreamDecoder();
+				if (decoder.decode(inputStream, os)) {
+					return ResContainer.decodedData(rf.getDeobfName(), os.toByteArray());
+				}
+			} catch (Exception e) {
+				LOG.error("Failed to decode 9-patch png image, path: {}", name, e);
+			}
+		}
+		return ResContainer.resourceFileLink(rf);
 	}
 
 	private void loadFile(List<ResourceFile> list, File file) {
-		if (file == null) {
+		if (file == null || file.isDirectory()) {
 			return;
 		}
-		ZipFile zip = null;
-		try {
-			zip = new ZipFile(file);
-			Enumeration<? extends ZipEntry> entries = zip.entries();
-			while (entries.hasMoreElements()) {
-				ZipEntry entry = entries.nextElement();
+		if (FileUtils.isZipFile(file)) {
+			ZipSecurity.visitZipEntries(file, (zipFile, entry) -> {
 				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);
-				}
-			}
+				return null;
+			});
+		} else {
+			ResourceType type = ResourceType.getFileType(file.getAbsolutePath());
+			list.add(ResourceFile.createResourceFile(jadxRef, file, type));
 		}
 	}
 
@@ -142,28 +157,16 @@ 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.createResourceFile(jadxRef, name, type);
+		if (rf != null) {
+			rf.setZipRef(new ZipRef(zipFile, name));
+			list.add(rf);
+		}
 	}
 
-	private static CodeWriter loadToCodeWriter(InputStream is) throws IOException {
-		CodeWriter cw = new CodeWriter();
+	public static ICodeInfo loadToCodeWriter(InputStream is) throws IOException {
 		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) {
-			}
-		}
-		cw.add(baos.toString("UTF-8"));
-		return cw;
+		copyStream(is, baos);
+		return new SimpleCodeInfo(baos.toString("UTF-8"));
 	}
 }

jadx-core/src/main/java/jadx/api/args/DeobfuscationMapFileMode.java

@@ -0,0 +1,32 @@
+package jadx.api.args;
+
+public enum DeobfuscationMapFileMode {
+
+	/**
+	 * Load if found, don't save (default)
+	 */
+	READ,
+
+	/**
+	 * Load if found, save only if new (don't overwrite)
+	 */
+	READ_OR_SAVE,
+
+	/**
+	 * Don't load, always save
+	 */
+	OVERWRITE,
+
+	/**
+	 * Don't load and don't save
+	 */
+	IGNORE;
+
+	public boolean shouldRead() {
+		return this == READ || this == READ_OR_SAVE;
+	}
+
+	public boolean shouldWrite() {
+		return this == READ_OR_SAVE || this == OVERWRITE;
+	}
+}

jadx-core/src/main/java/jadx/api/args/ResourceNameSource.java

@@ -0,0 +1,22 @@
+package jadx.api.args;
+
+/**
+ * Resources original name source (for deobfuscation)
+ */
+public enum ResourceNameSource {
+
+	/**
+	 * Automatically select best name (default)
+	 */
+	AUTO,
+
+	/**
+	 * Force use resources provided names
+	 */
+	RESOURCES,
+
+	/**
+	 * Force use resources names from R class
+	 */
+	CODE,
+}

jadx-core/src/main/java/jadx/api/data/CodeRefType.java

@@ -0,0 +1,8 @@
+package jadx.api.data;
+
+public enum CodeRefType {
+	MTH_ARG,
+	VAR,
+	CATCH,
+	INSN,
+}

jadx-core/src/main/java/jadx/api/data/ICodeComment.java

@@ -0,0 +1,13 @@
+package jadx.api.data;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface ICodeComment extends Comparable<ICodeComment> {
+
+	IJavaNodeRef getNodeRef();
+
+	@Nullable
+	IJavaCodeRef getCodeRef();
+
+	String getComment();
+}

jadx-core/src/main/java/jadx/api/data/ICodeData.java

@@ -0,0 +1,10 @@
+package jadx.api.data;
+
+import java.util.List;
+
+public interface ICodeData {
+
+	List<ICodeComment> getComments();
+
+	List<ICodeRename> getRenames();
+}

jadx-core/src/main/java/jadx/api/data/ICodeRename.java

@@ -0,0 +1,13 @@
+package jadx.api.data;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface ICodeRename extends Comparable<ICodeRename> {
+
+	IJavaNodeRef getNodeRef();
+
+	@Nullable
+	IJavaCodeRef getCodeRef();
+
+	String getNewName();
+}

jadx-core/src/main/java/jadx/api/data/IJavaCodeRef.java

@@ -0,0 +1,15 @@
+package jadx.api.data;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface IJavaCodeRef extends Comparable<IJavaCodeRef> {
+
+	CodeRefType getAttachType();
+
+	int getIndex();
+
+	@Override
+	default int compareTo(@NotNull IJavaCodeRef o) {
+		return Integer.compare(getIndex(), o.getIndex());
+	}
+}

jadx-core/src/main/java/jadx/api/data/IJavaNodeRef.java

@@ -0,0 +1,14 @@
+package jadx.api.data;
+
+public interface IJavaNodeRef extends Comparable<IJavaNodeRef> {
+
+	enum RefType {
+		CLASS, FIELD, METHOD, PKG
+	}
+
+	RefType getType();
+
+	String getDeclaringClass();
+
+	String getShortId();
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeComment.java

@@ -0,0 +1,78 @@
+package jadx.api.data.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.data.ICodeComment;
+import jadx.api.data.IJavaCodeRef;
+import jadx.api.data.IJavaNodeRef;
+
+public class JadxCodeComment implements ICodeComment {
+
+	private IJavaNodeRef nodeRef;
+	@Nullable
+	private IJavaCodeRef codeRef;
+	private String comment;
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, String comment) {
+		this(nodeRef, null, comment);
+	}
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, @Nullable IJavaCodeRef codeRef, String comment) {
+		this.nodeRef = nodeRef;
+		this.codeRef = codeRef;
+		this.comment = comment;
+	}
+
+	public JadxCodeComment() {
+		// for json deserialization
+	}
+
+	@Override
+	public IJavaNodeRef getNodeRef() {
+		return nodeRef;
+	}
+
+	public void setNodeRef(IJavaNodeRef nodeRef) {
+		this.nodeRef = nodeRef;
+	}
+
+	@Nullable
+	@Override
+	public IJavaCodeRef getCodeRef() {
+		return codeRef;
+	}
+
+	public void setCodeRef(@Nullable IJavaCodeRef codeRef) {
+		this.codeRef = codeRef;
+	}
+
+	@Override
+	public String getComment() {
+		return comment;
+	}
+
+	public void setComment(String comment) {
+		this.comment = comment;
+	}
+
+	@Override
+	public int compareTo(@NotNull ICodeComment other) {
+		int cmpNodeRef = this.getNodeRef().compareTo(other.getNodeRef());
+		if (cmpNodeRef != 0) {
+			return cmpNodeRef;
+		}
+		if (this.getCodeRef() != null && other.getCodeRef() != null) {
+			return this.getCodeRef().compareTo(other.getCodeRef());
+		}
+		return this.getComment().compareTo(other.getComment());
+	}
+
+	@Override
+	public String toString() {
+		return "JadxCodeComment{" + nodeRef
+				+ ", ref=" + codeRef
+				+ ", comment='" + comment + '\''
+				+ '}';
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeData.java

@@ -0,0 +1,31 @@
+package jadx.api.data.impl;
+
+import java.util.Collections;
+import java.util.List;
+
+import jadx.api.data.ICodeComment;
+import jadx.api.data.ICodeData;
+import jadx.api.data.ICodeRename;
+
+public class JadxCodeData implements ICodeData {
+	private List<ICodeComment> comments = Collections.emptyList();
+	private List<ICodeRename> renames = Collections.emptyList();
+
+	@Override
+	public List<ICodeComment> getComments() {
+		return comments;
+	}
+
+	public void setComments(List<ICodeComment> comments) {
+		this.comments = comments;
+	}
+
+	@Override
+	public List<ICodeRename> getRenames() {
+		return renames;
+	}
+
+	public void setRenames(List<ICodeRename> renames) {
+		this.renames = renames;
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeRef.java

@@ -0,0 +1,88 @@
+package jadx.api.data.impl;
+
+import jadx.api.JavaVariable;
+import jadx.api.data.CodeRefType;
+import jadx.api.data.IJavaCodeRef;
+import jadx.api.metadata.annotations.VarNode;
+
+public class JadxCodeRef implements IJavaCodeRef {
+
+	public static JadxCodeRef forInsn(int offset) {
+		return new JadxCodeRef(CodeRefType.INSN, offset);
+	}
+
+	public static JadxCodeRef forMthArg(int argIndex) {
+		return new JadxCodeRef(CodeRefType.MTH_ARG, argIndex);
+	}
+
+	public static JadxCodeRef forVar(int regNum, int ssaVersion) {
+		return new JadxCodeRef(CodeRefType.VAR, regNum << 16 | ssaVersion);
+	}
+
+	public static JadxCodeRef forVar(JavaVariable javaVariable) {
+		return forVar(javaVariable.getReg(), javaVariable.getSsa());
+	}
+
+	public static JadxCodeRef forVar(VarNode varNode) {
+		return forVar(varNode.getReg(), varNode.getSsa());
+	}
+
+	public static JadxCodeRef forCatch(int handlerOffset) {
+		return new JadxCodeRef(CodeRefType.CATCH, handlerOffset);
+	}
+
+	private CodeRefType attachType;
+	private int index;
+
+	public JadxCodeRef(CodeRefType attachType, int index) {
+		this.attachType = attachType;
+		this.index = index;
+	}
+
+	public JadxCodeRef() {
+		// used for json serialization
+	}
+
+	public CodeRefType getAttachType() {
+		return attachType;
+	}
+
+	public void setAttachType(CodeRefType attachType) {
+		this.attachType = attachType;
+	}
+
+	@Override
+	public int getIndex() {
+		return index;
+	}
+
+	public void setIndex(int index) {
+		this.index = index;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof JadxCodeRef)) {
+			return false;
+		}
+		JadxCodeRef other = (JadxCodeRef) o;
+		return getIndex() == other.getIndex()
+				&& getAttachType() == other.getAttachType();
+	}
+
+	@Override
+	public int hashCode() {
+		return 31 * getAttachType().hashCode() + getIndex();
+	}
+
+	@Override
+	public String toString() {
+		return "JadxCodeRef{"
+				+ "attachType=" + attachType
+				+ ", index=" + index
+				+ '}';
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeRename.java

@@ -0,0 +1,88 @@
+package jadx.api.data.impl;
+
+import java.util.Objects;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.data.ICodeRename;
+import jadx.api.data.IJavaCodeRef;
+import jadx.api.data.IJavaNodeRef;
+
+public class JadxCodeRename implements ICodeRename {
+	private IJavaNodeRef nodeRef;
+	@Nullable
+	private IJavaCodeRef codeRef;
+	private String newName;
+
+	public JadxCodeRename(IJavaNodeRef nodeRef, String newName) {
+		this(nodeRef, null, newName);
+	}
+
+	public JadxCodeRename(IJavaNodeRef nodeRef, @Nullable IJavaCodeRef codeRef, String newName) {
+		this.nodeRef = nodeRef;
+		this.codeRef = codeRef;
+		this.newName = newName;
+	}
+
+	public JadxCodeRename() {
+		// used in json serialization
+	}
+
+	@Override
+	public IJavaNodeRef getNodeRef() {
+		return nodeRef;
+	}
+
+	public void setNodeRef(IJavaNodeRef nodeRef) {
+		this.nodeRef = nodeRef;
+	}
+
+	@Override
+	public IJavaCodeRef getCodeRef() {
+		return codeRef;
+	}
+
+	public void setCodeRef(IJavaCodeRef codeRef) {
+		this.codeRef = codeRef;
+	}
+
+	@Override
+	public String getNewName() {
+		return newName;
+	}
+
+	public void setNewName(String newName) {
+		this.newName = newName;
+	}
+
+	@Override
+	public int compareTo(@NotNull ICodeRename other) {
+		int cmpNodeRef = this.getNodeRef().compareTo(other.getNodeRef());
+		if (cmpNodeRef != 0) {
+			return cmpNodeRef;
+		}
+		if (this.getCodeRef() != null && other.getCodeRef() != null) {
+			return this.getCodeRef().compareTo(other.getCodeRef());
+		}
+		return this.getNewName().compareTo(other.getNewName());
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof ICodeRename)) {
+			return false;
+		}
+		ICodeRename other = (ICodeRename) o;
+		return getNodeRef().equals(other.getNodeRef())
+				&& Objects.equals(getCodeRef(), other.getCodeRef());
+	}
+
+	@Override
+	public int hashCode() {
+		return 31 * getNodeRef().hashCode() + Objects.hashCode(getCodeRef());
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxNodeRef.java

@@ -0,0 +1,144 @@
+package jadx.api.data.impl;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.JavaClass;
+import jadx.api.JavaField;
+import jadx.api.JavaMethod;
+import jadx.api.JavaNode;
+import jadx.api.data.IJavaNodeRef;
+
+public class JadxNodeRef implements IJavaNodeRef {
+
+	@Nullable
+	public static JadxNodeRef forJavaNode(JavaNode javaNode) {
+		if (javaNode instanceof JavaClass) {
+			return forCls((JavaClass) javaNode);
+		}
+		if (javaNode instanceof JavaMethod) {
+			return forMth((JavaMethod) javaNode);
+		}
+		if (javaNode instanceof JavaField) {
+			return forFld((JavaField) javaNode);
+		}
+		return null;
+	}
+
+	public static JadxNodeRef forCls(JavaClass cls) {
+		return new JadxNodeRef(RefType.CLASS, getClassRefStr(cls), null);
+	}
+
+	public static JadxNodeRef forCls(String clsFullName) {
+		return new JadxNodeRef(RefType.CLASS, clsFullName, null);
+	}
+
+	public static JadxNodeRef forMth(JavaMethod mth) {
+		return new JadxNodeRef(RefType.METHOD,
+				getClassRefStr(mth.getDeclaringClass()),
+				mth.getMethodNode().getMethodInfo().getShortId());
+	}
+
+	public static JadxNodeRef forFld(JavaField fld) {
+		return new JadxNodeRef(RefType.FIELD,
+				getClassRefStr(fld.getDeclaringClass()),
+				fld.getFieldNode().getFieldInfo().getShortId());
+	}
+
+	public static JadxNodeRef forPkg(String pkgFullName) {
+		return new JadxNodeRef(RefType.PKG, pkgFullName, "");
+	}
+
+	private static String getClassRefStr(JavaClass cls) {
+		return cls.getClassNode().getClassInfo().getRawName();
+	}
+
+	private RefType refType;
+	private String declClass;
+	@Nullable
+	private String shortId;
+
+	public JadxNodeRef(RefType refType, String declClass, @Nullable String shortId) {
+		this.refType = refType;
+		this.declClass = declClass;
+		this.shortId = shortId;
+	}
+
+	public JadxNodeRef() {
+		// for json deserialization
+	}
+
+	@Override
+	public RefType getType() {
+		return refType;
+	}
+
+	public void setRefType(RefType refType) {
+		this.refType = refType;
+	}
+
+	@Override
+	public String getDeclaringClass() {
+		return declClass;
+	}
+
+	public void setDeclClass(String declClass) {
+		this.declClass = declClass;
+	}
+
+	@Nullable
+	@Override
+	public String getShortId() {
+		return shortId;
+	}
+
+	public void setShortId(@Nullable String shortId) {
+		this.shortId = shortId;
+	}
+
+	private static final Comparator<IJavaNodeRef> COMPARATOR = Comparator
+			.comparing(IJavaNodeRef::getType)
+			.thenComparing(IJavaNodeRef::getDeclaringClass)
+			.thenComparing(IJavaNodeRef::getShortId);
+
+	@Override
+	public int compareTo(@NotNull IJavaNodeRef other) {
+		return COMPARATOR.compare(this, other);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(refType, declClass, shortId);
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof JadxNodeRef)) {
+			return false;
+		}
+		JadxNodeRef that = (JadxNodeRef) o;
+		return refType == that.refType
+				&& Objects.equals(declClass, that.declClass)
+				&& Objects.equals(shortId, that.shortId);
+	}
+
+	@Override
+	public String toString() {
+		switch (refType) {
+			case CLASS:
+			case PKG:
+				return declClass;
+			case FIELD:
+			case METHOD:
+				return declClass + "->" + shortId;
+			default:
+				return "unknown node ref type";
+		}
+	}
+}

jadx-core/src/main/java/jadx/api/impl/AnnotatedCodeInfo.java

@@ -0,0 +1,39 @@
+package jadx.api.impl;
+
+import java.util.Map;
+
+import jadx.api.ICodeInfo;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeMetadata;
+import jadx.api.metadata.impl.CodeMetadataStorage;
+
+public class AnnotatedCodeInfo implements ICodeInfo {
+
+	private final String code;
+	private final ICodeMetadata metadata;
+
+	public AnnotatedCodeInfo(String code, Map<Integer, Integer> lineMapping, Map<Integer, ICodeAnnotation> annotations) {
+		this.code = code;
+		this.metadata = CodeMetadataStorage.build(lineMapping, annotations);
+	}
+
+	@Override
+	public String getCodeStr() {
+		return code;
+	}
+
+	@Override
+	public ICodeMetadata getCodeMetadata() {
+		return metadata;
+	}
+
+	@Override
+	public boolean hasMetadata() {
+		return metadata != ICodeMetadata.EMPTY;
+	}
+
+	@Override
+	public String toString() {
+		return code;
+	}
+}

jadx-core/src/main/java/jadx/api/impl/AnnotatedCodeWriter.java

@@ -0,0 +1,194 @@
+package jadx.api.impl;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+import jadx.api.ICodeInfo;
+import jadx.api.ICodeWriter;
+import jadx.api.JadxArgs;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.NodeDeclareRef;
+import jadx.api.metadata.annotations.VarRef;
+import jadx.core.utils.StringUtils;
+
+public class AnnotatedCodeWriter extends SimpleCodeWriter implements ICodeWriter {
+
+	private int line = 1;
+	private int offset;
+	private Map<Integer, ICodeAnnotation> annotations = Collections.emptyMap();
+	private Map<Integer, Integer> lineMap = Collections.emptyMap();
+
+	public AnnotatedCodeWriter() {
+	}
+
+	public AnnotatedCodeWriter(JadxArgs args) {
+		super(args);
+	}
+
+	@Override
+	public boolean isMetadataSupported() {
+		return true;
+	}
+
+	@Override
+	public AnnotatedCodeWriter addMultiLine(String str) {
+		if (str.contains(NL)) {
+			buf.append(str.replace(NL, NL + indentStr));
+			line += StringUtils.countMatches(str, NL);
+			offset = 0;
+		} else {
+			buf.append(str);
+		}
+		return this;
+	}
+
+	@Override
+	public AnnotatedCodeWriter add(String str) {
+		buf.append(str);
+		offset += str.length();
+		return this;
+	}
+
+	@Override
+	public AnnotatedCodeWriter add(char c) {
+		buf.append(c);
+		offset++;
+		return this;
+	}
+
+	@Override
+	public ICodeWriter add(ICodeWriter cw) {
+		if (!cw.isMetadataSupported()) {
+			buf.append(cw.getCodeStr());
+			return this;
+		}
+		AnnotatedCodeWriter code = ((AnnotatedCodeWriter) cw);
+		line--;
+		int startPos = getLength();
+		for (Map.Entry<Integer, ICodeAnnotation> entry : code.annotations.entrySet()) {
+			int pos = entry.getKey();
+			int newPos = startPos + pos;
+			attachAnnotation(entry.getValue(), newPos);
+		}
+		for (Map.Entry<Integer, Integer> entry : code.lineMap.entrySet()) {
+			attachSourceLine(line + entry.getKey(), entry.getValue());
+		}
+		line += code.line;
+		offset = code.offset;
+		buf.append(code.buf);
+		return this;
+	}
+
+	@Override
+	protected void addLine() {
+		buf.append(NL);
+		line++;
+		offset = 0;
+	}
+
+	@Override
+	protected AnnotatedCodeWriter addLineIndent() {
+		buf.append(indentStr);
+		offset += indentStr.length();
+		return this;
+	}
+
+	@Override
+	public int getLine() {
+		return line;
+	}
+
+	@Override
+	public int getLineStartPos() {
+		return getLength() - offset;
+	}
+
+	@Override
+	public void attachDefinition(ICodeNodeRef obj) {
+		if (obj == null) {
+			return;
+		}
+		attachAnnotation(new NodeDeclareRef(obj));
+	}
+
+	@Override
+	public void attachAnnotation(ICodeAnnotation obj) {
+		if (obj == null) {
+			return;
+		}
+		attachAnnotation(obj, getLength());
+	}
+
+	@Override
+	public void attachLineAnnotation(ICodeAnnotation obj) {
+		if (obj == null) {
+			return;
+		}
+		attachAnnotation(obj, getLineStartPos());
+	}
+
+	private void attachAnnotation(ICodeAnnotation obj, int pos) {
+		if (annotations.isEmpty()) {
+			annotations = new HashMap<>();
+		}
+		annotations.put(pos, obj);
+	}
+
+	@Override
+	public void attachSourceLine(int sourceLine) {
+		if (sourceLine == 0) {
+			return;
+		}
+		attachSourceLine(line, sourceLine);
+	}
+
+	private void attachSourceLine(int decompiledLine, int sourceLine) {
+		if (lineMap.isEmpty()) {
+			lineMap = new TreeMap<>();
+		}
+		lineMap.put(decompiledLine, sourceLine);
+	}
+
+	@Override
+	public ICodeInfo finish() {
+		removeFirstEmptyLine();
+		processDefinitionAnnotations();
+		validateAnnotations();
+		String code = buf.toString();
+		buf = null;
+		return new AnnotatedCodeInfo(code, lineMap, annotations);
+	}
+
+	@Override
+	public Map<Integer, ICodeAnnotation> getRawAnnotations() {
+		return annotations;
+	}
+
+	private void processDefinitionAnnotations() {
+		if (!annotations.isEmpty()) {
+			annotations.forEach((k, v) -> {
+				if (v instanceof NodeDeclareRef) {
+					NodeDeclareRef declareRef = (NodeDeclareRef) v;
+					declareRef.setDefPos(k);
+					declareRef.getNode().setDefPosition(k);
+				}
+			});
+		}
+	}
+
+	private void validateAnnotations() {
+		if (annotations.isEmpty()) {
+			return;
+		}
+		annotations.values().removeIf(v -> {
+			if (v.getAnnType() == ICodeAnnotation.AnnType.VAR_REF) {
+				VarRef varRef = (VarRef) v;
+				return varRef.getRefPos() == 0;
+			}
+			return false;
+		});
+	}
+}

jadx-core/src/main/java/jadx/api/impl/DelegateCodeCache.java

@@ -0,0 +1,49 @@
+package jadx.api.impl;
+
+import java.io.IOException;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeCache;
+import jadx.api.ICodeInfo;
+
+public abstract class DelegateCodeCache implements ICodeCache {
+
+	protected final ICodeCache backCache;
+
+	public DelegateCodeCache(ICodeCache backCache) {
+		this.backCache = backCache;
+	}
+
+	@Override
+	public void add(String clsFullName, ICodeInfo codeInfo) {
+		backCache.add(clsFullName, codeInfo);
+	}
+
+	@Override
+	public void remove(String clsFullName) {
+		backCache.remove(clsFullName);
+	}
+
+	@Override
+	public @NotNull ICodeInfo get(String clsFullName) {
+		return backCache.get(clsFullName);
+	}
+
+	@Override
+	@Nullable
+	public String getCode(String clsFullName) {
+		return backCache.getCode(clsFullName);
+	}
+
+	@Override
+	public boolean contains(String clsFullName) {
+		return backCache.contains(clsFullName);
+	}
+
+	@Override
+	public void close() throws IOException {
+		backCache.close();
+	}
+}

jadx-core/src/main/java/jadx/api/impl/InMemoryCodeCache.java

@@ -0,0 +1,60 @@
+package jadx.api.impl;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeCache;
+import jadx.api.ICodeInfo;
+
+public class InMemoryCodeCache implements ICodeCache {
+
+	private final Map<String, ICodeInfo> storage = new ConcurrentHashMap<>();
+
+	@Override
+	public void add(String clsFullName, ICodeInfo codeInfo) {
+		storage.put(clsFullName, codeInfo);
+	}
+
+	@Override
+	public void remove(String clsFullName) {
+		storage.remove(clsFullName);
+	}
+
+	@NotNull
+	@Override
+	public ICodeInfo get(String clsFullName) {
+		ICodeInfo codeInfo = storage.get(clsFullName);
+		if (codeInfo == null) {
+			return ICodeInfo.EMPTY;
+		}
+		return codeInfo;
+	}
+
+	@Override
+	public @Nullable String getCode(String clsFullName) {
+		ICodeInfo codeInfo = storage.get(clsFullName);
+		if (codeInfo == null) {
+			return null;
+		}
+		return codeInfo.getCodeStr();
+	}
+
+	@Override
+	public boolean contains(String clsFullName) {
+		return storage.containsKey(clsFullName);
+	}
+
+	@Override
+	public void close() throws IOException {
+		storage.clear();
+	}
+
+	@Override
+	public String toString() {
+		return "InMemoryCodeCache: size=" + storage.size();
+	}
+}

jadx-core/src/main/java/jadx/api/impl/NoOpCodeCache.java

@@ -0,0 +1,48 @@
+package jadx.api.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeCache;
+import jadx.api.ICodeInfo;
+
+public class NoOpCodeCache implements ICodeCache {
+
+	public static final NoOpCodeCache INSTANCE = new NoOpCodeCache();
+
+	@Override
+	public void add(String clsFullName, ICodeInfo codeInfo) {
+		// do nothing
+	}
+
+	@Override
+	public void remove(String clsFullName) {
+		// do nothing
+	}
+
+	@Override
+	@NotNull
+	public ICodeInfo get(String clsFullName) {
+		return ICodeInfo.EMPTY;
+	}
+
+	@Override
+	public @Nullable String getCode(String clsFullName) {
+		return null;
+	}
+
+	@Override
+	public boolean contains(String clsFullName) {
+		return false;
+	}
+
+	@Override
+	public void close() {
+		// do nothing
+	}
+
+	@Override
+	public String toString() {
+		return "NoOpCodeCache";
+	}
+}

jadx-core/src/main/java/jadx/api/impl/SimpleCodeInfo.java

@@ -0,0 +1,33 @@
+package jadx.api.impl;
+
+import jadx.api.ICodeInfo;
+import jadx.api.metadata.ICodeMetadata;
+
+public class SimpleCodeInfo implements ICodeInfo {
+
+	private final String code;
+
+	public SimpleCodeInfo(String code) {
+		this.code = code;
+	}
+
+	@Override
+	public String getCodeStr() {
+		return code;
+	}
+
+	@Override
+	public ICodeMetadata getCodeMetadata() {
+		return ICodeMetadata.EMPTY;
+	}
+
+	@Override
+	public boolean hasMetadata() {
+		return false;
+	}
+
+	@Override
+	public String toString() {
+		return code;
+	}
+}

jadx-core/src/main/java/jadx/api/impl/SimpleCodeWriter.java

@@ -0,0 +1,260 @@
+package jadx.api.impl;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.ICodeInfo;
+import jadx.api.ICodeWriter;
+import jadx.api.JadxArgs;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.utils.Utils;
+
+/**
+ * CodeWriter implementation without meta information support (only strings builder)
+ */
+public class SimpleCodeWriter implements ICodeWriter {
+	private static final Logger LOG = LoggerFactory.getLogger(SimpleCodeWriter.class);
+
+	private static final String[] INDENT_CACHE = {
+			"",
+			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,
+	};
+
+	protected StringBuilder buf = new StringBuilder();
+	protected String indentStr = "";
+	protected int indent = 0;
+
+	private final boolean insertLineNumbers;
+
+	public SimpleCodeWriter() {
+		this.insertLineNumbers = false;
+	}
+
+	public SimpleCodeWriter(JadxArgs args) {
+		this.insertLineNumbers = args.isInsertDebugLines();
+		if (insertLineNumbers) {
+			incIndent(3);
+			add(indentStr);
+		}
+	}
+
+	@Override
+	public boolean isMetadataSupported() {
+		return false;
+	}
+
+	@Override
+	public SimpleCodeWriter startLine() {
+		addLine();
+		addLineIndent();
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter startLine(char c) {
+		startLine();
+		add(c);
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter startLine(String str) {
+		startLine();
+		add(str);
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter startLineWithNum(int sourceLine) {
+		if (sourceLine == 0) {
+			startLine();
+			return this;
+		}
+		if (this.insertLineNumbers) {
+			newLine();
+			attachSourceLine(sourceLine);
+			int start = getLength();
+			add("/* ").add(Integer.toString(sourceLine)).add(" */ ");
+			int len = getLength() - start;
+			if (indentStr.length() > len) {
+				add(indentStr.substring(len));
+			}
+		} else {
+			startLine();
+			attachSourceLine(sourceLine);
+		}
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter addMultiLine(String str) {
+		if (str.contains(NL)) {
+			buf.append(str.replace(NL, NL + indentStr));
+		} else {
+			buf.append(str);
+		}
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter add(String str) {
+		buf.append(str);
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter add(char c) {
+		buf.append(c);
+		return this;
+	}
+
+	@Override
+	public ICodeWriter add(ICodeWriter cw) {
+		buf.append(cw.getCodeStr());
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter newLine() {
+		addLine();
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter addIndent() {
+		add(INDENT_STR);
+		return this;
+	}
+
+	protected void addLine() {
+		buf.append(NL);
+	}
+
+	protected SimpleCodeWriter addLineIndent() {
+		buf.append(indentStr);
+		return this;
+	}
+
+	private void updateIndent() {
+		int curIndent = indent;
+		if (curIndent < INDENT_CACHE.length) {
+			this.indentStr = INDENT_CACHE[curIndent];
+		} else {
+			this.indentStr = Utils.strRepeat(INDENT_STR, curIndent);
+		}
+	}
+
+	@Override
+	public void incIndent() {
+		incIndent(1);
+	}
+
+	@Override
+	public void decIndent() {
+		decIndent(1);
+	}
+
+	private void incIndent(int c) {
+		this.indent += c;
+		updateIndent();
+	}
+
+	private void decIndent(int c) {
+		this.indent -= c;
+		if (this.indent < 0) {
+			LOG.warn("Indent < 0");
+			this.indent = 0;
+		}
+		updateIndent();
+	}
+
+	@Override
+	public int getIndent() {
+		return indent;
+	}
+
+	@Override
+	public void setIndent(int indent) {
+		this.indent = indent;
+		updateIndent();
+	}
+
+	@Override
+	public int getLine() {
+		return 0;
+	}
+
+	@Override
+	public int getLineStartPos() {
+		return 0;
+	}
+
+	@Override
+	public void attachDefinition(ICodeNodeRef obj) {
+		// no op
+	}
+
+	@Override
+	public void attachAnnotation(ICodeAnnotation obj) {
+		// no op
+	}
+
+	@Override
+	public void attachLineAnnotation(ICodeAnnotation obj) {
+		// no op
+	}
+
+	@Override
+	public void attachSourceLine(int sourceLine) {
+		// no op
+	}
+
+	@Override
+	public ICodeInfo finish() {
+		removeFirstEmptyLine();
+		String code = buf.toString();
+		buf = null;
+		return new SimpleCodeInfo(code);
+	}
+
+	protected void removeFirstEmptyLine() {
+		int len = NL.length();
+		if (buf.length() > len && buf.substring(0, len).equals(NL)) {
+			buf.delete(0, len);
+		}
+	}
+
+	@Override
+	public int getLength() {
+		return buf.length();
+	}
+
+	@Override
+	public StringBuilder getRawBuf() {
+		return buf;
+	}
+
+	@Override
+	public Map<Integer, ICodeAnnotation> getRawAnnotations() {
+		return Collections.emptyMap();
+	}
+
+	@Override
+	public String getCodeStr() {
+		removeFirstEmptyLine();
+		return buf.toString();
+	}
+
+	@Override
+	public String toString() {
+		return getCodeStr();
+	}
+}

jadx-core/src/main/java/jadx/api/metadata/ICodeAnnotation.java

@@ -0,0 +1,17 @@
+package jadx.api.metadata;
+
+public interface ICodeAnnotation {
+
+	enum AnnType {
+		CLASS,
+		FIELD,
+		METHOD,
+		VAR,
+		VAR_REF,
+		DECLARATION,
+		OFFSET,
+		END // class or method body end
+	}
+
+	AnnType getAnnType();
+}

jadx-core/src/main/java/jadx/api/metadata/ICodeMetadata.java

@@ -0,0 +1,59 @@
+package jadx.api.metadata;
+
+import java.util.Map;
+import java.util.function.BiFunction;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.metadata.impl.CodeMetadataStorage;
+
+public interface ICodeMetadata {
+
+	ICodeMetadata EMPTY = CodeMetadataStorage.empty();
+
+	@Nullable
+	ICodeAnnotation getAt(int position);
+
+	@Nullable
+	ICodeAnnotation getClosestUp(int position);
+
+	@Nullable
+	ICodeAnnotation searchUp(int position, ICodeAnnotation.AnnType annType);
+
+	@Nullable
+	ICodeAnnotation searchUp(int position, int limitPos, ICodeAnnotation.AnnType annType);
+
+	/**
+	 * Iterate code annotations from {@code startPos} to smaller positions.
+	 *
+	 * @param visitor
+	 *                return not null value to stop iterations
+	 */
+	@Nullable
+	<T> T searchUp(int startPos, BiFunction<Integer, ICodeAnnotation, T> visitor);
+
+	/**
+	 * Iterate code annotations from {@code startPos} to higher positions.
+	 *
+	 * @param visitor
+	 *                return not null value to stop iterations
+	 */
+	@Nullable
+	<T> T searchDown(int startPos, BiFunction<Integer, ICodeAnnotation, T> visitor);
+
+	/**
+	 * Get current node at position (can be enclosing class or method)
+	 */
+	@Nullable
+	ICodeNodeRef getNodeAt(int position);
+
+	/**
+	 * Any definition of class or method below position
+	 */
+	@Nullable
+	ICodeNodeRef getNodeBelow(int position);
+
+	Map<Integer, ICodeAnnotation> getAsMap();
+
+	Map<Integer, Integer> getLineMapping();
+}

jadx-core/src/main/java/jadx/api/metadata/ICodeNodeRef.java

@@ -0,0 +1,7 @@
+package jadx.api.metadata;
+
+public interface ICodeNodeRef extends ICodeAnnotation {
+	int getDefPosition();
+
+	void setDefPosition(int pos);
+}

jadx-core/src/main/java/jadx/api/metadata/annotations/InsnCodeOffset.java

@@ -0,0 +1,57 @@
+package jadx.api.metadata.annotations;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeWriter;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.core.dex.nodes.InsnNode;
+
+public class InsnCodeOffset implements ICodeAnnotation {
+
+	public static void attach(ICodeWriter code, InsnNode insn) {
+		if (insn == null) {
+			return;
+		}
+		if (code.isMetadataSupported()) {
+			InsnCodeOffset ann = from(insn);
+			if (ann != null) {
+				code.attachLineAnnotation(ann);
+			}
+		}
+	}
+
+	public static void attach(ICodeWriter code, int offset) {
+		if (offset >= 0 && code.isMetadataSupported()) {
+			code.attachLineAnnotation(new InsnCodeOffset(offset));
+		}
+	}
+
+	@Nullable
+	public static InsnCodeOffset from(InsnNode insn) {
+		int offset = insn.getOffset();
+		if (offset < 0) {
+			return null;
+		}
+		return new InsnCodeOffset(offset);
+	}
+
+	private final int offset;
+
+	public InsnCodeOffset(int offset) {
+		this.offset = offset;
+	}
+
+	public int getOffset() {
+		return offset;
+	}
+
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.OFFSET;
+	}
+
+	@Override
+	public String toString() {
+		return "offset=" + offset;
+	}
+}

jadx-core/src/main/java/jadx/api/metadata/annotations/NodeDeclareRef.java

@@ -0,0 +1,55 @@
+package jadx.api.metadata.annotations;
+
+import java.util.Objects;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+
+public class NodeDeclareRef implements ICodeAnnotation {
+
+	private final ICodeNodeRef node;
+
+	private int defPos;
+
+	public NodeDeclareRef(ICodeNodeRef node) {
+		this.node = Objects.requireNonNull(node);
+	}
+
+	public ICodeNodeRef getNode() {
+		return node;
+	}
+
+	public int getDefPos() {
+		return defPos;
+	}
+
+	public void setDefPos(int defPos) {
+		this.defPos = defPos;
+	}
+
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.DECLARATION;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof NodeDeclareRef)) {
+			return false;
+		}
+		return node.equals(((NodeDeclareRef) o).node);
+	}
+
+	@Override
+	public int hashCode() {
+		return node.hashCode();
+	}
+
+	@Override
+	public String toString() {
+		return "NodeDeclareRef{" + node + '}';
+	}
+}

jadx-core/src/main/java/jadx/api/metadata/annotations/NodeEnd.java

@@ -0,0 +1,21 @@
+package jadx.api.metadata.annotations;
+
+import jadx.api.metadata.ICodeAnnotation;
+
+public class NodeEnd implements ICodeAnnotation {
+
+	public static final NodeEnd VALUE = new NodeEnd();
+
+	private NodeEnd() {
+	}
+
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.END;
+	}
+
+	@Override
+	public String toString() {
+		return "END";
+	}
+}