fix test

* wip: finished with factories

* wip: bundleconfig.pb

* wip: jadx-aab-input, separate BundleConfig parser

* wip: removed test apks

* wip: proto xml pretty print

* wip: fixed getNamedValues NPE

* minor fixes

* spotless

* enabled zip64 for gui shadow jar

* spotless

* spotless

* reverted manifest identification since signature parsing not working at the moment

* replace static methods with new API methods

---------

Co-authored-by: Skylot <118523+skylot@users.noreply.github.com>

.codecov.yml

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

.editorconfig

@@ -7,11 +7,23 @@ 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
 
+[*.java]
+ij_java_continuation_indent_size = 8
+ij_java_use_single_class_imports = true
+ij_java_class_count_to_use_import_on_demand = 99
+ij_java_names_count_to_use_import_on_demand = 99
+ij_java_packages_to_use_import_on_demand = *
+
+[*.kt]
+ij_kotlin_continuation_indent_size = 8
+ij_kotlin_name_count_to_use_star_import = 99
+ij_kotlin_name_count_to_use_star_import_for_members = 99
+ij_kotlin_packages_to_use_import_on_demand = *
+
 [*.yml]
 indent_style = space
 indent_size = 2

.gitattributes

@@ -0,0 +1,12 @@
+*       text=auto eol=lf
+
+*.java  text eol=lf diff=java
+*.kt    text eol=lf diff=kotlin
+*.kts   text eol=lf diff=kotlin
+
+gradlew text eol=lf
+
+*.bat   text eol=crlf
+
+*.png   binary
+*.jar   binary

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/decompilation-error.md

@@ -1,20 +0,0 @@
----
-name: Decompilation error
-about: Create a report to help us improve jadx decompiler
-title: "[core]"
-labels: Core, bug
-assignees: ''
-
----
-
-**Checks before report**
-- check [latest unstable build](https://bintray.com/skylot/jadx/unstable/_latestVersion#files) (maybe issue already fixed)
-- 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/decompilation-issue.yml

@@ -0,0 +1,40 @@
+name: Decompilation issue
+description: Create a report to help us improve jadx decompiler
+title: '[core] '
+labels:
+  - Core
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Checks before submit**
+        - check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+        - try [latest unstable build](https://nightly.link/skylot/jadx/workflows/build-artifacts/master), maybe issue already fixed
+        - search existing issues by exception message
+  - type: textarea
+    id: details
+    attributes:
+      label: Issue details
+      placeholder: >-
+        Describe issue
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output or stacktrace
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: java
+  - type: textarea
+    id: sample
+    attributes:
+      label: Provide sample and class/method full name
+      description: |
+        - sample: attach or provide a link
+        - full name of class or method with issue
+        - other details which may help to reproduce issue
+  - type: input
+    id: jadx-version
+    attributes:
+      label: Jadx version

.github/ISSUE_TEMPLATE/feature-request.md

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

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,13 @@
+name: Feature Request
+description: Suggest an idea for jadx
+title: '[feature] '
+labels:
+  - 'new feature'
+body:
+  - type: textarea
+    id: details
+    attributes:
+      label: Describe your idea
+      placeholder: Feature details
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/jadx-gui-issue.yml

@@ -0,0 +1,43 @@
+name: jadx-gui issue
+description: Create a bug report about issue found in jadx-gui
+title: '[gui] '
+labels:
+  - GUI
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Checks before submit**
+        - check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+        - try [latest unstable build](https://nightly.link/skylot/jadx/workflows/build-artifacts/master), maybe issue already fixed
+        - search existing issues by exception message
+  - type: textarea
+    id: details
+    attributes:
+      label: Issue details
+      placeholder: Describe issue and how to reproduce it
+    validations:
+      required: true
+  - type: input
+    id: jadx-version
+    attributes:
+      label: Jadx version
+      placeholder: check `Help->About`
+    validations:
+      required: true
+  - type: input
+    id: java-version
+    attributes:
+      label: Java version
+      placeholder: check `Help->About`
+    validations:
+      required: true
+  - type: checkboxes
+    id: os
+    attributes:
+      label: OS
+      options:
+        - label: Windows
+        - label: Linux
+        - label: macOS

.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/workflows/build-artifacts.yml

@@ -0,0 +1,84 @@
+name: Build Artifacts
+
+on:
+  push:
+    branches: [ master, build-test ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 11
+
+      - name: Set jadx version
+        run: |
+          JADX_REV=$(git rev-list --count HEAD)
+          JADX_VERSION="r${JADX_REV}.${GITHUB_SHA:0:7}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - name: Build with Gradle
+        uses: gradle/actions/setup-gradle@v3
+        with:
+          arguments: dist copyExe
+
+      - name: Save bundle artifact
+        uses: actions/upload-artifact@v4
+        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: 14
+
+      - name: Save exe artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ format('jadx-gui-{0}-no-jre-win.exe', env.JADX_VERSION) }}
+          path: build/*.exe
+          if-no-files-found: error
+          retention-days: 14
+
+  build-win-bundle:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: oracle-actions/setup-java@v1
+        with:
+          release: 21
+
+      - name: Print Java version
+        shell: bash
+        run: java -version
+
+      - name: Set jadx version
+        shell: bash
+        run: |
+          JADX_REV=$(git rev-list --count HEAD)
+          JADX_VERSION="r${JADX_REV}.${GITHUB_SHA:0:7}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - name: Build with Gradle
+        uses: gradle/actions/setup-gradle@v3
+        with:
+          arguments: dist -PbundleJRE=true
+
+      - name: Save exe bundle artifact
+        uses: actions/upload-artifact@v4
+        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: 14

.github/workflows/build-test.yml

@@ -0,0 +1,28 @@
+name: Build Test
+
+on:
+  push:
+    branches: [ master, build-test ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  tests:
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, windows-latest ]
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 11
+
+      - name: Build with Gradle
+        uses: gradle/actions/setup-gradle@v3
+        with:
+          arguments: build dist copyExe

.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@v4
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      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@v3

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

@@ -1,10 +1,15 @@
-name: "Validate Gradle Wrapper"
-on: [push]
+name: Validate Gradle Wrapper
+
+on:
+  push:
+    branches: [ master, build-test ]
+  pull_request:
+    branches: [ master ]
 
 jobs:
   validation:
-    name: "Validation"
+    name: Validation
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: gradle/wrapper-validation-action@v1
+      - uses: actions/checkout@v4
+      - uses: gradle/actions/wrapper-validation@v3

.gitignore

@@ -22,6 +22,7 @@ classes/
 idea/
 .gradle/
 node_modules/
+.vscode/
 
 jadx-output/
 *-tmp/
@@ -33,3 +34,7 @@ jadx-output/
 *.log
 *.cfg
 *.orig
+quark.json
+
+cliff.toml
+jadx-gui/src/main/resources/logback.xml

.gitlab-ci.yml

@@ -8,17 +8,17 @@ before_script:
 stages:
   - test
 
-java-8:
-  stage: test
-  image: openjdk:8
-  script: ./gradlew clean build dist
-
 java-11:
   stage: test
-  image: openjdk:11
-  script: ./gradlew clean build dist
+  image: eclipse-temurin:11
+  script: ./gradlew clean build dist copyExe
 
-java-latest:
+java-17:
   stage: test
-  image: openjdk:latest
-  script: java -version && ./gradlew clean build dist
+  image: eclipse-temurin:17
+  script: ./gradlew clean build dist copyExe
+
+java-21:
+  stage: test
+  image: eclipse-temurin:21
+  script: ./gradlew clean build dist copyExe

.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

.releaserc.yml

@@ -1,37 +0,0 @@
-branches:
-  - release
-
-verifyConditions:
-  - '@semantic-release/github'
-
-prepare:
-  - path: '@semantic-release/exec'
-    cmd: "JADX_VERSION=${nextRelease.version} ./gradlew clean dist"
-
-preset: "angular"
-
-generateNotes:
-  - path: '@semantic-release/release-notes-generator'
-    writerOpts:
-      groupBy: "type"
-      commitGroupsSort:
-        - "feat"
-        - "perf"
-        - "fix"
-      commitsSort: "header"
-
-publish:
-  - path: '@semantic-release/exec'
-    cmd: "JADX_VERSION=${nextRelease.version} BINTRAY_PACKAGE=releases bash scripts/bintray-upload.sh"
-  - path: '@semantic-release/github'
-    assets:
-      - path: 'build/*.zip'
-      - path: 'build/*.exe'
-
-success:
-  - path: '@semantic-release/github'
-    successComment: false
-
-fail:
-  - path: '@semantic-release/github'
-    failComment: false

.run/jadx-gui.run.xml

@@ -0,0 +1,12 @@
+<component name="ProjectRunConfigurationManager">
+	<configuration default="false" name="jadx-gui" type="Application" factoryName="Application">
+		<option name="MAIN_CLASS_NAME" value="jadx.gui.JadxGUI"/>
+		<module name="jadx.jadx-gui.main"/>
+		<option name="PROGRAM_PARAMETERS" value="-v"/>
+		<option name="VM_PARAMETERS"
+				value="-Xms128M -XX:MaxRAMPercentage=70.0 -Dawt.useSystemAAFontSettings=lcd -Dswing.aatext=true -Djava.util.Arrays.useLegacyMergeSort=true -Djdk.util.zip.disableZip64ExtraFieldValidation=true -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED"/>
+		<method v="2">
+			<option name="Make" enabled="true"/>
+		</method>
+	</configuration>
+</component>

.travis.yml

@@ -1,46 +0,0 @@
-language: java
-os: linux
-dist: trusty
-
-# don't build on tag push
-if: tag IS blank
-
-git:
-  depth: false
-
-before_install:
-  - chmod +x gradlew
-
-# override install to skip 'gradle assemble'
-install: true
-
-env:
-  global:
-    - TERM=dumb
-    - JADX_LAST_TAG=$(git describe --abbrev=0 --tags)
-    - JADX_VERSION="${JADX_LAST_TAG:1}-b$TRAVIS_BUILD_NUMBER-$(git rev-parse --short HEAD)"
-
-jdk:
-  - openjdk8
-  - openjdk11
-
-script: ./gradlew clean build
-
-jobs:
-  include:
-    - stage: checks
-      jdk: openjdk11
-      if: branch = master AND repo = env(MAIN_REPO) AND type = push
-      script: bash scripts/travis-checks.sh
-
-    - stage: deploy-unstable
-      jdk: openjdk8
-      if: branch = master AND repo = env(MAIN_REPO) AND type = push
-      script: bash scripts/travis-master.sh
-
-    - stage: deploy-release
-      language: node_js
-      jdk: openjdk8
-      node_js: 11
-      if: branch = release AND repo = env(MAIN_REPO) AND type = push
-      script: bash scripts/travis-release.sh

.typos.toml

@@ -0,0 +1,20 @@
+# Config for 'typos' spellchecker (https://github.com/crate-ci/typos)
+
+[default.extend-words]
+IPUT = "IPUT"
+Laf = "Laf"
+Darcula="Darcula"
+
+[default]
+extend-ignore-identifiers-re = [
+    "finaly", # intentional package name
+]
+
+[files]
+extend-exclude = [
+    "config/",
+    "jadx-core/src/main/resources/",
+    "jadx-core/src/test/",
+    "jadx-gui/src/main/resources/i18n/",
+    "!jadx-gui/src/main/resources/i18n/Messages_en_US.properties",
+]

CONTRIBUTING.md

@@ -1,33 +1,27 @@
 # Contributing
 
-Please note we have a [code of conduct](CODE_OF_CONDUCT.md), please follow it in all your interactions with the project.
+Please note, we have [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 [latest unstable build](https://bintray.com/skylot/jadx/unstable/_latestVersion#files) (maybe issue already fixed)
+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**
+2. 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 :)
+	  **Note**: GitHub don't allow attaching 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. Please don't submit any code style fixes or dependencies updates changes.
 
-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. Use only features and API from Java 11 or below.
 
 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`
+1. Make sure your changes are passing build: `./gradlew clean build dist`

README.md

@@ -2,19 +2,25 @@
 
 ## JADX
 
-[![Build Status](https://travis-ci.com/skylot/jadx.svg?branch=master)](https://travis-ci.com/skylot/jadx)
-[![Code Coverage](https://codecov.io/gh/skylot/jadx/branch/master/graph/badge.svg)](https://codecov.io/gh/skylot/jadx)
-[![Alerts from lgtm.com](https://img.shields.io/lgtm/alerts/g/skylot/jadx.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/skylot/jadx/alerts/)
-[![SonarQube Bugs](https://sonarcloud.io/api/project_badges/measure?project=jadx&metric=bugs)](https://sonarcloud.io/dashboard?id=jadx)
+![Build status](https://img.shields.io/github/actions/workflow/status/skylot/jadx/build-artifacts.yml)
+![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)
+![Java 11+](https://img.shields.io/badge/Java-11%2B-blue)
 [![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
-[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
 **jadx** - Dex to Java decompiler
 
 Command line and GUI tools for producing Java source code from Android Dex and Apk files
 
+> [!WARNING]
+> Please note that in most cases **jadx** can't decompile all 100% of the code, so errors will occur.<br />
+> Check [Troubleshooting guide](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A#decompilation-issues) for workarounds.
+
 **Main features:**
-- decompile Dalvik bytecode to java classes from APK, dex, aar and zip files
+- decompile Dalvik bytecode to Java code from APK, dex, aar, aab and zip files
 - decode `AndroidManifest.xml` and other resources from `resources.arsc`
 - deobfuscator included
 
@@ -23,38 +29,50 @@ Command line and GUI tools for producing Java source code from Android Dex and A
 - 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
+
+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)
 
-
-![jadx-gui screenshot](https://i.imgur.com/h917IBZ.png)
-
+<img src="https://user-images.githubusercontent.com/118523/142730720-839f017e-38db-423e-b53f-39f5f0a0316f.png" width="700"/>
 
 ### Download
-- latest [unstable build: ![Download](https://api.bintray.com/packages/skylot/jadx/unstable/images/download.svg) ](https://bintray.com/skylot/jadx/unstable/_latestVersion#files)
-- release from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
-- release from [bintray: ![Download](https://api.bintray.com/packages/skylot/jadx/releases/images/download.svg) ](https://bintray.com/skylot/jadx/releases/_latestVersion#files)
+- release
+  from [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 8 or later 64-bit version.
-For windows you can download it from [adoptopenjdk.net](https://adoptopenjdk.net/releases.html?variant=openjdk11&jvmVariant=hotspot#x64_win) (select "Install JRE").
+**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
-    ```bash
-        sudo pacman -S jadx
-    ```
-2. macOS
-    ```bash
-        brew install jadx
-    ```
+- Arch Linux
+  [![Arch Linux package](https://img.shields.io/archlinux/v/extra/any/jadx)](https://archlinux.org/packages/extra/any/jadx/)
+  [![AUR Version](https://img.shields.io/aur/version/jadx-git)](https://aur.archlinux.org/packages/jadx-git)
+  ```bash
+  sudo pacman -S jadx
+  ```
+- macOS
+  [![homebrew version](https://img.shields.io/homebrew/v/jadx)](https://formulae.brew.sh/formula/jadx)
+  ```bash
+  brew install jadx
+  ```
+- Flathub
+  [![Flathub Version](https://img.shields.io/flathub/v/com.github.skylot.jadx)](https://flathub.org/apps/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:
+JDK 11 or higher must be installed:
 ```
 git clone https://github.com/skylot/jadx.git
 cd jadx
@@ -68,46 +86,117 @@ and also packed to `build/jadx-<version>.zip`
 
 ### Usage
 ```
-jadx[-gui] [options] <input file> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc)
+jadx[-gui] [command] [options] <input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab, .xapk, .jadx.kts)
+commands (use '<command> --help' for command options):
+  plugins	  - manage jadx plugins
+
 options:
   -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
+  --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-xml-pretty-print               - do not prettify XML
   --no-imports                        - disable use of imports, always write entire package name
-  --no-debug-info                     - disable debug info
+  --no-debug-info                     - disable debug info parsing and processing
+  --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-move-inner-classes             - disable move inner classes into parent
+  --no-inline-kotlin-lambda           - disable inline for Kotlin lambdas
+  --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
+  --mappings-path                     - deobfuscation mappings file or directory. Allowed formats: Tiny and Tiny v2 (both '.tiny'), Enigma (.mapping) or Enigma directory
+  --mappings-mode                     - set mode for handling the deobfuscation mapping file:
+                                         'read' - just read, user can always save manually (default)
+                                         'read-and-autosave-every-change' - read and autosave after every change
+                                         'read-and-autosave-before-closing' - read and autosave before exiting the app or closing the project
+                                         'ignore' - don't read or save (can be used to skip loading mapping files referenced in the project file)
   --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-rewrite-cfg                 - force to save deobfuscation map
+  --deobf-whitelist                   - space separated list of classes (full name) and packages (ends with '.*') to exclude from deobfuscation, default: android.support.* android.os.* androidx.core.os.* androidx.annotation.*
+  --deobf-cfg-file                    - deobfuscation mappings file used for JADX auto-generated names (in the JOBF file format), default: same dir and name as input file with '.jobf' extension
+  --deobf-cfg-file-mode               - set mode for handling the JADX auto-generated names' 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
-  --rename-flags                      - what to rename, comma-separated, 'case' for system case sensitivity, 'valid' for java identifiers, 'printable' characters, 'none' or 'all' (default)
+  --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)
+  --integer-format                    - how integers are displayed:
+                                         'auto' - automatically select (default)
+                                         'decimal' - use decimal
+                                         'hexadecimal' - use hexadecimal
   --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                      - make simple dump (using goto instead of 'if', 'for', etc)
+  -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)
-  --log-level                         - set log level, values: QUIET, PROGRESS, ERROR, WARN, INFO, DEBUG, default: PROGRESS
   --version                           - print jadx version
   -h, --help                          - print this help
-Example:
- jadx -d out classes.dex
- jadx --rename-flags "none" classes.dex
- jadx --rename-flags "valid,printable" classes.dex
- jadx --log-level error app.apk
+
+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
+ 3) kotlin-metadata: Use kotlin.Metadata annotation for code generation
+    - kotlin-metadata.class-alias     - rename class alias, values: [yes, no], default: yes
+    - kotlin-metadata.method-args     - rename function arguments, values: [yes, no], default: yes
+    - kotlin-metadata.fields          - rename fields, values: [yes, no], default: yes
+    - kotlin-metadata.companion       - rename companion object, values: [yes, no], default: yes
+    - kotlin-metadata.data-class      - add data class modifier, values: [yes, no], default: yes
+    - kotlin-metadata.to-string       - rename fields using toString, values: [yes, no], default: yes
+    - kotlin-metadata.getters         - rename simple getters to field names, values: [yes, no], default: yes
+ 4) rename-mappings: various mappings support
+    - rename-mappings.format          - mapping format, values: [AUTO, TINY_FILE, TINY_2_FILE, ENIGMA_FILE, ENIGMA_DIR, SRG_FILE, XSRG_FILE, CSRG_FILE, TSRG_FILE, TSRG_2_FILE, PROGUARD_FILE], default: AUTO
+    - rename-mappings.invert          - invert mapping on load, values: [yes, no], default: no
+
+Environment variables:
+  JADX_DISABLE_XML_SECURITY - set to 'true' to disable all security checks for XML files
+  JADX_DISABLE_ZIP_SECURITY - set to 'true' to disable all security checks for zip files
+  JADX_ZIP_MAX_ENTRIES_COUNT - maximum allowed number of entries in zip files (default: 100 000)
+  JADX_CONFIG_DIR - custom config directory, using system by default
+  JADX_CACHE_DIR - custom cache directory, using system by default
+  JADX_TMP_DIR - custom temp directory, using system by default
+
+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
+These options also work in jadx-gui running from command line and override options from preferences' dialog
 
 ### Troubleshooting
 Please check wiki page [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A)
@@ -118,8 +207,5 @@ To support this project you can:
   - 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)
 
-### Related projects:
-- [PyJadx](https://github.com/romainthomas/pyjadx) - python binding for jadx by [@romainthomas](https://github.com/romainthomas)
-
 ---------------------------------------
 *Licensed under the Apache 2.0 License*

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,170 +0,0 @@
-plugins {
-	id 'org.sonarqube' version '3.0'
-	id 'com.github.ben-manes.versions' version '0.33.0'
-	id "com.diffplug.spotless" version "5.5.1"
-}
-
-ext.jadxVersion = System.getenv('JADX_VERSION') ?: "dev"
-version = jadxVersion
-println("jadx version: ${jadxVersion}")
-
-allprojects {
-	apply plugin: 'java'
-	apply plugin: 'jacoco'
-	apply plugin: 'checkstyle'
-
-	version = jadxVersion
-
-	sourceCompatibility = JavaVersion.VERSION_1_8
-	targetCompatibility = JavaVersion.VERSION_1_8
-
-	tasks.withType(JavaCompile) {
-		if (!"$it".contains(':jadx-samples:')) {
-			options.compilerArgs << '-Xlint' << '-Xlint:unchecked' << '-Xlint:deprecation'
-		}
-	}
-
-	compileJava {
-		options.encoding = "UTF-8"
-	}
-
-	jar {
-		manifest {
-			mainAttributes('jadx-version': jadxVersion)
-		}
-	}
-
-	dependencies {
-		implementation 'org.slf4j:slf4j-api:1.7.30'
-		compileOnly 'org.jetbrains:annotations:20.1.0'
-
-		testImplementation 'ch.qos.logback:logback-classic:1.2.3'
-		testImplementation 'org.hamcrest:hamcrest-library:2.2'
-		testImplementation 'org.mockito:mockito-core:3.5.10'
-		testImplementation 'org.assertj:assertj-core:3.17.2'
-
-		testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
-		testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
-
-		testImplementation 'org.eclipse.jdt.core.compiler:ecj:4.6.1'
-		testCompileOnly 'org.jetbrains:annotations:20.1.0'
-	}
-
-	test {
-		useJUnitPlatform()
-	}
-
-	repositories {
-		mavenLocal()
-		mavenCentral()
-		jcenter()
-		google()
-	}
-
-	jacoco {
-		toolVersion = "0.8.6"
-	}
-	jacocoTestReport {
-		reports {
-			xml.enabled = true
-			html.enabled = true
-		}
-	}
-
-	checkstyleMain {
-		// exclude all sources in samples module
-		exclude '**/samples/**'
-	}
-}
-
-sonarqube {
-	properties {
-		property 'sonar.exclusions', '**/jadx/samples/**/*,**/test-app/**/*'
-		property 'sonar.coverage.exclusions', '**/jadx/gui/**/*'
-	}
-}
-
-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()
-	}
-}
-
-dependencyUpdates {
-	resolutionStrategy {
-		componentSelection { rules ->
-			rules.all { ComponentSelection selection ->
-				boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm', 'atlassian'].any { qualifier ->
-					selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
-				}
-				if (rejected) {
-					selection.reject('Release candidate')
-				}
-			}
-		}
-	}
-}
-
-task copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installDist', 'jadx-gui:installDist']) {
-	destinationDir file("$buildDir/jadx")
-	['jadx-cli', 'jadx-gui'].each {
-		from tasks.getByPath(":${it}:installDist").destinationDir
-	}
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-}
-
-task pack(type: Zip, dependsOn: copyArtifacts) {
-	destinationDirectory = buildDir
-	archiveFileName = "jadx-${jadxVersion}.zip"
-	from copyArtifacts.destinationDir
-}
-
-task copyExe(type: Copy, dependsOn: 'jadx-gui:createExe') {
-	group 'jadx'
-	description = 'Copy exe to build dir'
-	destinationDir buildDir
-	from tasks.getByPath('jadx-gui:createExe').outputs
-	include '*.exe'
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-}
-
-task dist(dependsOn: [pack, copyExe]) {
-	group 'jadx'
-	description = 'Build jadx distribution zip'
-}
-
-task samples(dependsOn: 'jadx-samples:samples') {
-	group 'jadx'
-}
-
-task cleanBuildDir(type: Delete) {
-	group 'jadx'
-	delete buildDir
-}
-
-test.dependsOn(samples)
-
-clean.dependsOn(cleanBuildDir)

build.gradle.kts

@@ -0,0 +1,158 @@
+import com.diffplug.gradle.spotless.FormatExtension
+import com.diffplug.gradle.spotless.SpotlessExtension
+import com.diffplug.spotless.LineEnding
+import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask
+import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
+import java.util.Locale
+
+plugins {
+	id("com.github.ben-manes.versions") version "0.51.0"
+	id("se.patrikerdes.use-latest-versions") version "0.2.18"
+	id("com.diffplug.spotless") version "6.25.0"
+}
+
+val jadxVersion by extra { System.getenv("JADX_VERSION") ?: "dev" }
+println("jadx version: $jadxVersion")
+version = jadxVersion
+
+allprojects {
+	apply(plugin = "java")
+	apply(plugin = "checkstyle")
+	apply(plugin = "com.diffplug.spotless")
+	apply(plugin = "com.github.ben-manes.versions")
+	apply(plugin = "se.patrikerdes.use-latest-versions")
+
+	repositories {
+		mavenCentral()
+	}
+
+	configure<SpotlessExtension> {
+		java {
+			importOrderFile("$rootDir/config/code-formatter/eclipse.importorder")
+			eclipse().configFile("$rootDir/config/code-formatter/eclipse.xml")
+			removeUnusedImports()
+			commonFormatOptions()
+		}
+		kotlin {
+			ktlint().editorConfigOverride(mapOf("indent_style" to "tab"))
+			commonFormatOptions()
+		}
+		kotlinGradle {
+			ktlint()
+			commonFormatOptions()
+		}
+		format("misc") {
+			target("**/*.gradle", "**/*.xml", "**/.gitignore", "**/.properties")
+			targetExclude(".gradle/**", ".idea/**", "*/build/**")
+			commonFormatOptions()
+		}
+	}
+
+	tasks.named<DependencyUpdatesTask>("dependencyUpdates") {
+		rejectVersionIf {
+			// disallow release candidates as upgradable versions from stable versions
+			isNonStable(candidate.version) && !isNonStable(currentVersion)
+		}
+	}
+}
+
+fun FormatExtension.commonFormatOptions() {
+	lineEndings = LineEnding.UNIX
+	encoding = Charsets.UTF_8
+	trimTrailingWhitespace()
+	endWithNewline()
+}
+
+fun isNonStable(version: String): Boolean {
+	val stableKeyword = listOf("RELEASE", "FINAL", "GA").any { version.uppercase(Locale.getDefault()).contains(it) }
+	val regex = "^[0-9,.v-]+(-r)?$".toRegex()
+	val isStable = stableKeyword || regex.matches(version)
+	return isStable.not()
+}
+
+val copyArtifacts by tasks.registering(Copy::class) {
+	val jarCliPattern = "jadx-cli-(.*)-all.jar".toPattern()
+	from(tasks.getByPath(":jadx-cli:installShadowDist")) {
+		exclude("**/*.jar")
+		filter { line ->
+			jarCliPattern.matcher(line).replaceAll("jadx-$1-all.jar")
+				.replace("-jar \"\\\"\$CLASSPATH\\\"\"", "-cp \"\\\"\$CLASSPATH\\\"\" jadx.cli.JadxCLI")
+				.replace("-jar \"%CLASSPATH%\"", "-cp \"%CLASSPATH%\" jadx.cli.JadxCLI")
+		}
+	}
+	val jarGuiPattern = "jadx-gui-(.*)-all.jar".toPattern()
+	from(tasks.getByPath(":jadx-gui:installShadowDist")) {
+		exclude("**/*.jar")
+		filter { line -> jarGuiPattern.matcher(line).replaceAll("jadx-$1-all.jar") }
+	}
+	from(tasks.getByPath(":jadx-gui:installShadowDist")) {
+		include("**/*.jar")
+		rename("jadx-gui-(.*)-all.jar", "jadx-$1-all.jar")
+	}
+	from(layout.projectDirectory) {
+		include("README.md")
+		include("LICENSE")
+	}
+	into(layout.buildDirectory.dir("jadx"))
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+val pack by tasks.registering(Zip::class) {
+	from(copyArtifacts)
+	archiveFileName.set("jadx-$jadxVersion.zip")
+	destinationDirectory.set(layout.buildDirectory)
+}
+
+val copyExe by tasks.registering(Copy::class) {
+	group = "jadx"
+	description = "Copy exe to build dir"
+
+	// next task dependencies not needed, but gradle throws warning because of same output dir
+	mustRunAfter("jar")
+	mustRunAfter(pack)
+
+	from(tasks.getByPath("jadx-gui:createExe"))
+	include("*.exe")
+	into(layout.buildDirectory)
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+val distWinBundle by tasks.registering(Copy::class) {
+	group = "jadx"
+	description = "Copy bundle to build dir"
+
+	dependsOn(tasks.getByPath(":jadx-gui:distWinWithJre"))
+
+	// next task dependencies not needed, but gradle throws warning because of same output dir
+	mustRunAfter("jar")
+	mustRunAfter(pack)
+
+	from(tasks.getByPath("jadx-gui:distWinWithJre").outputs) {
+		include("*.zip")
+	}
+	into(layout.buildDirectory)
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+val dist by tasks.registering {
+	group = "jadx"
+	description = "Build jadx distribution zip"
+
+	dependsOn(pack)
+
+	val os = DefaultNativePlatform.getCurrentOperatingSystem()
+	if (os.isWindows) {
+		if (project.hasProperty("bundleJRE")) {
+			println("Build win bundle with JRE")
+			dependsOn(distWinBundle)
+		} else {
+			dependsOn(copyExe)
+		}
+	}
+}
+
+val cleanBuildDir by tasks.registering(Delete::class) {
+	group = "jadx"
+	delete(layout.buildDirectory)
+}
+tasks.getByName("clean").dependsOn(cleanBuildDir)

buildSrc/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+	`kotlin-dsl`
+}
+
+dependencies {
+	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.23")
+}
+
+repositories {
+	gradlePluginPortal()
+}

buildSrc/src/main/kotlin/jadx-java.gradle.kts

@@ -0,0 +1,57 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+
+plugins {
+	java
+	checkstyle
+}
+
+val jadxVersion: String by rootProject.extra
+
+group = "io.github.skylot"
+version = jadxVersion
+
+dependencies {
+	implementation("org.slf4j:slf4j-api:2.0.13")
+	compileOnly("org.jetbrains:annotations:24.1.0")
+
+	testImplementation("ch.qos.logback:logback-classic:1.5.6")
+	testImplementation("org.hamcrest:hamcrest-library:2.2")
+	testImplementation("org.mockito:mockito-core:5.11.0")
+	testImplementation("org.assertj:assertj-core:3.25.3")
+
+	testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
+	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+
+	testCompileOnly("org.jetbrains:annotations:24.1.0")
+}
+
+repositories {
+	mavenCentral()
+	// required for: aapt-proto, r8, smali
+	google()
+}
+
+java {
+	sourceCompatibility = JavaVersion.VERSION_11
+	targetCompatibility = JavaVersion.VERSION_11
+}
+
+tasks {
+	compileJava {
+		options.encoding = "UTF-8"
+	}
+	jar {
+		manifest {
+			attributes("jadx-version" to jadxVersion)
+		}
+	}
+	test {
+		useJUnitPlatform()
+		maxParallelForks = Runtime.getRuntime().availableProcessors()
+		testLogging {
+			showExceptions = true
+			exceptionFormat = TestExceptionFormat.FULL
+			showCauses = true
+		}
+	}
+}

buildSrc/src/main/kotlin/jadx-kotlin.gradle.kts

@@ -0,0 +1,12 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+	id("jadx-java")
+	id("org.jetbrains.kotlin.jvm")
+}
+
+kotlin {
+	compilerOptions {
+		jvmTarget.set(JvmTarget.JVM_11)
+	}
+}

buildSrc/src/main/kotlin/jadx-library.gradle.kts

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

config/checkstyle/checkstyle.xml

@@ -119,6 +119,17 @@
 		<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"/>

config/code-formatter/eclipse.xml

@@ -1,77 +1,248 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<profiles version="16">
-    <profile kind="CodeFormatterProfile" name="jadx eclipse" version="16">
+<profiles version="23">
+    <profile kind="CodeFormatterProfile" name="jadx eclipse" version="23">
         <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.number_of_blank_lines_before_code_block" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions" value="do not insert"/>
         <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_record_components" value="16"/>
         <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_space_before_closing_paren_in_record_declaration" value="do not insert"/>
         <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_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.blank_lines_before_abstract_method" value="1"/>
+        <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.number_of_blank_lines_at_beginning_of_method_body" value="0"/>
+        <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.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_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.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.insert_space_after_comma_in_switch_case_expressions" value="insert"/>
+        <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.brace_position_for_block" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block" value="0"/>
+        <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.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.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.wrap_before_switch_case_arrow_operator" value="false"/>
+        <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.format_line_comment_starting_on_first_column" value="true"/>
+        <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_before_ellipsis" value="do not 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.alignment_for_annotations_on_enum_constant" value="49"/>
+        <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_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.text_block_indentation" value="0"/>
+        <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.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.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_space_before_comma_in_permitted_types" value="do not insert"/>
+        <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_type_annotations" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assertion_message_operator" value="true"/>
+        <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.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.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.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" 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.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.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.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_not_operator" value="do not 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.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.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_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.alignment_for_annotations_on_package" value="49"/>
+        <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_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_before_colon_in_conditional" value="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_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case" value="insert"/>
+        <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_opening_bracket_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_permitted_types_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header" value="true"/>
+        <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.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_try" value="do not insert"/>
+        <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.brace_position_for_record_constructor" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+        <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_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <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.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.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_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_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_comma_in_record_components" 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.insert_space_before_opening_paren_in_synchronized" value="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_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <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.join_lines_in_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration" value="do not insert"/>
+        <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.blank_lines_between_import_groups" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration" value="common_lines"/>
+        <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.insert_space_after_postfix_operator" value="do not insert"/>
+        <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_after_arrow_in_switch_default" 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.disabling_tag" value="@formatter:off"/>
+        <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.number_of_blank_lines_at_end_of_method_body" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_switch_body_block_on_one_line" value="one_line_never"/>
+        <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_paren_in_switch" value="do not insert"/>
+        <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.never_indent_line_comments_on_first_column" value="false"/>
         <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.alignment_for_expressions_in_switch_case_with_arrow" value="0"/>
         <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"/>
@@ -80,267 +251,148 @@
         <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_opening_brace_in_record_constructor" value="insert"/>
         <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.keep_record_declaration_on_one_line" value="one_line_never"/>
         <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.alignment_for_annotations_on_parameter" value="0"/>
         <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.align_selector_in_method_invocation_on_expression_first_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_record_declaration" value="end_of_line"/>
         <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.keep_switch_case_with_arrow_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_colon" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block" value="0"/>
         <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.alignment_for_annotations_on_type" value="49"/>
         <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_local_variable" value="49"/>
         <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_arrow_in_switch_default" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags" value="do not insert"/>
         <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.alignment_for_annotations_on_field" value="49"/>
         <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.insert_space_after_comma_in_record_components" 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.insert_space_after_opening_paren_in_record_declaration" value="do not insert"/>
         <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.alignment_for_switch_case_with_arrow" value="0"/>
         <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.alignment_for_annotations_on_method" value="49"/>
         <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_record_constructor_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration" value="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.alignment_for_assertion_message" value="0"/>
         <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.alignment_for_superinterfaces_in_record_declaration" value="16"/>
         <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.blank_lines_after_last_class_body_declaration" value="0"/>
         <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.blank_lines_between_statement_group_in_switch" value="0"/>
         <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_after_comma_in_permitted_types" 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.number_of_blank_lines_at_beginning_of_code_block" value="0"/>
         <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"/>

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

@@ -1 +1,12 @@
-org.gradle.daemon=false
+org.gradle.warning.mode=all
+org.gradle.parallel=true
+org.gradle.caching=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,8 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-bin.zip
+distributionSha256Sum=544c35d6bd849ae8a5ed0bcea39ba677dc40f49df7d1835561582da2009b961d
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# 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.
@@ -17,67 +17,99 @@
 #
 
 ##############################################################################
-##
-##  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/HEAD/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/.
+#
 ##############################################################################
 
 # 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
+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
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +119,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 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
@@ -98,88 +130,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    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.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        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
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            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 or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    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=`expr $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*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# 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.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# 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
+
+
+# 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"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+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
+    die "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,89 +1,92 @@
-@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
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-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 execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-: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 %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="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
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@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
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+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% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+: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 %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+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!
+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
+
+:omega

jadx-cli/build.gradle

@@ -1,29 +0,0 @@
-plugins {
-	id 'application'
-}
-
-dependencies {
-	implementation(project(':jadx-core'))
-
-	runtimeOnly(project(':jadx-plugins:jadx-dex-input'))
-	runtimeOnly(project(':jadx-plugins:jadx-smali-input'))
-	runtimeOnly(project(':jadx-plugins:jadx-java-convert'))
-
-	implementation 'com.beust:jcommander:1.80'
-	implementation 'ch.qos.logback:logback-classic:1.2.3'
-}
-
-application {
-	applicationName = 'jadx'
-	mainClassName = 'jadx.cli.JadxCLI'
-	applicationDefaultJvmArgs = ['-Xms128M', '-Xmx4g', '-XX:+UseG1GC']
-}
-
-applicationDistribution.with {
-	into('') {
-		from '../.'
-		include 'README.md'
-		include 'NOTICE'
-		include 'LICENSE'
-	}
-}

jadx-cli/build.gradle.kts

@@ -0,0 +1,47 @@
+plugins {
+	id("jadx-java")
+	id("application")
+
+	// use shadow only for application scripts, jar will be copied from jadx-gui
+	id("com.github.johnrengelman.shadow") version "8.1.1"
+}
+
+dependencies {
+	implementation(project(":jadx-core"))
+	implementation(project(":jadx-plugins-tools"))
+
+	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"))
+	runtimeOnly(project(":jadx-plugins:jadx-rename-mappings"))
+	runtimeOnly(project(":jadx-plugins:jadx-kotlin-metadata"))
+	runtimeOnly(project(":jadx-plugins:jadx-script:jadx-script-plugin"))
+	runtimeOnly(project(":jadx-plugins:jadx-xapk-input"))
+	runtimeOnly(project(":jadx-plugins:jadx-aab-input"))
+
+	implementation("org.jcommander:jcommander:1.83")
+	implementation("ch.qos.logback:logback-classic:1.5.6")
+}
+
+application {
+	applicationName = "jadx"
+	mainClass.set("jadx.cli.JadxCLI")
+	applicationDefaultJvmArgs =
+		listOf(
+			"-Xms256M",
+			"-XX:MaxRAMPercentage=70.0",
+			// disable zip checks (#1962)
+			"-Djdk.util.zip.disableZip64ExtraFieldValidation=true",
+		)
+	applicationDistribution.from("$rootDir") {
+		include("README.md")
+		include("NOTICE")
+		include("LICENSE")
+	}
+}
+
+tasks.shadowJar {
+	// shadow jar not needed
+	configurations = listOf()
+}

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

@@ -5,9 +5,10 @@ import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
-import java.util.LinkedList;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
+import java.util.function.Supplier;
 
 import org.jetbrains.annotations.Nullable;
 
@@ -17,12 +18,24 @@ import com.beust.jcommander.ParameterException;
 import com.beust.jcommander.Parameterized;
 
 import jadx.api.JadxDecompiler;
+import jadx.api.plugins.JadxPluginInfo;
+import jadx.api.plugins.options.JadxPluginOptions;
+import jadx.api.plugins.options.OptionDescription;
+import jadx.core.plugins.JadxPluginManager;
+import jadx.core.plugins.PluginContext;
+import jadx.core.utils.Utils;
+import jadx.plugins.tools.JadxExternalPluginsLoader;
 
 public class JCommanderWrapper<T> {
 	private final JCommander jc;
+	private final JadxCLIArgs argsObj;
 
-	public JCommanderWrapper(T obj) {
-		this.jc = JCommander.newBuilder().addObject(obj).build();
+	public JCommanderWrapper(JadxCLIArgs argsObj) {
+		JCommander.Builder builder = JCommander.newBuilder().addObject(argsObj);
+		builder.acceptUnknownOptions(true); // workaround for "default" command
+		JadxCLICommands.append(builder);
+		this.jc = builder.build();
+		this.argsObj = argsObj;
 	}
 
 	public boolean parse(String[] args) {
@@ -36,7 +49,15 @@ public class JCommanderWrapper<T> {
 		}
 	}
 
-	public void overrideProvided(T obj) {
+	public boolean processCommands() {
+		String parsedCommand = jc.getParsedCommand();
+		if (parsedCommand == null) {
+			return false;
+		}
+		return JadxCLICommands.process(this, jc, parsedCommand);
+	}
+
+	public void overrideProvided(JadxCLIArgs obj) {
 		List<ParameterDescription> fieldsParams = jc.getParameters();
 		List<ParameterDescription> parameters = new ArrayList<>(1 + fieldsParams.size());
 		parameters.add(jc.getMainParameterValue());
@@ -45,19 +66,70 @@ public class JCommanderWrapper<T> {
 			if (parameter.isAssigned()) {
 				// copy assigned field value to obj
 				Parameterized parameterized = parameter.getParameterized();
-				Object val = parameterized.get(parameter.getObject());
-				parameterized.set(obj, val);
+				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 List<String> getUnknownOptions() {
+		return jc.getUnknownOptions();
+	}
+
 	public void printUsage() {
-		// print usage in not sorted fields order (by default its sorted by description)
+		LogHelper.setLogLevel(LogHelper.LogLevelEnum.ERROR); // mute logger while printing help
+
+		// print usage in not sorted fields order (by default 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("usage: jadx [command] [options] " + jc.getMainParameterDescription());
+
+		out.println("commands (use '<command> --help' for command options):");
+		for (String command : jc.getCommands().keySet()) {
+			out.println("  " + command + "\t  - " + jc.getUsageFormatter().getCommandDescription(command));
+		}
+		out.println();
+
+		int maxNamesLen = printOptions(jc, out, true);
+		out.println(appendPluginOptions(maxNamesLen));
+		out.println();
+		out.println("Environment variables:");
+		out.println("  JADX_DISABLE_XML_SECURITY - set to 'true' to disable all security checks for XML files");
+		out.println("  JADX_DISABLE_ZIP_SECURITY - set to 'true' to disable all security checks for zip files");
+		out.println("  JADX_ZIP_MAX_ENTRIES_COUNT - maximum allowed number of entries in zip files (default: 100 000)");
+		out.println("  JADX_CONFIG_DIR - custom config directory, using system by default");
+		out.println("  JADX_CACHE_DIR - custom cache directory, using system by default");
+		out.println("  JADX_TMP_DIR - custom temp directory, using system by default");
+		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");
+	}
+
+	public void printUsage(JCommander subCommander) {
+		PrintStream out = System.out;
+		out.println("usage: " + subCommander.getProgramName() + " [options]");
+		printOptions(subCommander, out, false);
+	}
+
+	private static int printOptions(JCommander jc, PrintStream out, boolean addDefaults) {
 		out.println("options:");
 
 		List<ParameterDescription> params = jc.getParameters();
@@ -70,36 +142,46 @@ public class JCommanderWrapper<T> {
 				maxNamesLen = len;
 			}
 		}
+		maxNamesLen += 3;
 
-		JadxCLIArgs args = (JadxCLIArgs) jc.getObjects().get(0);
+		Object args = jc.getObjects().get(0);
 		for (Field f : getFields(args.getClass())) {
 			String name = f.getName();
 			ParameterDescription p = paramsMap.get(name);
-			if (p == null) {
+			if (p == null || p.getParameter().hidden()) {
 				continue;
 			}
 			StringBuilder opt = new StringBuilder();
 			opt.append("  ").append(p.getNames());
-			addSpaces(opt, maxNamesLen - opt.length() + 3);
-			opt.append("- ").append(p.getDescription());
-			String defaultValue = getDefaultValue(args, f, opt);
-			if (defaultValue != null) {
-				opt.append(", default: ").append(defaultValue);
+			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);
+			}
+			if (addDefaults) {
+				String defaultValue = getDefaultValue(args, f);
+				if (defaultValue != null && !description.contains("(default)")) {
+					opt.append(", default: ").append(defaultValue);
+				}
 			}
 			out.println(opt);
 		}
-		out.println("Example:");
-		out.println("  jadx -d out classes.dex");
+		return maxNamesLen;
 	}
 
 	/**
 	 * Get all declared fields of the specified class and all super classes
-	 *
-	 * @param clazz
-	 * @return
 	 */
-	private List<Field> getFields(Class<?> clazz) {
-		List<Field> fieldList = new LinkedList<>();
+	private static List<Field> getFields(Class<?> clazz) {
+		List<Field> fieldList = new ArrayList<>();
 		while (clazz != null) {
 			fieldList.addAll(Arrays.asList(clazz.getDeclaredFields()));
 			clazz = clazz.getSuperclass();
@@ -108,7 +190,7 @@ public class JCommanderWrapper<T> {
 	}
 
 	@Nullable
-	private String getDefaultValue(JadxCLIArgs args, Field f, StringBuilder opt) {
+	private static String getDefaultValue(Object args, Field f) {
 		try {
 			Class<?> fieldType = f.getType();
 			if (fieldType == int.class) {
@@ -120,7 +202,7 @@ public class JCommanderWrapper<T> {
 			if (Enum.class.isAssignableFrom(fieldType)) {
 				Enum<?> val = (Enum<?>) f.get(args);
 				if (val != null) {
-					return val.name();
+					return val.name().toLowerCase(Locale.ROOT);
 				}
 			}
 		} catch (Exception e) {
@@ -134,4 +216,50 @@ public class JCommanderWrapper<T> {
 			str.append(' ');
 		}
 	}
+
+	private String appendPluginOptions(int maxNamesLen) {
+		StringBuilder sb = new StringBuilder();
+		int k = 1;
+		// load and init all options plugins to print all options
+		try (JadxDecompiler decompiler = new JadxDecompiler(argsObj.toJadxArgs())) {
+			JadxPluginManager pluginManager = decompiler.getPluginManager();
+			pluginManager.load(new JadxExternalPluginsLoader());
+			pluginManager.initAll();
+			for (PluginContext context : pluginManager.getAllPluginContexts()) {
+				JadxPluginOptions options = context.getOptions();
+				if (options != null) {
+					if (appendPlugin(context.getPluginInfo(), context.getOptions(), sb, maxNamesLen, k)) {
+						k++;
+					}
+				}
+			}
+		}
+		if (sb.length() == 0) {
+			return "";
+		}
+		return "\nPlugin options (-P<name>=<value>):" + sb;
+	}
+
+	private boolean appendPlugin(JadxPluginInfo pluginInfo, JadxPluginOptions options, StringBuilder out, int maxNamesLen, int k) {
+		List<OptionDescription> descs = options.getOptionsDescriptions();
+		if (descs.isEmpty()) {
+			return false;
+		}
+		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

@@ -5,9 +5,13 @@ import org.slf4j.LoggerFactory;
 
 import jadx.api.JadxArgs;
 import jadx.api.JadxDecompiler;
+import jadx.api.impl.AnnotatedCodeWriter;
 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;
+import jadx.plugins.tools.JadxExternalPluginsLoader;
 
 public class JadxCLI {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxCLI.class);
@@ -19,8 +23,8 @@ public class JadxCLI {
 		} catch (JadxArgsValidateException e) {
 			LOG.error("Incorrect arguments: {}", e.getMessage());
 			result = 1;
-		} catch (Exception e) {
-			LOG.error("jadx error: {}", e.getMessage(), e);
+		} catch (Throwable e) {
+			LOG.error("Process error:", e);
 			result = 1;
 		} finally {
 			FileUtils.deleteTempRootDir();
@@ -31,16 +35,27 @@ public class JadxCLI {
 	public static int execute(String[] args) {
 		JadxCLIArgs jadxArgs = new JadxCLIArgs();
 		if (jadxArgs.processArgs(args)) {
-			return processAndSave(jadxArgs.toJadxArgs());
+			return processAndSave(jadxArgs);
 		}
 		return 0;
 	}
 
-	private static int processAndSave(JadxArgs jadxArgs) {
+	private static int processAndSave(JadxCLIArgs cliArgs) {
+		LogHelper.initLogLevel(cliArgs);
+		LogHelper.setLogLevelsForLoadingStage();
+		JadxArgs jadxArgs = cliArgs.toJadxArgs();
 		jadxArgs.setCodeCache(new NoOpCodeCache());
+		jadxArgs.setPluginLoader(new JadxExternalPluginsLoader());
+		initCodeWriterProvider(jadxArgs);
 		try (JadxDecompiler jadx = new JadxDecompiler(jadxArgs)) {
 			jadx.load();
-			jadx.save();
+			if (checkForErrors(jadx)) {
+				return 1;
+			}
+			LogHelper.setLogLevelsForDecompileStage();
+			if (!SingleClassMode.process(jadx, cliArgs)) {
+				save(jadx);
+			}
 			int errorsCount = jadx.getErrorsCount();
 			if (errorsCount != 0) {
 				jadx.printErrorsReport();
@@ -51,4 +66,49 @@ public class JadxCLI {
 		}
 		return 0;
 	}
+
+	private static void initCodeWriterProvider(JadxArgs jadxArgs) {
+		switch (jadxArgs.getOutputFormat()) {
+			case JAVA:
+				jadxArgs.setCodeWriterProvider(SimpleCodeWriter::new);
+				break;
+			case JSON:
+				// needed for code offsets and source lines
+				jadxArgs.setCodeWriterProvider(AnnotatedCodeWriter::new);
+				break;
+		}
+	}
+
+	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 {
+			LOG.info("processing ...");
+			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");
+		}
+	}
 }

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

@@ -1,25 +1,40 @@
 package jadx.cli;
 
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 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.function.Function;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import com.beust.jcommander.DynamicParameter;
 import com.beust.jcommander.IStringConverter;
 import com.beust.jcommander.Parameter;
 
+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.core.utils.exceptions.JadxException;
+import jadx.api.args.GeneratedRenamesMappingFileMode;
+import jadx.api.args.IntegerFormat;
+import jadx.api.args.ResourceNameSource;
+import jadx.api.args.UserRenamesMappingsMode;
+import jadx.core.deobf.conditions.DeobfWhitelist;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
 import jadx.core.utils.files.FileUtils;
 
 public class JadxCLIArgs {
 
-	@Parameter(description = "<input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc)")
+	@Parameter(description = "<input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab, .xapk, .jadx.kts)")
 	protected List<String> files = new ArrayList<>(1);
 
 	@Parameter(names = { "-d", "--output-dir" }, description = "output directory")
@@ -37,9 +52,12 @@ public class JadxCLIArgs {
 	@Parameter(names = { "-s", "--no-src" }, description = "do not decompile source code")
 	protected boolean skipSources = false;
 
-	@Parameter(names = { "--single-class" }, description = "decompile a single class")
+	@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";
 
@@ -49,18 +67,47 @@ public class JadxCLIArgs {
 	@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 = { "--no-xml-pretty-print" }, description = "do not prettify XML")
+	protected boolean skipXmlPrettyPrint = false;
+
 	@Parameter(names = { "--no-imports" }, description = "disable use of imports, always write entire package name")
 	protected boolean useImports = true;
 
-	@Parameter(names = { "--no-debug-info" }, description = "disable debug info")
+	@Parameter(names = { "--no-debug-info" }, description = "disable debug info parsing and processing")
 	protected boolean debugInfo = true;
 
+	@Parameter(names = { "--add-debug-lines" }, description = "add comments with debug line numbers if available")
+	protected boolean addDebugLines = false;
+
 	@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-move-inner-classes" }, description = "disable move inner classes into parent")
+	protected boolean moveInnerClasses = true;
+
+	@Parameter(names = { "--no-inline-kotlin-lambda" }, description = "disable inline for Kotlin lambdas")
+	protected boolean allowInlineKotlinLambda = 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;
 
@@ -70,6 +117,22 @@ public class JadxCLIArgs {
 	@Parameter(names = { "--respect-bytecode-access-modifiers" }, description = "don't change original access modifiers")
 	protected boolean respectBytecodeAccessModifiers = false;
 
+	@Parameter(
+			names = { "--mappings-path" },
+			description = "deobfuscation mappings file or directory. Allowed formats: Tiny and Tiny v2 (both '.tiny'), Enigma (.mapping) or Enigma directory"
+	)
+	protected Path userRenamesMappingsPath;
+
+	@Parameter(
+			names = { "--mappings-mode" },
+			description = "set mode for handling the deobfuscation mapping file:"
+					+ "\n 'read' - just read, user can always save manually (default)"
+					+ "\n 'read-and-autosave-every-change' - read and autosave after every change"
+					+ "\n 'read-and-autosave-before-closing' - read and autosave before exiting the app or closing the project"
+					+ "\n 'ignore' - don't read or save (can be used to skip loading mapping files referenced in the project file)"
+	)
+	protected UserRenamesMappingsMode userRenamesMappingsMode = UserRenamesMappingsMode.getDefault();
+
 	@Parameter(names = { "--deobf" }, description = "activate deobfuscation")
 	protected boolean deobfuscationOn = false;
 
@@ -79,26 +142,72 @@ public class JadxCLIArgs {
 	@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-whitelist" },
+			description = "space separated list of classes (full name) and packages (ends with '.*') to exclude from deobfuscation"
+	)
+	protected String deobfuscationWhitelistStr = DeobfWhitelist.DEFAULT_STR;
+
+	@Parameter(
+			names = { "--deobf-cfg-file" },
+			description = "deobfuscation mappings file used for JADX auto-generated names (in the JOBF file format),"
+					+ " default: same dir and name as input file with '.jobf' extension"
+	)
+	protected String generatedRenamesMappingFile;
+
+	@Parameter(
+			names = { "--deobf-cfg-file-mode" },
+			description = "set mode for handling the JADX auto-generated names' 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 GeneratedRenamesMappingFileMode generatedRenamesMappingFileMode = GeneratedRenamesMappingFileMode.getDefault();
 
 	@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 = "what to rename, comma-separated,"
-					+ " 'case' for system case sensitivity,"
-					+ " 'valid' for java identifiers,"
-					+ " 'printable' characters,"
-					+ " 'none' or 'all' (default)",
+			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 = { "--integer-format" },
+			description = "how integers are displayed:"
+					+ "\n 'auto' - automatically select (default)"
+					+ "\n 'decimal' - use decimal"
+					+ "\n 'hexadecimal' - use hexadecimal",
+			converter = IntegerFormatConverter.class
+	)
+	protected IntegerFormat integerFormat = IntegerFormat.AUTO;
+
 	@Parameter(names = { "--fs-case-sensitive" }, description = "treat filesystem as case sensitive, false by default")
 	protected boolean fsCaseSensitive = false;
 
@@ -108,28 +217,41 @@ public class JadxCLIArgs {
 	@Parameter(names = { "--raw-cfg" }, description = "save methods control flow graph (use raw instructions)")
 	protected boolean rawCfgOutput = false;
 
-	@Parameter(names = { "-f", "--fallback" }, description = "make simple dump (using goto instead of 'if', 'for', etc)")
+	@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 = 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 = { "--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 = { "--version" }, description = "print jadx version")
 	protected boolean printVersion = false;
 
 	@Parameter(names = { "-h", "--help" }, description = "print this help", help = true)
 	protected boolean printHelp = false;
 
+	@DynamicParameter(names = "-P", description = "Plugin options", hidden = true)
+	protected Map<String, String> pluginOptions = new HashMap<>();
+
 	public boolean processArgs(String[] args) {
 		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(this);
 		return jcw.parse(args) && process(jcw);
@@ -153,6 +275,10 @@ public class JadxCLIArgs {
 	}
 
 	private boolean process(JCommanderWrapper<JadxCLIArgs> jcw) {
+		files.addAll(jcw.getUnknownOptions());
+		if (jcw.processCommands()) {
+			return false;
+		}
 		if (printHelp) {
 			jcw.printUsage();
 			return false;
@@ -161,15 +287,13 @@ public class JadxCLIArgs {
 			System.out.println(JadxDecompiler.getVersion());
 			return false;
 		}
-		try {
-			if (threadsCount <= 0) {
-				throw new JadxException("Threads count must be positive, got: " + threadsCount);
+		if (threadsCount <= 0) {
+			throw new JadxArgsValidateException("Threads count must be positive, got: " + threadsCount);
+		}
+		for (String fileName : files) {
+			if (fileName.startsWith("-")) {
+				throw new JadxArgsValidateException("Unknown option: " + fileName);
 			}
-			LogHelper.setLogLevelFromArgs(this);
-		} catch (JadxException e) {
-			System.err.println("ERROR: " + e.getMessage());
-			jcw.printUsage();
-			return false;
 		}
 		return true;
 	}
@@ -183,31 +307,47 @@ public class JadxCLIArgs {
 		args.setOutputFormat(JadxArgs.OutputFormatEnum.valueOf(outputFormat.toUpperCase()));
 		args.setThreadsCount(threadsCount);
 		args.setSkipSources(skipSources);
-		if (singleClass != null) {
-			args.setClassFilter(className -> singleClass.equals(className));
-		}
 		args.setSkipResources(skipResources);
-		args.setFallbackMode(fallbackMode);
+		if (fallbackMode) {
+			args.setDecompilationMode(DecompilationMode.FALLBACK);
+		} else {
+			args.setDecompilationMode(decompilationMode);
+		}
 		args.setShowInconsistentCode(showInconsistentCode);
 		args.setCfgOutput(cfgOutput);
 		args.setRawCFGOutput(rawCfgOutput);
 		args.setReplaceConsts(replaceConsts);
+		if (userRenamesMappingsPath != null) {
+			args.setUserRenamesMappingsPath(userRenamesMappingsPath);
+		}
+		args.setUserRenamesMappingsMode(userRenamesMappingsMode);
 		args.setDeobfuscationOn(deobfuscationOn);
-		args.setDeobfuscationForceSave(deobfuscationForceSave);
+		args.setGeneratedRenamesMappingFile(FileUtils.toFile(generatedRenamesMappingFile));
+		args.setGeneratedRenamesMappingFileMode(generatedRenamesMappingFileMode);
 		args.setDeobfuscationMinLength(deobfuscationMinLength);
 		args.setDeobfuscationMaxLength(deobfuscationMaxLength);
+		args.setDeobfuscationWhitelist(Arrays.asList(deobfuscationWhitelistStr.split(" ")));
 		args.setUseSourceNameAsClassAlias(deobfuscationUseSourceNameAsAlias);
-		args.setParseKotlinMetadata(deobfuscationParseKotlinMetadata);
+		args.setUseKotlinMethodsForVarNames(useKotlinMethodsForVarNames);
+		args.setResourceNameSource(resourceNameSource);
 		args.setEscapeUnicode(escapeUnicode);
 		args.setRespectBytecodeAccModifiers(respectBytecodeAccessModifiers);
 		args.setExportAsGradleProject(exportAsGradleProject);
+		args.setSkipXmlPrettyPrint(skipXmlPrettyPrint);
 		args.setUseImports(useImports);
 		args.setDebugInfo(debugInfo);
+		args.setInsertDebugLines(addDebugLines);
 		args.setInlineAnonymousClasses(inlineAnonymousClasses);
-		args.setRenameCaseSensitive(isRenameCaseSensitive());
-		args.setRenameValid(isRenameValid());
-		args.setRenamePrintable(isRenamePrintable());
+		args.setInlineMethods(inlineMethods);
+		args.setMoveInnerClasses(moveInnerClasses);
+		args.setAllowInlineKotlinLambda(allowInlineKotlinLambda);
+		args.setExtractFinally(extractFinally);
+		args.setRenameFlags(renameFlags);
 		args.setFsCaseSensitive(fsCaseSensitive);
+		args.setCommentsLevel(commentsLevel);
+		args.setIntegerFormat(integerFormat);
+		args.setUseDxInput(useDx);
+		args.setPluginOptions(pluginOptions);
 		return args;
 	}
 
@@ -227,6 +367,14 @@ public class JadxCLIArgs {
 		return outDirRes;
 	}
 
+	public String getSingleClass() {
+		return singleClass;
+	}
+
+	public String getSingleClassOutput() {
+		return singleClassOutput;
+	}
+
 	public boolean isSkipResources() {
 		return skipResources;
 	}
@@ -243,6 +391,14 @@ public class JadxCLIArgs {
 		return fallbackMode;
 	}
 
+	public boolean isUseDx() {
+		return useDx;
+	}
+
+	public DecompilationMode getDecompilationMode() {
+		return decompilationMode;
+	}
+
 	public boolean isShowInconsistentCode() {
 		return showInconsistentCode;
 	}
@@ -255,10 +411,38 @@ public class JadxCLIArgs {
 		return debugInfo;
 	}
 
+	public boolean isAddDebugLines() {
+		return addDebugLines;
+	}
+
 	public boolean isInlineAnonymousClasses() {
 		return inlineAnonymousClasses;
 	}
 
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public boolean isMoveInnerClasses() {
+		return moveInnerClasses;
+	}
+
+	public boolean isAllowInlineKotlinLambda() {
+		return allowInlineKotlinLambda;
+	}
+
+	public boolean isExtractFinally() {
+		return extractFinally;
+	}
+
+	public Path getUserRenamesMappingsPath() {
+		return userRenamesMappingsPath;
+	}
+
+	public UserRenamesMappingsMode getUserRenamesMappingsMode() {
+		return userRenamesMappingsMode;
+	}
+
 	public boolean isDeobfuscationOn() {
 		return deobfuscationOn;
 	}
@@ -271,16 +455,32 @@ public class JadxCLIArgs {
 		return deobfuscationMaxLength;
 	}
 
-	public boolean isDeobfuscationForceSave() {
-		return deobfuscationForceSave;
+	public String getDeobfuscationWhitelistStr() {
+		return deobfuscationWhitelistStr;
+	}
+
+	public String getGeneratedRenamesMappingFile() {
+		return generatedRenamesMappingFile;
+	}
+
+	public GeneratedRenamesMappingFileMode getGeneratedRenamesMappingFileMode() {
+		return generatedRenamesMappingFileMode;
 	}
 
 	public boolean isDeobfuscationUseSourceNameAsAlias() {
 		return deobfuscationUseSourceNameAsAlias;
 	}
 
-	public boolean isDeobfuscationParseKotlinMetadata() {
-		return deobfuscationParseKotlinMetadata;
+	public ResourceNameSource getResourceNameSource() {
+		return resourceNameSource;
+	}
+
+	public UseKotlinMethodsForVarNames getUseKotlinMethodsForVarNames() {
+		return useKotlinMethodsForVarNames;
+	}
+
+	public IntegerFormat getIntegerFormat() {
+		return integerFormat;
 	}
 
 	public boolean isEscapeUnicode() {
@@ -307,6 +507,10 @@ public class JadxCLIArgs {
 		return exportAsGradleProject;
 	}
 
+	public boolean isSkipXmlPrettyPrint() {
+		return skipXmlPrettyPrint;
+	}
+
 	public boolean isRenameCaseSensitive() {
 		return renameFlags.contains(RenameEnum.CASE);
 	}
@@ -323,6 +527,18 @@ public class JadxCLIArgs {
 		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;
 
@@ -341,9 +557,9 @@ public class JadxCLIArgs {
 			Set<RenameEnum> set = EnumSet.noneOf(RenameEnum.class);
 			for (String s : value.split(",")) {
 				try {
-					set.add(RenameEnum.valueOf(s.toUpperCase(Locale.ROOT)));
-				} catch (IllegalArgumentException e) {
-					throw new IllegalArgumentException(
+					set.add(RenameEnum.valueOf(s.trim().toUpperCase(Locale.ROOT)));
+				} catch (Exception e) {
+					throw new JadxArgsValidateException(
 							'\'' + s + "' is unknown for parameter " + paramName
 									+ ", possible values are " + enumValuesString(RenameEnum.values()));
 				}
@@ -352,9 +568,76 @@ public class JadxCLIArgs {
 		}
 	}
 
+	public static class CommentsLevelConverter extends BaseEnumConverter<CommentsLevel> {
+		public CommentsLevelConverter() {
+			super(CommentsLevel::valueOf, CommentsLevel::values);
+		}
+	}
+
+	public static class UseKotlinMethodsForVarNamesConverter extends BaseEnumConverter<UseKotlinMethodsForVarNames> {
+		public UseKotlinMethodsForVarNamesConverter() {
+			super(UseKotlinMethodsForVarNames::valueOf, UseKotlinMethodsForVarNames::values);
+		}
+	}
+
+	public static class DeobfuscationMapFileModeConverter extends BaseEnumConverter<GeneratedRenamesMappingFileMode> {
+		public DeobfuscationMapFileModeConverter() {
+			super(GeneratedRenamesMappingFileMode::valueOf, GeneratedRenamesMappingFileMode::values);
+		}
+	}
+
+	public static class ResourceNameSourceConverter extends BaseEnumConverter<ResourceNameSource> {
+		public ResourceNameSourceConverter() {
+			super(ResourceNameSource::valueOf, ResourceNameSource::values);
+		}
+	}
+
+	public static class DecompilationModeConverter extends BaseEnumConverter<DecompilationMode> {
+		public DecompilationModeConverter() {
+			super(DecompilationMode::valueOf, DecompilationMode::values);
+		}
+	}
+
+	public static class LogLevelConverter extends BaseEnumConverter<LogHelper.LogLevelEnum> {
+		public LogLevelConverter() {
+			super(LogHelper.LogLevelEnum::valueOf, LogHelper.LogLevelEnum::values);
+		}
+	}
+
+	public static class IntegerFormatConverter extends BaseEnumConverter<IntegerFormat> {
+		public IntegerFormatConverter() {
+			super(IntegerFormat::valueOf, IntegerFormat::values);
+		}
+	}
+
+	public abstract static class BaseEnumConverter<E extends Enum<E>> implements IStringConverter<E> {
+		private final Function<String, E> parse;
+		private final Supplier<E[]> values;
+
+		public BaseEnumConverter(Function<String, E> parse, Supplier<E[]> values) {
+			this.parse = parse;
+			this.values = values;
+		}
+
+		@Override
+		public E convert(String value) {
+			try {
+				return parse.apply(stringAsEnumName(value));
+			} catch (Exception e) {
+				throw new JadxArgsValidateException(
+						'\'' + value + "' is unknown, possible values are: " + enumValuesString(values.get()));
+			}
+		}
+	}
+
 	public static String enumValuesString(Enum<?>[] values) {
 		return Stream.of(values)
-				.map(v -> '\'' + v.name().toLowerCase(Locale.ROOT) + '\'')
+				.map(v -> v.name().replace('_', '-').toLowerCase(Locale.ROOT))
 				.collect(Collectors.joining(", "));
 	}
+
+	private static String stringAsEnumName(String value) {
+		// inverse of enumValuesString conversion
+		return value.replace('-', '_').toUpperCase(Locale.ROOT);
+	}
 }

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

@@ -0,0 +1,37 @@
+package jadx.cli;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+import com.beust.jcommander.JCommander;
+
+import jadx.cli.commands.CommandPlugins;
+import jadx.cli.commands.ICommand;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
+public class JadxCLICommands {
+	private static final Map<String, ICommand> COMMANDS_MAP = new TreeMap<>();
+
+	static {
+		JadxCLICommands.register(new CommandPlugins());
+	}
+
+	public static void register(ICommand command) {
+		COMMANDS_MAP.put(command.name(), command);
+	}
+
+	public static void append(JCommander.Builder builder) {
+		COMMANDS_MAP.forEach(builder::addCommand);
+	}
+
+	public static boolean process(JCommanderWrapper<?> jcw, JCommander jc, String parsedCommand) {
+		ICommand command = COMMANDS_MAP.get(parsedCommand);
+		if (command == null) {
+			throw new JadxArgsValidateException("Unknown command: " + parsedCommand
+					+ ". Expected one of: " + COMMANDS_MAP.keySet());
+		}
+		JCommander subCommander = jc.getCommands().get(parsedCommand);
+		command.process(jcw, subCommander);
+		return true;
+	}
+}

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

@@ -1,9 +1,9 @@
 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;
 
@@ -31,35 +31,81 @@ public class LogHelper {
 		}
 	}
 
-	public static void setLogLevelFromArgs(JadxCLIArgs args) {
+	@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 setLogLevel(LogLevelEnum newLogLevel) {
+		logLevelValue = newLogLevel;
+		applyLogLevel(logLevelValue);
+	}
+
+	public static void setLogLevelsForLoadingStage() {
+		if (logLevelValue == null) {
 			return;
 		}
-		LogLevelEnum logLevel = args.logLevel;
-		if (args.quiet) {
-			logLevel = LogLevelEnum.QUIET;
-		} else if (args.verbose) {
-			logLevel = LogLevelEnum.DEBUG;
+		if (logLevelValue == LogLevelEnum.PROGRESS) {
+			// show load errors
+			LogHelper.applyLogLevel(LogLevelEnum.ERROR);
+			fixForShowProgress();
+			return;
 		}
-
-		applyLogLevel(logLevel);
+		applyLogLevel(logLevelValue);
 	}
 
-	public static void applyLogLevel(LogLevelEnum logLevel) {
+	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());
-
-		if (logLevel != LogLevelEnum.QUIET) {
-			// show progress for all levels except quiet
-			setLevelForClass(JadxCLI.class, Level.INFO);
-			setLevelForClass(JadxDecompiler.class, Level.INFO);
-		}
 	}
 
-	private static void setLevelForClass(Class<?> cls, Level level) {
+	@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=
 	 */
@@ -76,18 +122,4 @@ public class LogHelper {
 		}
 		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,88 @@
+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.JadxArgsValidateException;
+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 JadxArgsValidateException("Input class not found: " + singleClass);
+			}
+			if (clsForProcess.contains(AFlag.DONT_GENERATE)) {
+				throw new JadxArgsValidateException("Input class can't be saved by current 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 JadxArgsValidateException("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

@@ -1,9 +1,7 @@
 package jadx.cli.clst;
 
-import java.io.IOException;
 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;
@@ -13,11 +11,10 @@ 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.api.JadxDecompiler;
 import jadx.core.clsp.ClsSet;
 import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.files.FileUtils;
 
 /**
  * Utility class for convert dex or jar to jadx classes set (.jcst)
@@ -26,33 +23,50 @@ 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> ");
+		LOG.info("<android API level (number)> <output .jcst file> <several input dex or jar files> ");
+		LOG.info("Arguments to update core.jcst: "
+				+ "<android API level (number)> "
+				+ "<jadx root>/jadx-core/src/main/resources/clst/core.jcst "
+				+ "<sdk_root>/platforms/android-<api level>/android.jar"
+				+ "<sdk_root>/platforms/android-<api level>/optional/android.car.jar "
+				+ "<sdk_root>/platforms/android-<api level>/optional/org.apache.http.legacy.jar");
 	}
 
-	public static void main(String[] args) throws IOException {
-		if (args.length < 2) {
+	public static void main(String[] args) {
+		if (args.length != 5) {
 			usage();
 			System.exit(1);
 		}
-		List<Path> inputPaths = Stream.of(args).map(Paths::get).collect(Collectors.toList());
+		int androidApiLevel = Integer.parseInt(args[0]);
+		List<Path> inputPaths = Stream.of(args).skip(1).map(Paths::get).collect(Collectors.toList());
 		Path output = inputPaths.remove(0);
 
-		JadxPluginManager pluginManager = new JadxPluginManager();
-		List<ILoadResult> loadedInputs = new ArrayList<>();
-		for (JadxInputPlugin inputPlugin : pluginManager.getInputPlugins()) {
-			loadedInputs.add(inputPlugin.loadFiles(inputPaths));
-		}
-
 		JadxArgs jadxArgs = new JadxArgs();
+		jadxArgs.setInputFiles(FileUtils.toFiles(inputPaths));
+
+		// disable not needed passes executed at prepare stage
+		jadxArgs.setDeobfuscationOn(false);
 		jadxArgs.setRenameFlags(EnumSet.noneOf(JadxArgs.RenameEnum.class));
-		RootNode root = new RootNode(jadxArgs);
-		root.loadClasses(loadedInputs);
+		jadxArgs.setUseSourceNameAsClassAlias(false);
+		jadxArgs.setMoveInnerClasses(false);
+		jadxArgs.setInlineAnonymousClasses(false);
+		jadxArgs.setInlineMethods(false);
 
-		ClsSet set = new ClsSet(root);
-		set.loadFrom(root);
-		set.save(output);
+		// don't require/load class set file
+		jadxArgs.setLoadJadxClsSetFile(false);
 
-		LOG.info("Output: {}, file size: {}B", output, output.toFile().length());
-		LOG.info("done");
+		try (JadxDecompiler decompiler = new JadxDecompiler(jadxArgs)) {
+			decompiler.load();
+			RootNode root = decompiler.getRoot();
+			ClsSet set = new ClsSet(root);
+			set.setAndroidApiLevel(androidApiLevel);
+			set.loadFrom(root);
+			set.save(output);
+
+			LOG.info("Output: {}", output);
+			LOG.info("done");
+		} catch (Exception e) {
+			LOG.error("Failed with error", e);
+		}
 	}
 }

jadx-cli/src/main/java/jadx/cli/commands/CommandPlugins.java

@@ -0,0 +1,98 @@
+package jadx.cli.commands;
+
+import java.util.List;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+
+import jadx.cli.JCommanderWrapper;
+import jadx.plugins.tools.JadxPluginsList;
+import jadx.plugins.tools.JadxPluginsTools;
+import jadx.plugins.tools.data.JadxPluginMetadata;
+import jadx.plugins.tools.data.JadxPluginUpdate;
+
+@Parameters(commandDescription = "manage jadx plugins")
+public class CommandPlugins implements ICommand {
+
+	@Parameter(names = { "-i", "--install" }, description = "install plugin with locationId")
+	protected String install;
+
+	@Parameter(names = { "-j", "--install-jar" }, description = "install plugin from jar file")
+	protected String installJar;
+
+	@Parameter(names = { "-l", "--list" }, description = "list installed plugins")
+	protected boolean list;
+
+	@Parameter(names = { "-a", "--available" }, description = "list available plugins")
+	protected boolean available;
+
+	@Parameter(names = { "-u", "--update" }, description = "update installed plugins")
+	protected boolean update;
+
+	@Parameter(names = { "--uninstall" }, description = "uninstall plugin with pluginId")
+	protected String uninstall;
+
+	@Parameter(names = { "-h", "--help" }, description = "print this help", help = true)
+	protected boolean printHelp = false;
+
+	@Override
+	public String name() {
+		return "plugins";
+	}
+
+	@Override
+	public void process(JCommanderWrapper<?> jcw, JCommander subCommander) {
+		if (printHelp) {
+			jcw.printUsage(subCommander);
+			return;
+		}
+		if (install != null) {
+			installPlugin(install);
+		}
+		if (installJar != null) {
+			installPlugin("file:" + installJar);
+		}
+		if (uninstall != null) {
+			boolean uninstalled = JadxPluginsTools.getInstance().uninstall(uninstall);
+			System.out.println(uninstalled ? "Uninstalled" : "Plugin not found");
+		}
+		if (update) {
+			List<JadxPluginUpdate> updates = JadxPluginsTools.getInstance().updateAll();
+			if (updates.isEmpty()) {
+				System.out.println("No updates");
+			} else {
+				System.out.println("Installed updates: " + updates.size());
+				for (JadxPluginUpdate update : updates) {
+					System.out.println("  " + update.getPluginId() + ": " + update.getOldVersion() + " -> " + update.getNewVersion());
+				}
+			}
+		}
+		if (list) {
+			List<JadxPluginMetadata> installed = JadxPluginsTools.getInstance().getInstalled();
+			System.out.println("Installed plugins: " + installed.size());
+			int i = 1;
+			for (JadxPluginMetadata plugin : installed) {
+				System.out.println(" " + (i++) + ") "
+						+ plugin.getPluginId() + " (" + plugin.getVersion() + ") - "
+						+ plugin.getName() + ": " + plugin.getDescription());
+			}
+		}
+
+		if (available) {
+			List<JadxPluginMetadata> availableList = JadxPluginsList.getInstance().get();
+			System.out.println("Available plugins: " + availableList.size());
+			int i = 1;
+			for (JadxPluginMetadata plugin : availableList) {
+				System.out.println(" " + (i++) + ") "
+						+ plugin.getName() + ": " + plugin.getDescription()
+						+ " (" + plugin.getLocationId() + ")");
+			}
+		}
+	}
+
+	private void installPlugin(String locationId) {
+		JadxPluginMetadata plugin = JadxPluginsTools.getInstance().install(locationId);
+		System.out.println("Plugin installed: " + plugin.getPluginId() + ":" + plugin.getVersion());
+	}
+}

jadx-cli/src/main/java/jadx/cli/commands/ICommand.java

@@ -0,0 +1,11 @@
+package jadx.cli.commands;
+
+import com.beust.jcommander.JCommander;
+
+import jadx.cli.JCommanderWrapper;
+
+public interface ICommand {
+	String name();
+
+	void process(JCommanderWrapper<?> jcw, JCommander subCommander);
+}

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.ResTableBinaryParser;
+
+/**
+ * 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);
+			ResTableBinaryParser resTableParser = new ResTableBinaryParser(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,3 +1,5 @@
+<!-- Jadx logger config. Used both in cli and gui -->
+
 <configuration>
 	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
 		<encoder>
@@ -5,6 +7,9 @@
 		</encoder>
 	</appender>
 
+	<!-- jadx-gui -->
+	<logger name="com.pinterest.ktlint" level="INFO"/>
+
 	<root level="INFO">
 		<appender-ref ref="STDOUT"/>
 	</root>

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

@@ -1,9 +1,14 @@
 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;
 
@@ -47,6 +52,40 @@ public class JadxCLIArgsTest {
 		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);
 	}

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

@@ -7,6 +7,7 @@ import org.junit.jupiter.api.Test;
 
 import jadx.api.JadxArgs.RenameEnum;
 import jadx.cli.JadxCLIArgs.RenameConverter;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -38,12 +39,11 @@ public class RenameConverterTest {
 
 	@Test
 	public void wrong() {
-		IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
+		JadxArgsValidateException thrown = assertThrows(JadxArgsValidateException.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'",
+		assertEquals("'wrong' is unknown for parameter someParam, possible values are case, valid, printable",
 				thrown.getMessage());
 	}
 }

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

@@ -7,6 +7,7 @@ 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;
@@ -43,20 +44,48 @@ public class TestInput {
 		decompile("multi", "samples/hello.dex", "samples/HelloWorld.smali");
 	}
 
-	private void decompile(String tmpDirName, String... inputSamples) throws URISyntaxException, IOException {
-		StringBuilder args = new StringBuilder();
+	@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.append("-v");
-		args.append(" -d ").append(tempDir.toAbsolutePath());
+		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.append(' ').append(sampleFile);
+			args.add(sampleFile);
 		}
 
-		int result = JadxCLI.execute(args.toString().split(" "));
+		int result = JadxCLI.execute(args.toArray(new String[0]));
 		assertThat(result).isEqualTo(0);
 		List<Path> resultJavaFiles = collectJavaFilesInDir(tempDir);
 		assertThat(resultJavaFiles).isNotEmpty();

jadx-commons/jadx-app-commons/README.md

@@ -0,0 +1,6 @@
+## jadx app commons
+
+This module contains common utilities used in jadx apps (cli and gui) and not needed in jadx-code module:
+- `JadxCommonFiles` - wrapper for `dev.dirs:directories` lib to get
+  'config' and 'cache' directories in cross-platform way
+- `JadxCommonEnv` - utils for work with environment variables

jadx-commons/jadx-app-commons/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+	id("jadx-library")
+}
+
+dependencies {
+	implementation("dev.dirs:directories:26")
+}

jadx-commons/jadx-app-commons/src/main/java/jadx/commons/app/JadxCommonEnv.java

@@ -0,0 +1,29 @@
+package jadx.commons.app;
+
+public class JadxCommonEnv {
+
+	public static String get(String varName, String defValue) {
+		String strValue = System.getenv(varName);
+		return isNullOrEmpty(strValue) ? defValue : strValue;
+	}
+
+	public static boolean getBool(String varName, boolean defValue) {
+		String strValue = System.getenv(varName);
+		if (isNullOrEmpty(strValue)) {
+			return defValue;
+		}
+		return strValue.equalsIgnoreCase("true");
+	}
+
+	public static int getInt(String varName, int defValue) {
+		String strValue = System.getenv(varName);
+		if (isNullOrEmpty(strValue)) {
+			return defValue;
+		}
+		return Integer.parseInt(strValue);
+	}
+
+	private static boolean isNullOrEmpty(String value) {
+		return value == null || value.isEmpty();
+	}
+}

jadx-commons/jadx-app-commons/src/main/java/jadx/commons/app/JadxCommonFiles.java

@@ -0,0 +1,73 @@
+package jadx.commons.app;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.jetbrains.annotations.Nullable;
+
+import dev.dirs.ProjectDirectories;
+
+public class JadxCommonFiles {
+
+	private static final Path CONFIG_DIR;
+	private static final Path CACHE_DIR;
+
+	public static Path getConfigDir() {
+		return CONFIG_DIR;
+	}
+
+	public static Path getCacheDir() {
+		return CACHE_DIR;
+	}
+
+	static {
+		DirsLoader loader = new DirsLoader();
+		loader.init();
+		CONFIG_DIR = loader.getConfigDir();
+		CACHE_DIR = loader.getCacheDir();
+	}
+
+	private static final class DirsLoader {
+		private @Nullable ProjectDirectories dirs;
+		private Path configDir;
+		private Path cacheDir;
+
+		public void init() {
+			try {
+				configDir = loadEnvDir("JADX_CONFIG_DIR");
+				cacheDir = loadEnvDir("JADX_CACHE_DIR");
+			} catch (Exception e) {
+				throw new RuntimeException("Failed to init common directories", e);
+			}
+		}
+
+		private Path loadEnvDir(String envVar) throws IOException {
+			String envDir = JadxCommonEnv.get(envVar, null);
+			String dirStr;
+			if (envDir != null) {
+				dirStr = envDir;
+			} else {
+				dirStr = loadDirs().configDir;
+			}
+			Path path = Path.of(dirStr).toAbsolutePath();
+			Files.createDirectories(path);
+			return path;
+		}
+
+		private synchronized ProjectDirectories loadDirs() {
+			if (dirs == null) {
+				dirs = ProjectDirectories.from("io.github", "skylot", "jadx");
+			}
+			return dirs;
+		}
+
+		public Path getCacheDir() {
+			return cacheDir;
+		}
+
+		public Path getConfigDir() {
+			return configDir;
+		}
+	}
+}

jadx-core/build.gradle

@@ -1,22 +0,0 @@
-plugins {
-	id 'java-library'
-}
-
-dependencies {
-	runtimeOnly files('clsp-data/android-29-clst.jar')
-	runtimeOnly files('clsp-data/android-29-res.jar')
-
-	api(project(':jadx-plugins:jadx-plugins-api'))
-
-	implementation 'com.google.code.gson:gson:2.8.6'
-
-	testImplementation 'org.apache.commons:commons-lang3:3.11'
-
-	testRuntimeOnly(project(':jadx-plugins:jadx-dex-input'))
-	testRuntimeOnly(project(':jadx-plugins:jadx-smali-input'))
-	testRuntimeOnly(project(':jadx-plugins:jadx-java-convert'))
-}
-
-test {
-	exclude '**/tmp/*'
-}

jadx-core/build.gradle.kts

@@ -0,0 +1,29 @@
+plugins {
+	id("jadx-library")
+}
+
+dependencies {
+	api(project(":jadx-plugins:jadx-input-api"))
+
+	implementation("com.google.code.gson:gson:2.10.1")
+
+	testImplementation("org.apache.commons:commons-lang3:3.14.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") {
+		version {
+			prefer("3.33.0")
+			strictly("[3.33, 3.34[") // from 3.34 compiled with Java 17
+		}
+	}
+	testImplementation("tools.profiler:async-profiler:3.0")
+}
+
+tasks.test {
+	exclude("**/tmp/*")
+}

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

@@ -1,70 +0,0 @@
-package jadx.api;
-
-public final class CodePosition {
-
-	private final JavaNode node;
-	private final int line;
-	private final int offset;
-
-	public CodePosition(JavaNode node, int line, int offset) {
-		this.node = node;
-		this.line = line;
-		this.offset = offset;
-	}
-
-	public CodePosition(int line, int offset) {
-		this.node = null;
-		this.line = line;
-		this.offset = offset;
-	}
-
-	public JavaNode getNode() {
-		return node;
-	}
-
-	public JavaClass getJavaClass() {
-		JavaClass parent = node.getDeclaringClass();
-		if (parent == null && node instanceof JavaClass) {
-			return (JavaClass) node;
-		}
-		return parent;
-	}
-
-	public int getLine() {
-		return line;
-	}
-
-	public int getOffset() {
-		return offset;
-	}
-
-	@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() {
-		StringBuilder sb = new StringBuilder();
-		sb.append(line);
-		if (offset != 0) {
-			sb.append(':').append(offset);
-		}
-		if (node != null) {
-			sb.append(' ').append(node);
-		}
-		return sb.toString();
-	}
-}

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

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

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

@@ -1,8 +1,7 @@
 package jadx.api;
 
-import java.util.Map;
-
 import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.metadata.ICodeMetadata;
 
 public interface ICodeInfo {
 
@@ -10,7 +9,7 @@ public interface ICodeInfo {
 
 	String getCodeStr();
 
-	Map<Integer, Integer> getLineMapping();
+	ICodeMetadata getCodeMetadata();
 
-	Map<CodePosition, Object> getAnnotations();
+	boolean hasMetadata();
 }

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

@@ -0,0 +1,70 @@
+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 {
+
+	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/JadxArgs.java

@@ -1,19 +1,50 @@
 package jadx.api;
 
+import java.io.Closeable;
 import java.io.File;
+import java.nio.file.Path;
 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 java.util.stream.Collectors;
 
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.args.GeneratedRenamesMappingFileMode;
+import jadx.api.args.IntegerFormat;
+import jadx.api.args.ResourceNameSource;
+import jadx.api.args.UserRenamesMappingsMode;
+import jadx.api.data.ICodeData;
+import jadx.api.deobf.IAliasProvider;
+import jadx.api.deobf.IRenameCondition;
+import jadx.api.impl.AnnotatedCodeWriter;
 import jadx.api.impl.InMemoryCodeCache;
+import jadx.api.plugins.loader.JadxBasePluginLoader;
+import jadx.api.plugins.loader.JadxPluginLoader;
+import jadx.api.usage.IUsageInfoCache;
+import jadx.api.usage.impl.InMemoryUsageInfoCache;
+import jadx.core.deobf.DeobfAliasProvider;
+import jadx.core.deobf.conditions.DeobfWhitelist;
+import jadx.core.deobf.conditions.JadxRenameConditions;
+import jadx.core.plugins.PluginContext;
+import jadx.core.utils.files.FileUtils;
 
-public class JadxArgs {
+public class JadxArgs implements Closeable {
+	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_NEW_LINE_STR = System.lineSeparator();
+	public static final String DEFAULT_INDENT_STR = "    ";
+
 	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";
@@ -26,17 +57,29 @@ public class JadxArgs {
 
 	private ICodeCache codeCache = new InMemoryCodeCache();
 
+	/**
+	 * Usage data cache. Saves use places of classes, methods and fields between code reloads.
+	 * Can be set to {@link jadx.api.usage.impl.EmptyUsageInfoCache} if code reload not needed.
+	 */
+	private IUsageInfoCache usageInfoCache = new InMemoryUsageInfoCache();
+
+	private Function<JadxArgs, ICodeWriter> codeWriterProvider = AnnotatedCodeWriter::new;
+
 	private int threadsCount = DEFAULT_THREADS_COUNT;
 
 	private boolean cfgOutput = false;
 	private boolean rawCFGOutput = false;
 
-	private boolean fallbackMode = false;
 	private boolean showInconsistentCode = false;
 
 	private boolean useImports = true;
 	private boolean debugInfo = true;
+	private boolean insertDebugLines = false;
+	private boolean extractFinally = true;
 	private boolean inlineAnonymousClasses = true;
+	private boolean inlineMethods = true;
+	private boolean allowInlineKotlinLambda = true;
+	private boolean moveInnerClasses = true;
 
 	private boolean skipResources = false;
 	private boolean skipSources = false;
@@ -46,19 +89,46 @@ public class JadxArgs {
 	 */
 	private Predicate<String> classFilter = null;
 
+	/**
+	 * Save dependencies for classes accepted by {@code classFilter}
+	 */
+	private boolean includeDependencies = false;
+
+	private Path userRenamesMappingsPath = null;
+	private UserRenamesMappingsMode userRenamesMappingsMode = UserRenamesMappingsMode.getDefault();
+
 	private boolean deobfuscationOn = false;
-	private boolean deobfuscationForceSave = false;
 	private boolean useSourceNameAsClassAlias = false;
-	private boolean parseKotlinMetadata = false;
+
+	private File generatedRenamesMappingFile = null;
+	private GeneratedRenamesMappingFileMode generatedRenamesMappingFileMode = GeneratedRenamesMappingFileMode.getDefault();
+	private ResourceNameSource resourceNameSource = ResourceNameSource.AUTO;
 
 	private int deobfuscationMinLength = 0;
 	private int deobfuscationMaxLength = Integer.MAX_VALUE;
 
+	/**
+	 * List of classes and packages (ends with '.*') to exclude from deobfuscation
+	 */
+	private List<String> deobfuscationWhitelist = new ArrayList<>(DeobfWhitelist.DEFAULT_LIST);
+
+	/**
+	 * Nodes alias provider for deobfuscator and rename visitor
+	 */
+	private IAliasProvider aliasProvider = new DeobfAliasProvider();
+
+	/**
+	 * Condition to rename node in deobfuscator
+	 */
+	private IRenameCondition renameCondition = JadxRenameConditions.buildDefault();
+
 	private boolean escapeUnicode = false;
 	private boolean replaceConsts = true;
 	private boolean respectBytecodeAccModifiers = false;
 	private boolean exportAsGradleProject = false;
 
+	private boolean skipXmlPrettyPrint = false;
+
 	private boolean fsCaseSensitive;
 
 	public enum RenameEnum {
@@ -73,6 +143,37 @@ public class JadxArgs {
 
 	private OutputFormatEnum outputFormat = OutputFormatEnum.JAVA;
 
+	private DecompilationMode decompilationMode = DecompilationMode.AUTO;
+
+	private ICodeData codeData;
+
+	private String codeNewLineStr = DEFAULT_NEW_LINE_STR;
+
+	private String codeIndentStr = DEFAULT_INDENT_STR;
+
+	private CommentsLevel commentsLevel = CommentsLevel.INFO;
+
+	private IntegerFormat integerFormat = IntegerFormat.AUTO;
+
+	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<>();
+
+	private JadxPluginLoader pluginLoader = new JadxBasePluginLoader();
+
+	private boolean loadJadxClsSetFile = true;
+
 	public JadxArgs() {
 		// use default options
 	}
@@ -83,6 +184,27 @@ public class JadxArgs {
 		setOutDirRes(new File(rootDir, DEFAULT_RES_DIR));
 	}
 
+	@Override
+	public void close() {
+		try {
+			inputFiles = null;
+			if (codeCache != null) {
+				codeCache.close();
+			}
+			if (usageInfoCache != null) {
+				usageInfoCache.close();
+			}
+			if (pluginLoader != null) {
+				pluginLoader.close();
+			}
+		} catch (Exception e) {
+			LOG.error("Failed to close JadxArgs", e);
+		} finally {
+			codeCache = null;
+			usageInfoCache = null;
+		}
+	}
+
 	public List<File> getInputFiles() {
 		return inputFiles;
 	}
@@ -124,7 +246,7 @@ public class JadxArgs {
 	}
 
 	public void setThreadsCount(int threadsCount) {
-		this.threadsCount = threadsCount;
+		this.threadsCount = Math.max(1, threadsCount); // make sure threadsCount >= 1
 	}
 
 	public boolean isCfgOutput() {
@@ -144,11 +266,17 @@ public class JadxArgs {
 	}
 
 	public boolean isFallbackMode() {
-		return fallbackMode;
+		return decompilationMode == DecompilationMode.FALLBACK;
 	}
 
+	/**
+	 * Deprecated: use 'decompilation mode' property
+	 */
+	@Deprecated
 	public void setFallbackMode(boolean fallbackMode) {
-		this.fallbackMode = fallbackMode;
+		if (fallbackMode) {
+			this.decompilationMode = DecompilationMode.FALLBACK;
+		}
 	}
 
 	public boolean isShowInconsistentCode() {
@@ -175,6 +303,14 @@ public class JadxArgs {
 		this.debugInfo = debugInfo;
 	}
 
+	public boolean isInsertDebugLines() {
+		return insertDebugLines;
+	}
+
+	public void setInsertDebugLines(boolean insertDebugLines) {
+		this.insertDebugLines = insertDebugLines;
+	}
+
 	public boolean isInlineAnonymousClasses() {
 		return inlineAnonymousClasses;
 	}
@@ -183,6 +319,38 @@ public class JadxArgs {
 		this.inlineAnonymousClasses = inlineAnonymousClasses;
 	}
 
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public void setInlineMethods(boolean inlineMethods) {
+		this.inlineMethods = inlineMethods;
+	}
+
+	public boolean isAllowInlineKotlinLambda() {
+		return allowInlineKotlinLambda;
+	}
+
+	public void setAllowInlineKotlinLambda(boolean allowInlineKotlinLambda) {
+		this.allowInlineKotlinLambda = allowInlineKotlinLambda;
+	}
+
+	public boolean isMoveInnerClasses() {
+		return moveInnerClasses;
+	}
+
+	public void setMoveInnerClasses(boolean moveInnerClasses) {
+		this.moveInnerClasses = moveInnerClasses;
+	}
+
+	public boolean isExtractFinally() {
+		return extractFinally;
+	}
+
+	public void setExtractFinally(boolean extractFinally) {
+		this.extractFinally = extractFinally;
+	}
+
 	public boolean isSkipResources() {
 		return skipResources;
 	}
@@ -199,6 +367,14 @@ public class JadxArgs {
 		this.skipSources = skipSources;
 	}
 
+	public void setIncludeDependencies(boolean includeDependencies) {
+		this.includeDependencies = includeDependencies;
+	}
+
+	public boolean isIncludeDependencies() {
+		return includeDependencies;
+	}
+
 	public Predicate<String> getClassFilter() {
 		return classFilter;
 	}
@@ -207,6 +383,22 @@ public class JadxArgs {
 		this.classFilter = classFilter;
 	}
 
+	public Path getUserRenamesMappingsPath() {
+		return userRenamesMappingsPath;
+	}
+
+	public void setUserRenamesMappingsPath(Path path) {
+		this.userRenamesMappingsPath = path;
+	}
+
+	public UserRenamesMappingsMode getUserRenamesMappingsMode() {
+		return userRenamesMappingsMode;
+	}
+
+	public void setUserRenamesMappingsMode(UserRenamesMappingsMode mode) {
+		this.userRenamesMappingsMode = mode;
+	}
+
 	public boolean isDeobfuscationOn() {
 		return deobfuscationOn;
 	}
@@ -216,11 +408,21 @@ public class JadxArgs {
 	}
 
 	public boolean isDeobfuscationForceSave() {
-		return deobfuscationForceSave;
+		return generatedRenamesMappingFileMode == GeneratedRenamesMappingFileMode.OVERWRITE;
 	}
 
 	public void setDeobfuscationForceSave(boolean deobfuscationForceSave) {
-		this.deobfuscationForceSave = deobfuscationForceSave;
+		if (deobfuscationForceSave) {
+			this.generatedRenamesMappingFileMode = GeneratedRenamesMappingFileMode.OVERWRITE;
+		}
+	}
+
+	public GeneratedRenamesMappingFileMode getGeneratedRenamesMappingFileMode() {
+		return generatedRenamesMappingFileMode;
+	}
+
+	public void setGeneratedRenamesMappingFileMode(GeneratedRenamesMappingFileMode mode) {
+		this.generatedRenamesMappingFileMode = mode;
 	}
 
 	public boolean isUseSourceNameAsClassAlias() {
@@ -231,14 +433,6 @@ public class JadxArgs {
 		this.useSourceNameAsClassAlias = useSourceNameAsClassAlias;
 	}
 
-	public boolean isParseKotlinMetadata() {
-		return parseKotlinMetadata;
-	}
-
-	public void setParseKotlinMetadata(boolean parseKotlinMetadata) {
-		this.parseKotlinMetadata = parseKotlinMetadata;
-	}
-
 	public int getDeobfuscationMinLength() {
 		return deobfuscationMinLength;
 	}
@@ -255,6 +449,46 @@ public class JadxArgs {
 		this.deobfuscationMaxLength = deobfuscationMaxLength;
 	}
 
+	public List<String> getDeobfuscationWhitelist() {
+		return this.deobfuscationWhitelist;
+	}
+
+	public void setDeobfuscationWhitelist(List<String> deobfuscationWhitelist) {
+		this.deobfuscationWhitelist = deobfuscationWhitelist;
+	}
+
+	public File getGeneratedRenamesMappingFile() {
+		return generatedRenamesMappingFile;
+	}
+
+	public void setGeneratedRenamesMappingFile(File file) {
+		this.generatedRenamesMappingFile = file;
+	}
+
+	public ResourceNameSource getResourceNameSource() {
+		return resourceNameSource;
+	}
+
+	public void setResourceNameSource(ResourceNameSource resourceNameSource) {
+		this.resourceNameSource = resourceNameSource;
+	}
+
+	public IAliasProvider getAliasProvider() {
+		return aliasProvider;
+	}
+
+	public void setAliasProvider(IAliasProvider aliasProvider) {
+		this.aliasProvider = aliasProvider;
+	}
+
+	public IRenameCondition getRenameCondition() {
+		return renameCondition;
+	}
+
+	public void setRenameCondition(IRenameCondition renameCondition) {
+		this.renameCondition = renameCondition;
+	}
+
 	public boolean isEscapeUnicode() {
 		return escapeUnicode;
 	}
@@ -287,6 +521,14 @@ public class JadxArgs {
 		this.exportAsGradleProject = exportAsGradleProject;
 	}
 
+	public boolean isSkipXmlPrettyPrint() {
+		return skipXmlPrettyPrint;
+	}
+
+	public void setSkipXmlPrettyPrint(boolean skipXmlPrettyPrint) {
+		this.skipXmlPrettyPrint = skipXmlPrettyPrint;
+	}
+
 	public boolean isFsCaseSensitive() {
 		return fsCaseSensitive;
 	}
@@ -347,6 +589,14 @@ public class JadxArgs {
 		this.outputFormat = outputFormat;
 	}
 
+	public DecompilationMode getDecompilationMode() {
+		return decompilationMode;
+	}
+
+	public void setDecompilationMode(DecompilationMode decompilationMode) {
+		this.decompilationMode = decompilationMode;
+	}
+
 	public ICodeCache getCodeCache() {
 		return codeCache;
 	}
@@ -355,6 +605,137 @@ public class JadxArgs {
 		this.codeCache = codeCache;
 	}
 
+	public Function<JadxArgs, ICodeWriter> getCodeWriterProvider() {
+		return codeWriterProvider;
+	}
+
+	public void setCodeWriterProvider(Function<JadxArgs, ICodeWriter> codeWriterProvider) {
+		this.codeWriterProvider = codeWriterProvider;
+	}
+
+	public IUsageInfoCache getUsageInfoCache() {
+		return usageInfoCache;
+	}
+
+	public void setUsageInfoCache(IUsageInfoCache usageInfoCache) {
+		this.usageInfoCache = usageInfoCache;
+	}
+
+	public ICodeData getCodeData() {
+		return codeData;
+	}
+
+	public void setCodeData(ICodeData codeData) {
+		this.codeData = codeData;
+	}
+
+	public String getCodeIndentStr() {
+		return codeIndentStr;
+	}
+
+	public void setCodeIndentStr(String codeIndentStr) {
+		this.codeIndentStr = codeIndentStr;
+	}
+
+	public String getCodeNewLineStr() {
+		return codeNewLineStr;
+	}
+
+	public void setCodeNewLineStr(String codeNewLineStr) {
+		this.codeNewLineStr = codeNewLineStr;
+	}
+
+	public CommentsLevel getCommentsLevel() {
+		return commentsLevel;
+	}
+
+	public void setCommentsLevel(CommentsLevel commentsLevel) {
+		this.commentsLevel = commentsLevel;
+	}
+
+	public IntegerFormat getIntegerFormat() {
+		return integerFormat;
+	}
+
+	public void setIntegerFormat(IntegerFormat format) {
+		this.integerFormat = format;
+	}
+
+	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;
+	}
+
+	public JadxPluginLoader getPluginLoader() {
+		return pluginLoader;
+	}
+
+	public void setPluginLoader(JadxPluginLoader pluginLoader) {
+		this.pluginLoader = pluginLoader;
+	}
+
+	public boolean isLoadJadxClsSetFile() {
+		return loadJadxClsSetFile;
+	}
+
+	public void setLoadJadxClsSetFile(boolean loadJadxClsSetFile) {
+		this.loadJadxClsSetFile = loadJadxClsSetFile;
+	}
+
+	/**
+	 * Hash of all options that can change result code
+	 */
+	public String makeCodeArgsHash(@Nullable JadxDecompiler decompiler) {
+		String argStr = "args:" + decompilationMode + useImports + showInconsistentCode
+				+ inlineAnonymousClasses + inlineMethods + moveInnerClasses + allowInlineKotlinLambda
+				+ deobfuscationOn + deobfuscationMinLength + deobfuscationMaxLength + deobfuscationWhitelist
+				+ resourceNameSource
+				+ useKotlinMethodsForVarNames
+				+ insertDebugLines + extractFinally
+				+ debugInfo + useSourceNameAsClassAlias + escapeUnicode + replaceConsts
+				+ respectBytecodeAccModifiers + fsCaseSensitive + renameFlags
+				+ commentsLevel + useDxInput + integerFormat
+				+ "|" + buildPluginsHash(decompiler);
+		return FileUtils.md5Sum(argStr);
+	}
+
+	private static String buildPluginsHash(@Nullable JadxDecompiler decompiler) {
+		if (decompiler == null) {
+			return "";
+		}
+		return decompiler.getPluginManager().getResolvedPluginContexts()
+				.stream()
+				.map(PluginContext::getInputsHash)
+				.collect(Collectors.joining(":"));
+	}
+
 	@Override
 	public String toString() {
 		return "JadxArgs{" + "inputFiles=" + inputFiles
@@ -362,27 +743,40 @@ public class JadxArgs {
 				+ ", outDirSrc=" + outDirSrc
 				+ ", outDirRes=" + outDirRes
 				+ ", threadsCount=" + threadsCount
-				+ ", cfgOutput=" + cfgOutput
-				+ ", rawCFGOutput=" + rawCFGOutput
-				+ ", fallbackMode=" + fallbackMode
+				+ ", decompilationMode=" + decompilationMode
 				+ ", showInconsistentCode=" + showInconsistentCode
 				+ ", useImports=" + useImports
 				+ ", skipResources=" + skipResources
 				+ ", skipSources=" + skipSources
+				+ ", includeDependencies=" + includeDependencies
+				+ ", userRenamesMappingsPath=" + userRenamesMappingsPath
+				+ ", userRenamesMappingsMode=" + userRenamesMappingsMode
 				+ ", deobfuscationOn=" + deobfuscationOn
-				+ ", deobfuscationForceSave=" + deobfuscationForceSave
+				+ ", generatedRenamesMappingFile=" + generatedRenamesMappingFile
+				+ ", generatedRenamesMappingFileMode=" + generatedRenamesMappingFileMode
+				+ ", resourceNameSource=" + resourceNameSource
 				+ ", useSourceNameAsClassAlias=" + useSourceNameAsClassAlias
-				+ ", parseKotlinMetadata=" + parseKotlinMetadata
+				+ ", useKotlinMethodsForVarNames=" + useKotlinMethodsForVarNames
+				+ ", insertDebugLines=" + insertDebugLines
+				+ ", extractFinally=" + extractFinally
 				+ ", deobfuscationMinLength=" + deobfuscationMinLength
 				+ ", deobfuscationMaxLength=" + deobfuscationMaxLength
+				+ ", deobfuscationWhitelist=" + deobfuscationWhitelist
 				+ ", escapeUnicode=" + escapeUnicode
 				+ ", replaceConsts=" + replaceConsts
 				+ ", respectBytecodeAccModifiers=" + respectBytecodeAccModifiers
 				+ ", exportAsGradleProject=" + exportAsGradleProject
+				+ ", skipXmlPrettyPrint=" + skipXmlPrettyPrint
 				+ ", 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

@@ -13,8 +13,9 @@ public class JadxArgsValidator {
 
 	private static final Logger LOG = LoggerFactory.getLogger(JadxArgsValidator.class);
 
-	public static void validate(JadxArgs args) {
-		checkInputFiles(args);
+	public static void validate(JadxDecompiler jadx) {
+		JadxArgs args = jadx.getArgs();
+		checkInputFiles(jadx, args);
 		validateOutDirs(args);
 
 		if (LOG.isDebugEnabled()) {
@@ -22,17 +23,11 @@ public class JadxArgsValidator {
 		}
 	}
 
-	private static void checkInputFiles(JadxArgs args) {
+	private static void checkInputFiles(JadxDecompiler jadx, JadxArgs args) {
 		List<File> inputFiles = args.getInputFiles();
-		if (inputFiles.isEmpty()) {
+		if (inputFiles.isEmpty() && jadx.getCustomCodeLoaders().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);
 		}
@@ -66,28 +61,28 @@ public class JadxArgsValidator {
 
 	@NotNull
 	private static File makeDirFromInput(JadxArgs args) {
-		File outDir;
 		String outDirName;
-		File file = args.getInputFiles().get(0);
-		String name = file.getName();
-		int pos = name.lastIndexOf('.');
-		if (pos != -1) {
-			outDirName = name.substring(0, pos);
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty()) {
+			outDirName = JadxArgs.DEFAULT_OUT_DIR;
 		} else {
-			outDirName = name + '-' + JadxArgs.DEFAULT_OUT_DIR;
+			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);
-		outDir = new File(outDirName);
-		return outDir;
+		return new File(outDirName);
 	}
 
 	private static void checkFile(File file) {
 		if (!file.exists()) {
 			throw new JadxArgsValidateException("File not found " + file.getAbsolutePath());
 		}
-		if (file.isDirectory()) {
-			throw new JadxArgsValidateException("Expected file but found directory instead: " + file.getAbsolutePath());
-		}
 	}
 
 	private static void checkDir(File dir, String desc) {

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

@@ -6,38 +6,51 @@ 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.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.CustomResourcesLoader;
 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.events.IJadxEvents;
+import jadx.api.plugins.input.ICodeLoader;
+import jadx.api.plugins.input.JadxCodeInput;
+import jadx.api.plugins.pass.JadxPass;
+import jadx.api.plugins.pass.types.JadxAfterLoadPass;
+import jadx.api.plugins.pass.types.JadxPassType;
+import jadx.api.utils.tasks.ITaskExecutor;
 import jadx.core.Jadx;
 import jadx.core.dex.attributes.AFlag;
-import jadx.core.dex.attributes.nodes.LineAttrNode;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.PackageNode;
 import jadx.core.dex.nodes.RootNode;
 import jadx.core.dex.visitors.SaveCode;
-import jadx.core.export.ExportGradleProject;
+import jadx.core.export.ExportGradleTask;
+import jadx.core.plugins.JadxPluginManager;
+import jadx.core.plugins.PluginContext;
+import jadx.core.plugins.events.JadxEventsImpl;
+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.utils.tasks.TaskExecutor;
 import jadx.core.xmlgen.BinaryXMLParser;
 import jadx.core.xmlgen.ResourcesSaver;
 
@@ -46,6 +59,7 @@ import jadx.core.xmlgen.ResourcesSaver;
  *
  * <pre>
  * <code>
+ *
  * JadxArgs args = new JadxArgs();
  * args.getInputFiles().add(new File("test.apk"));
  * args.setOutDir(new File("jadx-test-output"));
@@ -60,6 +74,7 @@ import jadx.core.xmlgen.ResourcesSaver;
  *
  * <pre>
  * <code>
+ *
  *  for(JavaClass cls : jadx.getClasses()) {
  *      System.out.println(cls.getCode());
  *  }
@@ -70,18 +85,22 @@ public final class JadxDecompiler implements Closeable {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxDecompiler.class);
 
 	private final JadxArgs args;
-	private final JadxPluginManager pluginManager = new JadxPluginManager();
-	private final List<ILoadResult> loadedInputs = new ArrayList<>();
+	private final JadxPluginManager pluginManager = new JadxPluginManager(this);
+	private final List<ICodeLoader> loadedInputs = new ArrayList<>();
 
 	private RootNode root;
 	private List<JavaClass> classes;
 	private List<ResourceFile> resources;
 
-	private BinaryXMLParser xmlParser;
+	private BinaryXMLParser binaryXmlParser;
 
-	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 JadxEventsImpl events = new JadxEventsImpl();
+	private final ResourcesLoader resourcesLoader = new ResourcesLoader(this);
+
+	private final List<ICodeLoader> customCodeLoaders = new ArrayList<>();
+	private final List<CustomResourcesLoader> customResourcesLoaders = new ArrayList<>();
+	private final Map<JadxPassType, List<JadxPass>> customPasses = new HashMap<>();
 
 	public JadxDecompiler() {
 		this(new JadxArgs());
@@ -93,40 +112,71 @@ public final class JadxDecompiler implements Closeable {
 
 	public void load() {
 		reset();
-		JadxArgsValidator.validate(args);
+		JadxArgsValidator.validate(this);
 		LOG.info("loading ...");
+		loadPlugins();
 		loadInputFiles();
 
 		root = new RootNode(args);
+		root.setDecompilerRef(this);
+		root.mergePasses(customPasses);
 		root.loadClasses(loadedInputs);
 		root.initClassPath();
-		root.loadResources(getResources());
+		root.loadResources(resourcesLoader, getResources());
 		root.runPreDecompileStage();
 		root.initPasses();
+		loadFinished();
+	}
+
+	public void reloadPasses() {
+		LOG.info("reloading (passes only) ...");
+		customPasses.clear();
+		root.resetPasses();
+		events.reset();
+		loadPlugins();
+		root.mergePasses(customPasses);
+		root.restartVisitors();
+		root.initPasses();
+		loadFinished();
 	}
 
 	private void loadInputFiles() {
 		loadedInputs.clear();
 		List<Path> inputPaths = Utils.collectionMap(args.getInputFiles(), File::toPath);
-		for (JadxInputPlugin inputPlugin : pluginManager.getInputPlugins()) {
-			ILoadResult loadResult = inputPlugin.loadFiles(inputPaths);
-			if (loadResult != null && !loadResult.isEmpty()) {
-				loadedInputs.add(loadResult);
+		List<Path> inputFiles = FileUtils.expandDirs(inputPaths);
+		long start = System.currentTimeMillis();
+		for (PluginContext plugin : pluginManager.getResolvedPluginContexts()) {
+			for (JadxCodeInput codeLoader : plugin.getCodeInputs()) {
+				try {
+					ICodeLoader loader = codeLoader.loadFiles(inputFiles);
+					if (loader != null && !loader.isEmpty()) {
+						loadedInputs.add(loader);
+					}
+				} catch (Exception e) {
+					throw new JadxRuntimeException("Failed to load code for plugin: " + plugin, e);
+				}
 			}
 		}
+		loadedInputs.addAll(customCodeLoaders);
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Loaded using {} inputs plugin in {} ms", loadedInputs.size(), System.currentTimeMillis() - start);
+		}
 	}
 
 	private void reset() {
 		root = null;
 		classes = null;
 		resources = null;
-		xmlParser = null;
-
-		classesMap.clear();
-		methodsMap.clear();
-		fieldsMap.clear();
+		binaryXmlParser = null;
+		events.reset();
+	}
 
+	@Override
+	public void close() {
+		reset();
 		closeInputs();
+		closeLoaders();
+		args.close();
 	}
 
 	private void closeInputs() {
@@ -140,11 +190,42 @@ public final class JadxDecompiler implements Closeable {
 		loadedInputs.clear();
 	}
 
-	@Override
-	public void close() {
-		reset();
+	private void closeLoaders() {
+		for (CustomResourcesLoader resourcesLoader : customResourcesLoaders) {
+			try {
+				resourcesLoader.close();
+			} catch (Exception e) {
+				LOG.error("Failed to close resource loader: " + resourcesLoader, e);
+			}
+		}
+		customResourcesLoaders.clear();
 	}
 
+	private void loadPlugins() {
+		pluginManager.providesSuggestion("java-input", args.isUseDxInput() ? "java-convert" : "java-input");
+		pluginManager.load(args.getPluginLoader());
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Resolved plugins: {}", pluginManager.getResolvedPluginContexts());
+		}
+		pluginManager.initResolved();
+		if (LOG.isDebugEnabled()) {
+			List<String> passes = customPasses.values().stream().flatMap(Collection::stream)
+					.map(p -> p.getInfo().getName()).collect(Collectors.toList());
+			LOG.debug("Loaded custom passes: {} {}", passes.size(), passes);
+		}
+	}
+
+	private void loadFinished() {
+		LOG.debug("Load finished");
+		List<JadxPass> list = customPasses.get(JadxAfterLoadPass.TYPE);
+		if (list != null) {
+			for (JadxPass pass : list) {
+				((JadxAfterLoadPass) pass).init(this);
+			}
+		}
+	}
+
+	@SuppressWarnings("unused")
 	public void registerPlugin(JadxPlugin plugin) {
 		pluginManager.register(plugin);
 	}
@@ -157,6 +238,26 @@ public final class JadxDecompiler implements Closeable {
 		save(!args.isSkipSources(), !args.isSkipResources());
 	}
 
+	public interface ProgressListener {
+		void progress(long done, long total);
+	}
+
+	@SuppressWarnings("BusyWait")
+	public void save(int intervalInMillis, ProgressListener listener) {
+		try {
+			ITaskExecutor tasks = getSaveTaskExecutor();
+			tasks.execute();
+			long total = tasks.getTasksCount();
+			while (tasks.isRunning()) {
+				listener.progress(tasks.getProgress(), total);
+				Thread.sleep(intervalInMillis);
+			}
+		} catch (InterruptedException e) {
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
+		}
+	}
+
 	public void saveSources() {
 		save(true, false);
 	}
@@ -166,80 +267,135 @@ public final class JadxDecompiler implements Closeable {
 	}
 
 	private void save(boolean saveSources, boolean saveResources) {
-		ExecutorService ex = getSaveExecutor(saveSources, saveResources);
-		ex.shutdown();
-		try {
-			ex.awaitTermination(1, TimeUnit.DAYS);
-		} catch (InterruptedException e) {
-			LOG.error("Save interrupted", e);
-			Thread.currentThread().interrupt();
-		}
+		ITaskExecutor executor = getSaveTasks(saveSources, saveResources);
+		executor.execute();
+		executor.awaitTermination();
 	}
 
+	public ITaskExecutor getSaveTaskExecutor() {
+		return getSaveTasks(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	@Deprecated(forRemoval = true)
 	public ExecutorService getSaveExecutor() {
-		return getSaveExecutor(!args.isSkipSources(), !args.isSkipResources());
+		ITaskExecutor executor = getSaveTaskExecutor();
+		executor.execute();
+		return executor.getInternalExecutor();
 	}
 
-	private ExecutorService getSaveExecutor(boolean saveSources, boolean saveResources) {
+	@Deprecated(forRemoval = true)
+	public List<Runnable> getSaveTasks() {
+		return Collections.singletonList(this::save);
+	}
+
+	private TaskExecutor getSaveTasks(boolean saveSources, boolean saveResources) {
 		if (root == null) {
 			throw new JadxRuntimeException("No loaded files");
 		}
-		int threadsCount = args.getThreadsCount();
-		LOG.debug("processing threads count: {}", threadsCount);
-
-		LOG.info("processing ...");
-		ExecutorService executor = Executors.newFixedThreadPool(threadsCount);
-
 		File sourcesOutDir;
 		File resOutDir;
+		ExportGradleTask gradleExportTask;
 		if (args.isExportAsGradleProject()) {
-			ExportGradleProject export = new ExportGradleProject(root, args.getOutDir());
-			export.init();
-			sourcesOutDir = export.getSrcOutDir();
-			resOutDir = export.getResOutDir();
+			gradleExportTask = new ExportGradleTask(resources, root, args.getOutDir());
+			gradleExportTask.init();
+			sourcesOutDir = gradleExportTask.getSrcOutDir();
+			resOutDir = gradleExportTask.getResOutDir();
 		} else {
 			sourcesOutDir = args.getOutDirSrc();
 			resOutDir = args.getOutDirRes();
+			gradleExportTask = null;
 		}
+
+		TaskExecutor executor = new TaskExecutor();
+		executor.setThreadsCount(args.getThreadsCount());
 		if (saveResources) {
-			appendResourcesSave(executor, resOutDir);
+			// save resources first because decompilation can stop or fail
+			appendResourcesSaveTasks(executor, resOutDir);
 		}
 		if (saveSources) {
 			appendSourcesSave(executor, sourcesOutDir);
 		}
+		if (gradleExportTask != null) {
+			executor.addSequentialTask(gradleExportTask);
+		}
 		return executor;
 	}
 
-	private void appendResourcesSave(ExecutorService executor, File outDir) {
-		Set<String> inputFileNames = args.getInputFiles().stream().map(File::getAbsolutePath).collect(Collectors.toSet());
+	private void appendResourcesSaveTasks(ITaskExecutor executor, File outDir) {
+		if (args.isSkipFilesSave()) {
+			return;
+		}
+		// process AndroidManifest.xml first to load complete resource ids table
 		for (ResourceFile resourceFile : getResources()) {
-			if (resourceFile.getType() != ResourceType.ARSC
+			if (resourceFile.getType() == ResourceType.MANIFEST) {
+				new ResourcesSaver(outDir, resourceFile).run();
+				break;
+			}
+		}
+		Set<String> inputFileNames = args.getInputFiles().stream()
+				.map(File::getAbsolutePath)
+				.collect(Collectors.toSet());
+		List<Runnable> tasks = new ArrayList<>();
+		for (ResourceFile resourceFile : getResources()) {
+			ResourceType resType = resourceFile.getType();
+			if (resType == ResourceType.MANIFEST) {
+				// already processed
+				continue;
+			}
+			if (resType != ResourceType.ARSC
 					&& inputFileNames.contains(resourceFile.getOriginalName())) {
 				// ignore resource made from input file
 				continue;
 			}
-			executor.execute(new ResourcesSaver(outDir, resourceFile));
+			tasks.add(new ResourcesSaver(outDir, resourceFile));
 		}
+		executor.addParallelTasks(tasks);
 	}
 
-	private void appendSourcesSave(ExecutorService executor, File outDir) {
-		Predicate<String> classFilter = args.getClassFilter();
-		for (JavaClass cls : getClasses()) {
-			if (cls.getClassNode().contains(AFlag.DONT_GENERATE)) {
-				continue;
-			}
-			if (classFilter != null && !classFilter.test(cls.getFullName())) {
-				continue;
-			}
-			executor.execute(() -> {
-				try {
-					ICodeInfo code = cls.getCodeInfo();
-					SaveCode.save(outDir, cls.getClassNode(), code);
-				} catch (Exception e) {
-					LOG.error("Error saving class: {}", cls.getFullName(), e);
+	private void appendSourcesSave(ITaskExecutor executor, File outDir) {
+		List<JavaClass> classes = getClasses();
+		List<JavaClass> processQueue = filterClasses(classes);
+		List<List<JavaClass>> batches;
+		try {
+			batches = decompileScheduler.buildBatches(processQueue);
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Decompilation batches build failed", e);
+		}
+		List<Runnable> decompileTasks = new ArrayList<>(batches.size());
+		for (List<JavaClass> decompileBatch : batches) {
+			decompileTasks.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);
+					}
 				}
+
 			});
 		}
+		executor.addParallelTasks(decompileTasks);
+	}
+
+	private List<JavaClass> filterClasses(List<JavaClass> classes) {
+		Predicate<String> classFilter = args.getClassFilter();
+		List<JavaClass> list = 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;
+			}
+			list.add(cls);
+		}
+		return list;
 	}
 
 	public List<JavaClass> getClasses() {
@@ -247,14 +403,14 @@ public final class JadxDecompiler implements Closeable {
 			return Collections.emptyList();
 		}
 		if (classes == null) {
-			List<ClassNode> classNodeList = root.getClasses(false);
+			List<ClassNode> classNodeList = root.getClasses();
 			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
-			classesMap.clear();
 			for (ClassNode classNode : classNodeList) {
-				if (!classNode.contains(AFlag.DONT_GENERATE)) {
-					JavaClass javaClass = new JavaClass(classNode, this);
-					clsList.add(javaClass);
-					classesMap.put(classNode, javaClass);
+				if (classNode.contains(AFlag.DONT_GENERATE)) {
+					continue;
+				}
+				if (!classNode.getClassInfo().isInner()) {
+					clsList.add(convertClassNode(classNode));
 				}
 			}
 			classes = Collections.unmodifiableList(clsList);
@@ -262,36 +418,22 @@ public final class JadxDecompiler implements Closeable {
 		return classes;
 	}
 
-	public List<ResourceFile> getResources() {
+	public List<JavaClass> getClassesWithInners() {
+		return Utils.collectionMap(root.getClasses(), this::convertClassNode);
+	}
+
+	public synchronized List<ResourceFile> getResources() {
 		if (resources == null) {
 			if (root == null) {
 				return Collections.emptyList();
 			}
-			resources = new ResourcesLoader(this).load();
+			resources = resourcesLoader.load(root);
 		}
 		return resources;
 	}
 
 	public List<JavaPackage> getPackages() {
-		List<JavaClass> classList = getClasses();
-		if (classList.isEmpty()) {
-			return Collections.emptyList();
-		}
-		Map<String, List<JavaClass>> map = new HashMap<>();
-		for (JavaClass javaClass : classList) {
-			String pkg = javaClass.getPackage();
-			List<JavaClass> clsList = map.computeIfAbsent(pkg, k -> new ArrayList<>());
-			clsList.add(javaClass);
-		}
-		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) {
-			pkg.getClasses().sort(Comparator.comparing(JavaClass::getName, String.CASE_INSENSITIVE_ORDER));
-		}
-		return Collections.unmodifiableList(packages);
+		return Utils.collectionMap(root.getPackages(), this::convertPackageNode);
 	}
 
 	public int getErrorsCount() {
@@ -319,157 +461,243 @@ public final class JadxDecompiler implements Closeable {
 	/**
 	 * Internal API. Not Stable!
 	 */
+	@ApiStatus.Internal
 	public RootNode getRoot() {
 		return root;
 	}
 
-	synchronized BinaryXMLParser getXmlParser() {
-		if (xmlParser == null) {
-			xmlParser = new BinaryXMLParser(root);
+	synchronized BinaryXMLParser getBinaryXmlParser() {
+		if (binaryXmlParser == null) {
+			binaryXmlParser = new BinaryXMLParser(root);
 		}
-		return xmlParser;
+		return binaryXmlParser;
 	}
 
-	private void loadJavaClass(JavaClass javaClass) {
-		javaClass.getMethods().forEach(mth -> methodsMap.put(mth.getMethodNode(), mth));
-		javaClass.getFields().forEach(fld -> fieldsMap.put(fld.getFieldNode(), fld));
-
-		for (JavaClass innerCls : javaClass.getInnerClasses()) {
-			classesMap.put(innerCls.getClassNode(), innerCls);
-			loadJavaClass(innerCls);
+	/**
+	 * Get JavaClass by ClassNode without loading and decompilation
+	 */
+	@ApiStatus.Internal
+	synchronized JavaClass convertClassNode(ClassNode cls) {
+		JavaClass javaClass = cls.getJavaNode();
+		if (javaClass == null) {
+			javaClass = cls.isInner()
+					? new JavaClass(cls, convertClassNode(cls.getParentClass()))
+					: new JavaClass(cls, this);
+			cls.setJavaNode(javaClass);
 		}
+		return javaClass;
 	}
 
-	@Nullable("For not generated classes")
-	private JavaClass getJavaClassByNode(ClassNode cls) {
-		JavaClass javaClass = classesMap.get(cls);
-		if (javaClass != null) {
-			return javaClass;
+	@ApiStatus.Internal
+	synchronized JavaField convertFieldNode(FieldNode fld) {
+		JavaField javaField = fld.getJavaNode();
+		if (javaField == null) {
+			JavaClass parentCls = convertClassNode(fld.getParentClass());
+			javaField = new JavaField(parentCls, fld);
+			fld.setJavaNode(javaField);
 		}
-		// load parent class if inner
-		ClassNode parentClass = cls.getTopParentClass();
-		if (parentClass.contains(AFlag.DONT_GENERATE)) {
-			return null;
+		return javaField;
+	}
+
+	@ApiStatus.Internal
+	synchronized JavaMethod convertMethodNode(MethodNode mth) {
+		JavaMethod javaMethod = mth.getJavaNode();
+		if (javaMethod == null) {
+			javaMethod = new JavaMethod(convertClassNode(mth.getParentClass()), mth);
+			mth.setJavaNode(javaMethod);
 		}
-		if (parentClass != cls) {
-			JavaClass parentJavaClass = classesMap.get(parentClass);
-			if (parentJavaClass == null) {
-				getClasses();
-				parentJavaClass = classesMap.get(parentClass);
-			}
-			loadJavaClass(parentJavaClass);
-			javaClass = classesMap.get(cls);
-			if (javaClass != null) {
-				return javaClass;
+		return javaMethod;
+	}
+
+	@ApiStatus.Internal
+	synchronized JavaPackage convertPackageNode(PackageNode pkg) {
+		JavaPackage foundPkg = pkg.getJavaNode();
+		if (foundPkg != null) {
+			return foundPkg;
+		}
+		List<JavaClass> clsList = Utils.collectionMap(pkg.getClasses(), this::convertClassNode);
+		int subPkgsCount = pkg.getSubPackages().size();
+		List<JavaPackage> subPkgs = subPkgsCount == 0 ? Collections.emptyList() : new ArrayList<>(subPkgsCount);
+		JavaPackage javaPkg = new JavaPackage(pkg, clsList, subPkgs);
+		if (subPkgsCount != 0) {
+			// add subpackages after parent to avoid endless recursion
+			for (PackageNode subPackage : pkg.getSubPackages()) {
+				subPkgs.add(convertPackageNode(subPackage));
 			}
 		}
-		// class or parent classes can be excluded from generation
-		if (cls.hasNotGeneratedParent()) {
-			return null;
-		}
-		throw new JadxRuntimeException("JavaClass not found by ClassNode: " + cls);
+		pkg.setJavaNode(javaPkg);
+		return javaPkg;
 	}
 
 	@Nullable
-	private JavaMethod getJavaMethodByNode(MethodNode mth) {
-		JavaMethod javaMethod = methodsMap.get(mth);
-		if (javaMethod != null) {
-			return javaMethod;
-		}
-		// parent class not loaded yet
-		JavaClass javaClass = getJavaClassByNode(mth.getParentClass().getTopParentClass());
-		if (javaClass == null) {
-			return null;
-		}
-		loadJavaClass(javaClass);
-		javaMethod = methodsMap.get(mth);
-		if (javaMethod != null) {
-			return javaMethod;
-		}
-		if (mth.getParentClass().hasNotGeneratedParent()) {
-			return null;
-		}
-		throw new JadxRuntimeException("JavaMethod not found by MethodNode: " + mth);
+	public JavaClass searchJavaClassByOrigFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.map(this::convertClassNode)
+				.orElse(null);
 	}
 
 	@Nullable
-	private JavaField getJavaFieldByNode(FieldNode fld) {
-		JavaField javaField = fieldsMap.get(fld);
-		if (javaField != null) {
-			return javaField;
+	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);
+			}
 		}
-		// parent class not loaded yet
-		JavaClass javaClass = getJavaClassByNode(fld.getParentClass().getTopParentClass());
-		if (javaClass == null) {
-			return null;
-		}
-		loadJavaClass(javaClass);
-		javaField = fieldsMap.get(fld);
-		if (javaField != null) {
-			return javaField;
-		}
-		if (fld.getParentClass().hasNotGeneratedParent()) {
-			return null;
-		}
-		throw new JadxRuntimeException("JavaField not found by FieldNode: " + fld);
+		return null;
 	}
 
 	@Nullable
-	JavaNode convertNode(Object obj) {
-		if (!(obj instanceof LineAttrNode)) {
-			return null;
-		}
-		LineAttrNode node = (LineAttrNode) obj;
-		if (node.contains(AFlag.DONT_GENERATE)) {
-			return null;
-		}
-		if (obj instanceof ClassNode) {
-			return getJavaClassByNode((ClassNode) obj);
-		}
-		if (obj instanceof MethodNode) {
-			return getJavaMethodByNode(((MethodNode) obj));
-		}
-		if (obj instanceof FieldNode) {
-			return getJavaFieldByNode((FieldNode) obj);
-		}
-		throw new JadxRuntimeException("Unexpected node type: " + obj);
+	public JavaClass searchJavaClassByAliasFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getAliasFullName().equals(fullName))
+				.findFirst()
+				.map(this::convertClassNode)
+				.orElse(null);
 	}
 
-	List<JavaNode> convertNodes(Collection<?> nodesList) {
+	@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());
+		}
+	}
+
+	private JavaVariable resolveVarNode(VarNode varNode) {
+		JavaMethod javaNode = convertMethodNode(varNode.getMth());
+		return new JavaVariable(javaNode, 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::convertNode)
+				.map(this::getJavaNodeByRef)
 				.filter(Objects::nonNull)
 				.collect(Collectors.toList());
 	}
 
 	@Nullable
-	public JavaNode getJavaNodeAtPosition(ICodeInfo codeInfo, int line, int offset) {
-		Map<CodePosition, Object> map = codeInfo.getAnnotations();
-		if (map.isEmpty()) {
-			return null;
-		}
-		Object obj = map.get(new CodePosition(line, offset));
-		if (obj == null) {
-			return null;
-		}
-		return convertNode(obj);
+	public JavaNode getJavaNodeAtPosition(ICodeInfo codeInfo, int pos) {
+		ICodeAnnotation ann = codeInfo.getCodeMetadata().getAt(pos);
+		return getJavaNodeByCodeAnnotation(codeInfo, ann);
 	}
 
 	@Nullable
-	public CodePosition getDefinitionPosition(JavaNode javaNode) {
-		JavaClass jCls = javaNode.getTopParentClass();
-		jCls.decompile();
-		int defLine = javaNode.getDecompiledLine();
-		if (defLine == 0) {
+	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 new CodePosition(jCls, defLine, 0);
+		return getJavaNodeByRef(obj);
+	}
+
+	public void reloadCodeData() {
+		root.notifyCodeDataListeners();
 	}
 
 	public JadxArgs getArgs() {
 		return args;
 	}
 
+	public JadxPluginManager getPluginManager() {
+		return pluginManager;
+	}
+
+	public IDecompileScheduler getDecompileScheduler() {
+		return decompileScheduler;
+	}
+
+	public IJadxEvents events() {
+		return events;
+	}
+
+	public void addCustomCodeLoader(ICodeLoader customCodeLoader) {
+		customCodeLoaders.add(customCodeLoader);
+	}
+
+	public List<ICodeLoader> getCustomCodeLoaders() {
+		return customCodeLoaders;
+	}
+
+	public void addCustomResourcesLoader(CustomResourcesLoader loader) {
+		if (customResourcesLoaders.contains(loader)) {
+			return;
+		}
+		customResourcesLoaders.add(loader);
+	}
+
+	public List<CustomResourcesLoader> getCustomResourcesLoaders() {
+		return customResourcesLoaders;
+	}
+
+	public void addCustomPass(JadxPass pass) {
+		customPasses.computeIfAbsent(pass.getPassType(), l -> new ArrayList<>()).add(pass);
+	}
+
+	public ResourcesLoader getResourcesLoader() {
+		return resourcesLoader;
+	}
+
 	@Override
 	public String toString() {
 		return "jadx decompiler " + getVersion();

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

@@ -7,21 +7,33 @@ 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;
@@ -42,69 +54,114 @@ public final class JavaClass implements JavaNode {
 	}
 
 	public String getCode() {
-		ICodeInfo code = getCodeInfo();
-		if (code == null) {
-			return "";
-		}
-		return code.getCodeStr();
+		return getCodeInfo().getCodeStr();
 	}
 
-	public ICodeInfo getCodeInfo() {
+	public @NotNull ICodeInfo getCodeInfo() {
+		ICodeInfo code = load();
+		if (code != null) {
+			return code;
+		}
 		return cls.decompile();
 	}
 
 	public void decompile() {
-		cls.decompile();
+		load();
 	}
 
-	public synchronized void reload() {
+	public synchronized ICodeInfo reload() {
 		listsLoaded = false;
-		cls.reloadCode();
+		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.getSmali();
+		return cls.getDisassembledCode();
 	}
 
-	public synchronized void unload() {
-		cls.unload();
-		listsLoaded = false;
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.CLASS) {
+			return ann.equals(cls);
+		}
+		return false;
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return cls;
 	}
 
 	/**
 	 * Internal API. Not Stable!
 	 */
+	@ApiStatus.Internal
 	public ClassNode getClassNode() {
 		return cls;
 	}
 
-	private synchronized void loadLists() {
+	/**
+	 * 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;
+			return null;
 		}
 		listsLoaded = true;
-		decompile();
 
+		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<>(inClsCount);
 			for (ClassNode inner : cls.getInnerClasses()) {
 				if (!inner.contains(AFlag.DONT_GENERATE)) {
-					JavaClass javaClass = new JavaClass(inner, this);
-					javaClass.loadLists();
+					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<>(fieldsCount);
 			for (FieldNode f : cls.getFields()) {
 				if (!f.contains(AFlag.DONT_GENERATE)) {
-					JavaField javaField = new JavaField(f, this);
-					flds.add(javaField);
+					flds.add(rootDecompiler.convertFieldNode(f));
 				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
@@ -115,66 +172,66 @@ public final class JavaClass implements JavaNode {
 			List<JavaMethod> mths = new ArrayList<>(methodsCount);
 			for (MethodNode m : cls.getMethods()) {
 				if (!m.contains(AFlag.DONT_GENERATE)) {
-					JavaMethod javaMethod = new JavaMethod(this, m);
-					mths.add(javaMethod);
+					mths.add(rootDecompiler.convertMethodNode(m));
 				}
 			}
 			mths.sort(Comparator.comparing(JavaMethod::getName));
 			this.methods = Collections.unmodifiableList(mths);
 		}
+		return code;
 	}
 
-	protected JadxDecompiler getRootDecompiler() {
+	JadxDecompiler getRootDecompiler() {
 		if (parent != null) {
 			return parent.getRootDecompiler();
 		}
 		return decompiler;
 	}
 
-	private Map<CodePosition, Object> getCodeAnnotations() {
-		ICodeInfo code = getCodeInfo();
-		if (code == null) {
-			return Collections.emptyMap();
-		}
-		return code.getAnnotations();
+	public ICodeAnnotation getAnnotationAt(int pos) {
+		return getCodeInfo().getCodeMetadata().getAt(pos);
 	}
 
-	public Map<CodePosition, JavaNode> getUsageMap() {
-		Map<CodePosition, Object> map = getCodeAnnotations();
+	public Map<Integer, JavaNode> getUsageMap() {
+		Map<Integer, ICodeAnnotation> map = getCodeInfo().getCodeMetadata().getAsMap();
 		if (map.isEmpty() || decompiler == null) {
 			return Collections.emptyMap();
 		}
-		Map<CodePosition, JavaNode> resultMap = new HashMap<>(map.size());
-		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
-			CodePosition codePosition = entry.getKey();
-			Object obj = entry.getValue();
-			JavaNode node = getRootDecompiler().convertNode(obj);
-			if (node != null) {
-				resultMap.put(codePosition, node);
+		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;
+		});
+		return result;
+	}
+
 	@Override
 	public List<JavaNode> getUseIn() {
 		return getRootDecompiler().convertNodes(cls.getUseIn());
 	}
 
-	@Nullable
-	@Deprecated
-	public JavaNode getJavaNodeAtPosition(int line, int offset) {
-		return getRootDecompiler().getJavaNodeAtPosition(getCodeInfo(), line, offset);
-	}
-
-	@Nullable
-	@Deprecated
-	public CodePosition getDefinitionPosition() {
-		return getRootDecompiler().getDefinitionPosition(this);
-	}
-
 	public Integer getSourceLine(int decompiledLine) {
-		return getCodeInfo().getLineMapping().get(decompiledLine);
+		return getCodeInfo().getCodeMetadata().getLineMapping().get(decompiledLine);
 	}
 
 	@Override
@@ -200,9 +257,37 @@ 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() {
-		return parent == null ? this : parent.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() {
@@ -210,23 +295,51 @@ public final class JavaClass implements JavaNode {
 	}
 
 	public List<JavaClass> getInnerClasses() {
-		loadLists();
+		load();
 		return innerClasses;
 	}
 
+	public List<JavaClass> getInlinedClasses() {
+		load();
+		return inlinedClasses;
+	}
+
 	public List<JavaField> getFields() {
-		loadLists();
+		load();
 		return fields;
 	}
 
 	public List<JavaMethod> getMethods() {
-		loadLists();
+		load();
 		return methods;
 	}
 
+	@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 int getDecompiledLine() {
-		return cls.getDecompiledLine();
+	public void removeAlias() {
+		cls.removeAlias();
+	}
+
+	@Override
+	public int getDefPos() {
+		return cls.getDefPosition();
 	}
 
 	@Override

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

@@ -2,6 +2,10 @@ package jadx.api;
 
 import java.util.List;
 
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.FieldNode;
@@ -11,7 +15,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;
 	}
@@ -26,6 +30,10 @@ public final class JavaField implements JavaNode {
 		return parent.getFullName() + '.' + getName();
 	}
 
+	public String getRawName() {
+		return field.getName();
+	}
+
 	@Override
 	public JavaClass getDeclaringClass() {
 		return parent;
@@ -45,8 +53,8 @@ public final class JavaField implements JavaNode {
 	}
 
 	@Override
-	public int getDecompiledLine() {
-		return field.getDecompiledLine();
+	public int getDefPos() {
+		return field.getDefPosition();
 	}
 
 	@Override
@@ -54,9 +62,28 @@ public final class JavaField implements JavaNode {
 		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;
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return field;
+	}
+
 	/**
 	 * Internal API. Not Stable!
 	 */
+	@ApiStatus.Internal
 	public FieldNode getFieldNode() {
 		return field;
 	}

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

@@ -2,13 +2,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.api.metadata.ICodeNodeRef;
+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 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;
 
@@ -61,6 +73,24 @@ public final class JavaMethod implements JavaNode {
 		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() {
 		return mth.getMethodInfo().isConstructor();
 	}
@@ -70,13 +100,32 @@ public final class JavaMethod implements JavaNode {
 	}
 
 	@Override
-	public int getDecompiledLine() {
-		return mth.getDecompiledLine();
+	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;
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return mth;
 	}
 
 	/**
 	 * Internal API. Not Stable!
 	 */
+	@ApiStatus.Internal
 	public MethodNode getMethodNode() {
 		return mth;
 	}

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

@@ -2,8 +2,13 @@ package jadx.api;
 
 import java.util.List;
 
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+
 public interface JavaNode {
 
+	ICodeNodeRef getCodeNodeRef();
+
 	String getName();
 
 	String getFullName();
@@ -12,7 +17,11 @@ public interface JavaNode {
 
 	JavaClass getTopParentClass();
 
-	int getDecompiledLine();
+	int getDefPos();
 
 	List<JavaNode> getUseIn();
+
+	void removeAlias();
+
+	boolean isOwnCodeAnnotation(ICodeAnnotation ann);
 }

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

@@ -1,34 +1,91 @@
 package jadx.api;
 
-import java.util.Collections;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
+import org.jetbrains.annotations.ApiStatus.Internal;
 import org.jetbrains.annotations.NotNull;
 
-public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
-	private final String name;
-	private final List<JavaClass> classes;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.dex.info.PackageInfo;
+import jadx.core.dex.nodes.PackageNode;
 
-	JavaPackage(String name, List<JavaClass> classes) {
-		this.name = name;
+public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
+	private final PackageNode pkgNode;
+	private final List<JavaClass> classes;
+	private final List<JavaPackage> subPkgs;
+
+	JavaPackage(PackageNode pkgNode, List<JavaClass> classes, List<JavaPackage> subPkgs) {
+		this.pkgNode = pkgNode;
 		this.classes = classes;
+		this.subPkgs = subPkgs;
 	}
 
 	@Override
 	public String getName() {
-		return name;
+		return pkgNode.getAliasPkgInfo().getName();
 	}
 
 	@Override
 	public String getFullName() {
-		// TODO: store full package name
-		return name;
+		return pkgNode.getAliasPkgInfo().getFullName();
+	}
+
+	public String getRawName() {
+		return pkgNode.getPkgInfo().getName();
+	}
+
+	public String getRawFullName() {
+		return pkgNode.getPkgInfo().getFullName();
+	}
+
+	public List<JavaPackage> getSubPackages() {
+		return subPkgs;
 	}
 
 	public List<JavaClass> getClasses() {
 		return classes;
 	}
 
+	public boolean isRoot() {
+		return pkgNode.isRoot();
+	}
+
+	public boolean isLeaf() {
+		return pkgNode.isLeaf();
+	}
+
+	public boolean isDefault() {
+		return getFullName().isEmpty();
+	}
+
+	public void rename(String alias) {
+		pkgNode.rename(alias);
+	}
+
+	@Override
+	public void removeAlias() {
+		pkgNode.removeAlias();
+	}
+
+	public boolean isParentRenamed() {
+		PackageInfo parent = pkgNode.getPkgInfo().getParentPkg();
+		PackageInfo aliasParent = pkgNode.getAliasPkgInfo().getParentPkg();
+		return !Objects.equals(parent, aliasParent);
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return pkgNode;
+	}
+
+	@Internal
+	public PackageNode getPkgNode() {
+		return pkgNode;
+	}
+
 	@Override
 	public JavaClass getDeclaringClass() {
 		return null;
@@ -40,18 +97,32 @@ public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 	}
 
 	@Override
-	public int getDecompiledLine() {
+	public int getDefPos() {
 		return 0;
 	}
 
 	@Override
 	public List<JavaNode> getUseIn() {
-		return Collections.emptyList();
+		List<JavaNode> list = new ArrayList<>();
+		addUseIn(list);
+		return list;
+	}
+
+	public void addUseIn(List<JavaNode> list) {
+		list.addAll(classes);
+		for (JavaPackage subPkg : subPkgs) {
+			subPkg.addUseIn(list);
+		}
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		return false;
 	}
 
 	@Override
 	public int compareTo(@NotNull JavaPackage o) {
-		return name.compareTo(o.name);
+		return pkgNode.compareTo(o.pkgNode);
 	}
 
 	@Override
@@ -63,16 +134,16 @@ public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 			return false;
 		}
 		JavaPackage that = (JavaPackage) o;
-		return name.equals(that.name);
+		return pkgNode.equals(that.pkgNode);
 	}
 
 	@Override
 	public int hashCode() {
-		return name.hashCode();
+		return pkgNode.hashCode();
 	}
 
 	@Override
 	public String toString() {
-		return name;
+		return pkgNode.toString();
 	}
 }

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

@@ -0,0 +1,109 @@
+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.ICodeNodeRef;
+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();
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return varNode;
+	}
+
+	@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 void removeAlias() {
+		varNode.setName(null);
+	}
+
+	@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

@@ -37,6 +37,10 @@ public class ResourceFile {
 	private ZipRef zipRef;
 	private String deobfName;
 
+	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;
@@ -58,6 +62,10 @@ public class ResourceFile {
 		return deobfName != null ? deobfName : name;
 	}
 
+	public void setDeobfName(String resFullName) {
+		this.deobfName = resFullName;
+	}
+
 	public ResourceType getType() {
 		return type;
 	}
@@ -70,13 +78,20 @@ public class ResourceFile {
 		this.zipRef = zipRef;
 	}
 
-	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 boolean setAlias(ResourceEntry ri) {
+		StringBuilder sb = new StringBuilder();
+		sb.append("res/").append(ri.getTypeName()).append(ri.getConfig());
+		sb.append("/").append(ri.getKeyName());
+		int lastDot = name.lastIndexOf('.');
+		if (lastDot != -1) {
+			sb.append(name.substring(lastDot));
+		}
+		String alias = sb.toString();
+		if (!alias.equals(name)) {
+			setDeobfName(alias);
+			return true;
+		}
+		return false;
 	}
 
 	public ZipRef getZipRef() {

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

@@ -41,6 +41,9 @@ public enum ResourceType {
 	}
 
 	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);

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

@@ -16,29 +16,43 @@ import org.slf4j.LoggerFactory;
 
 import jadx.api.ResourceFile.ZipRef;
 import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.plugins.CustomResourcesLoader;
+import jadx.api.plugins.resources.IResContainerFactory;
+import jadx.api.plugins.resources.IResTableParserProvider;
+import jadx.api.plugins.resources.IResourcesLoader;
 import jadx.api.plugins.utils.ZipSecurity;
-import jadx.core.codegen.CodeWriter;
+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.exceptions.JadxRuntimeException;
 import jadx.core.utils.files.FileUtils;
+import jadx.core.xmlgen.BinaryXMLParser;
+import jadx.core.xmlgen.IResTableParser;
 import jadx.core.xmlgen.ResContainer;
-import jadx.core.xmlgen.ResTableParser;
+import jadx.core.xmlgen.ResTableBinaryParserProvider;
 
 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 {
+public final class ResourcesLoader implements IResourcesLoader {
 	private static final Logger LOG = LoggerFactory.getLogger(ResourcesLoader.class);
 
 	private final JadxDecompiler jadxRef;
 
+	private final List<IResTableParserProvider> resTableParserProviders = new ArrayList<>();
+	private final List<IResContainerFactory> resContainerFactories = new ArrayList<>();
+
+	private BinaryXMLParser binaryXmlParser;
+
 	ResourcesLoader(JadxDecompiler jadxRef) {
 		this.jadxRef = jadxRef;
+		this.resTableParserProviders.add(new ResTableBinaryParserProvider());
 	}
 
-	List<ResourceFile> load() {
+	List<ResourceFile> load(RootNode root) {
+		init(root);
 		List<File> inputFiles = jadxRef.getArgs().getInputFiles();
 		List<ResourceFile> list = new ArrayList<>(inputFiles.size());
 		for (File file : inputFiles) {
@@ -47,10 +61,37 @@ public final class ResourcesLoader {
 		return list;
 	}
 
+	private void init(RootNode root) {
+		for (IResTableParserProvider resTableParserProvider : resTableParserProviders) {
+			try {
+				resTableParserProvider.init(root);
+			} catch (Exception e) {
+				throw new JadxRuntimeException("Failed to init res table provider: " + resTableParserProvider);
+			}
+		}
+		for (IResContainerFactory resContainerFactory : resContainerFactories) {
+			try {
+				resContainerFactory.init(root);
+			} catch (Exception e) {
+				throw new JadxRuntimeException("Failed to init res container factory: " + resContainerFactory);
+			}
+		}
+	}
+
 	public interface ResourceDecoder<T> {
 		T decode(long size, InputStream is) throws IOException;
 	}
 
+	@Override
+	public void addResContainerFactory(IResContainerFactory resContainerFactory) {
+		resContainerFactories.add(resContainerFactory);
+	}
+
+	@Override
+	public void addResTableParserProvider(IResTableParserProvider resTableParserProvider) {
+		resTableParserProviders.add(resTableParserProvider);
+	}
+
 	public static <T> T decodeStream(ResourceFile rf, ResourceDecoder<T> decoder) throws JadxException {
 		try {
 			ZipRef zipRef = rf.getZipRef();
@@ -80,42 +121,67 @@ public final class ResourcesLoader {
 
 	static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf) {
 		try {
-			return decodeStream(rf, (size, is) -> loadContent(jadxRef, rf, is));
+			ResourcesLoader resLoader = jadxRef.getResourcesLoader();
+			return decodeStream(rf, (size, is) -> resLoader.loadContent(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());
 			Utils.appendStackTrace(cw, e.getCause());
 			return ResContainer.textResource(rf.getDeobfName(), cw.finish());
 		}
 	}
 
-	private static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf,
-			InputStream inputStream) throws IOException {
-		switch (rf.getType()) {
+	private ResContainer loadContent(ResourceFile resFile, InputStream inputStream) throws IOException {
+		for (IResContainerFactory customFactory : resContainerFactories) {
+			ResContainer resContainer = customFactory.create(resFile, inputStream);
+			if (resContainer != null) {
+				return resContainer;
+			}
+		}
+		switch (resFile.getType()) {
 			case MANIFEST:
 			case XML:
-				ICodeInfo content = jadxRef.getXmlParser().parse(inputStream);
-				return ResContainer.textResource(rf.getDeobfName(), content);
+				ICodeInfo content = loadBinaryXmlParser().parse(inputStream);
+				return ResContainer.textResource(resFile.getDeobfName(), content);
 
 			case ARSC:
-				return new ResTableParser(jadxRef.getRoot()).decodeFiles(inputStream);
+				return decodeTable(resFile, inputStream).decodeFiles();
 
 			case IMG:
-				return decodeImage(rf, inputStream);
+				return decodeImage(resFile, inputStream);
 
 			default:
-				return ResContainer.resourceFileLink(rf);
+				return ResContainer.resourceFileLink(resFile);
 		}
 	}
 
+	public IResTableParser decodeTable(ResourceFile resFile, InputStream is) throws IOException {
+		if (resFile.getType() != ResourceType.ARSC) {
+			throw new IllegalArgumentException("Unexpected resource type for decode: " + resFile.getType() + ", expect '.pb'/'.arsc'");
+		}
+		IResTableParser parser = null;
+		for (IResTableParserProvider provider : resTableParserProviders) {
+			parser = provider.getParser(resFile);
+			if (parser != null) {
+				break;
+			}
+		}
+		if (parser == null) {
+			throw new JadxRuntimeException("Unknown type of resource file: " + resFile.getOriginalName());
+		}
+		parser.decode(is);
+		return parser;
+	}
+
 	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();
-				decoder.decode(inputStream, os);
-				return ResContainer.decodedData(rf.getDeobfName(), os.toByteArray());
+				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);
 			}
@@ -124,32 +190,41 @@ public final class ResourcesLoader {
 	}
 
 	private void loadFile(List<ResourceFile> list, File file) {
-		if (file == null) {
+		if (file == null || file.isDirectory()) {
 			return;
 		}
+
+		// Try to load the resources with a custom loader first
+		for (CustomResourcesLoader loader : jadxRef.getCustomResourcesLoaders()) {
+			if (loader.load(this, list, file)) {
+				LOG.debug("Custom loader used for {}", file.getAbsolutePath());
+				return;
+			}
+		}
+
+		// If no custom decoder was able to decode the resources, use the default decoder
+		defaultLoadFile(list, file, "");
+	}
+
+	public void defaultLoadFile(List<ResourceFile> list, File file, String subDir) {
 		if (FileUtils.isZipFile(file)) {
-			ZipSecurity.visitZipEntries(file, (zipFile, entry) -> addEntry(list, file, entry));
+			ZipSecurity.visitZipEntries(file, (zipFile, entry) -> {
+				addEntry(list, file, entry, subDir);
+				return null;
+			});
 		} else {
-			addResourceFile(list, file);
+			ResourceType type = ResourceType.getFileType(file.getAbsolutePath());
+			list.add(ResourceFile.createResourceFile(jadxRef, file, type));
 		}
 	}
 
-	private void addResourceFile(List<ResourceFile> list, File file) {
-		String name = file.getAbsolutePath();
-		ResourceType type = ResourceType.getFileType(name);
-		ResourceFile rf = ResourceFile.createResourceFile(jadxRef, name, type);
-		if (rf != null) {
-			list.add(rf);
-		}
-	}
-
-	private void addEntry(List<ResourceFile> list, File zipFile, ZipEntry entry) {
+	public void addEntry(List<ResourceFile> list, File zipFile, ZipEntry entry, String subDir) {
 		if (entry.isDirectory()) {
 			return;
 		}
 		String name = entry.getName();
 		ResourceType type = ResourceType.getFileType(name);
-		ResourceFile rf = ResourceFile.createResourceFile(jadxRef, name, type);
+		ResourceFile rf = ResourceFile.createResourceFile(jadxRef, subDir + name, type);
 		if (rf != null) {
 			rf.setZipRef(new ZipRef(zipFile, name));
 			list.add(rf);
@@ -161,4 +236,11 @@ public final class ResourcesLoader {
 		copyStream(is, baos);
 		return new SimpleCodeInfo(baos.toString("UTF-8"));
 	}
+
+	private synchronized BinaryXMLParser loadBinaryXmlParser() {
+		if (binaryXmlParser == null) {
+			binaryXmlParser = new BinaryXMLParser(jadxRef.getRoot());
+		}
+		return binaryXmlParser;
+	}
 }

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

@@ -0,0 +1,36 @@
+package jadx.api.args;
+
+public enum GeneratedRenamesMappingFileMode {
+
+	/**
+	 * 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 static GeneratedRenamesMappingFileMode getDefault() {
+		return READ;
+	}
+
+	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/IntegerFormat.java

@@ -0,0 +1,11 @@
+package jadx.api.args;
+
+public enum IntegerFormat {
+	AUTO,
+	DECIMAL,
+	HEXADECIMAL;
+
+	public boolean isHexadecimal() {
+		return this == HEXADECIMAL;
+	}
+}

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/args/UserRenamesMappingsMode.java

@@ -0,0 +1,36 @@
+package jadx.api.args;
+
+public enum UserRenamesMappingsMode {
+
+	/**
+	 * Just read, user can save manually (default)
+	 */
+	READ,
+
+	/**
+	 * Read and autosave after every change
+	 */
+	READ_AND_AUTOSAVE_EVERY_CHANGE,
+
+	/**
+	 * Read and autosave before exiting the app or closing the project
+	 */
+	READ_AND_AUTOSAVE_BEFORE_CLOSING,
+
+	/**
+	 * Don't load and don't save
+	 */
+	IGNORE;
+
+	public static UserRenamesMappingsMode getDefault() {
+		return READ;
+	}
+
+	public boolean shouldRead() {
+		return this != IGNORE;
+	}
+
+	public boolean shouldWrite() {
+		return this == READ_AND_AUTOSAVE_EVERY_CHANGE || this == READ_AND_AUTOSAVE_BEFORE_CLOSING;
+	}
+}

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

@@ -0,0 +1,69 @@
+package jadx.api.data;
+
+public enum CommentStyle {
+
+	/**
+	 * <pre>
+	 * // comment
+	 * </pre>
+	 */
+	LINE("// ", "// ", ""),
+
+	// @formatter:off
+	/**
+	 * <pre>
+	 * /*
+	 *  * comment
+	 *  *&#47;
+	 * </pre>
+	 */
+	// @formatter:on
+	BLOCK("/*\n * ", " * ", "\n */"),
+
+	/**
+	 * <pre>
+	 * /* comment *&#47;
+	 * </pre>
+	 */
+	BLOCK_CONDENSED("/* ", " * ", " */"),
+
+	// @formatter:off
+	/**
+	 * <pre>
+	 * /**
+	 *  * comment
+	 *  *&#47;
+	 * </pre>
+	 */
+	// @formatter:on
+	JAVADOC("/**\n * ", " * ", "\n */"),
+
+	/**
+	 * <pre>
+	 * /** comment *&#47;
+	 * </pre>
+	 */
+	JAVADOC_CONDENSED("/** ", " * ", " */");
+
+	private final String start;
+	private final String onNewLine;
+	private final String end;
+
+	CommentStyle(String start, String onNewLine, String end) {
+		this.start = start;
+		this.onNewLine = onNewLine;
+		this.end = end;
+	}
+
+	public String getStart() {
+		return start;
+	}
+
+	public String getOnNewLine() {
+		return onNewLine;
+	}
+
+	public String getEnd() {
+		return end;
+	}
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+package jadx.api.data;
+
+public interface IRenameNode {
+
+	void rename(String newName);
+}

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

@@ -0,0 +1,99 @@
+package jadx.api.data.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.data.CommentStyle;
+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;
+	private CommentStyle style = CommentStyle.LINE;
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, String comment) {
+		this(nodeRef, null, comment);
+	}
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, String comment, CommentStyle style) {
+		this(nodeRef, null, comment, style);
+	}
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, @Nullable IJavaCodeRef codeRef, String comment) {
+		this(nodeRef, codeRef, comment, CommentStyle.LINE);
+	}
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, @Nullable IJavaCodeRef codeRef, String comment, CommentStyle style) {
+		this.nodeRef = nodeRef;
+		this.codeRef = codeRef;
+		this.comment = comment;
+		this.style = style;
+	}
+
+	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 CommentStyle getStyle() {
+		return style;
+	}
+
+	public void setStyle(CommentStyle style) {
+		this.style = style;
+	}
+
+	@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 + '\''
+				+ ", style=" + style
+				+ '}';
+	}
+}

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

@@ -0,0 +1,36 @@
+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;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return comments.isEmpty() && renames.isEmpty();
+	}
+}

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
+				+ '}';
+	}
+}