repo stringclasses 1k values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 6 values | commit_sha stringclasses 1k values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/RenameMappingsOptions.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/RenameMappingsOptions.java | package jadx.plugins.mappings;
import java.util.Locale;
import org.jetbrains.annotations.Nullable;
import net.fabricmc.mappingio.format.MappingFormat;
import jadx.api.plugins.options.OptionFlag;
import jadx.api.plugins.options.impl.BasePluginOptionsBuilder;
import jadx.core.utils.ListUtils;
import static jadx.plugins.mappings.RenameMappingsPlugin.PLUGIN_ID;
public class RenameMappingsOptions extends BasePluginOptionsBuilder {
public static final String INVERT_OPT = PLUGIN_ID + ".invert";
public static final String FORMAT_OPT = PLUGIN_ID + ".format";
private boolean invert = false;
/**
* null value - used for 'auto' option
*/
private @Nullable MappingFormat format = null;
@Override
public void registerOptions() {
option(FORMAT_OPT, MappingFormat.class)
.description("mapping format")
.parser(RenameMappingsOptions::parseMappingFormat)
.formatter(v -> v == null ? "AUTO" : v.name())
.values(ListUtils.concat(null, MappingFormat.values()))
.defaultValue(null)
.flags(OptionFlag.PER_PROJECT, OptionFlag.DISABLE_IN_GUI)
.setter(v -> format = v);
boolOption(INVERT_OPT)
.description("invert mapping on load")
.defaultValue(false)
.flags(OptionFlag.PER_PROJECT)
.setter(v -> invert = v);
}
private static MappingFormat parseMappingFormat(String name) {
String upName = name.toUpperCase(Locale.ROOT);
if (upName.equals("AUTO")) {
return null;
}
return MappingFormat.valueOf(upName);
}
public @Nullable MappingFormat getFormat() {
return format;
}
public boolean isInvert() {
return invert;
}
public String getOptionsHashString() {
return format + ":" + invert;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/RenameMappingsPlugin.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/RenameMappingsPlugin.java | package jadx.plugins.mappings;
import java.nio.file.Files;
import java.nio.file.Path;
import jadx.api.JadxArgs;
import jadx.api.args.UserRenamesMappingsMode;
import jadx.api.plugins.JadxPlugin;
import jadx.api.plugins.JadxPluginContext;
import jadx.api.plugins.JadxPluginInfo;
import jadx.core.utils.files.FileUtils;
import jadx.plugins.mappings.load.ApplyMappingsPass;
import jadx.plugins.mappings.load.CodeMappingsPass;
import jadx.plugins.mappings.load.LoadMappingsPass;
public class RenameMappingsPlugin implements JadxPlugin {
public static final String PLUGIN_ID = "rename-mappings";
private final RenameMappingsOptions options = new RenameMappingsOptions();
@Override
public JadxPluginInfo getPluginInfo() {
return new JadxPluginInfo(PLUGIN_ID, "Rename Mappings", "various mappings support");
}
@Override
public void init(JadxPluginContext context) {
context.registerOptions(options);
JadxArgs args = context.getArgs();
if (args.getUserRenamesMappingsMode() == UserRenamesMappingsMode.IGNORE) {
return;
}
Path mappingsPath = args.getUserRenamesMappingsPath();
if (mappingsPath == null || !Files.isReadable(mappingsPath)) {
return;
}
context.addPass(new LoadMappingsPass(options));
context.addPass(new ApplyMappingsPass());
context.addPass(new CodeMappingsPass());
// use mapping file time modification to check for changes
context.registerInputsHashSupplier(() -> FileUtils.md5Sum(getInputsHashString(mappingsPath)));
}
private String getInputsHashString(Path mappingsPath) {
return getFileHashString(mappingsPath) + ':' + options.getOptionsHashString();
}
private static String getFileHashString(Path mappingsPath) {
try {
return mappingsPath.toAbsolutePath().normalize()
+ ":" + Files.getLastModifiedTime(mappingsPath).toMillis();
} catch (Exception e) {
return "";
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/RenameMappingsData.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/RenameMappingsData.java | package jadx.plugins.mappings;
import org.jetbrains.annotations.Nullable;
import net.fabricmc.mappingio.tree.MappingTreeView;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.core.dex.nodes.RootNode;
public class RenameMappingsData implements IJadxAttribute {
private static final IJadxAttrType<RenameMappingsData> DATA = IJadxAttrType.create();
public static @Nullable RenameMappingsData getData(RootNode root) {
return root.getAttributes().get(DATA);
}
public static @Nullable MappingTreeView getTree(RootNode root) {
RenameMappingsData data = getData(root);
return data == null ? null : data.getMappings();
}
private final MappingTreeView mappings;
public RenameMappingsData(MappingTreeView mappings) {
this.mappings = mappings;
}
public MappingTreeView getMappings() {
return mappings;
}
@Override
public IJadxAttrType<RenameMappingsData> getAttrType() {
return DATA;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/save/MappingExporter.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/save/MappingExporter.java | package jadx.plugins.mappings.save;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.fabricmc.mappingio.MappedElementKind;
import net.fabricmc.mappingio.MappingUtil;
import net.fabricmc.mappingio.MappingWriter;
import net.fabricmc.mappingio.format.MappingFormat;
import net.fabricmc.mappingio.tree.MappingTreeView;
import net.fabricmc.mappingio.tree.MemoryMappingTree;
import net.fabricmc.mappingio.tree.VisitOrder;
import net.fabricmc.mappingio.tree.VisitableMappingTree;
import jadx.api.data.ICodeComment;
import jadx.api.data.ICodeRename;
import jadx.api.data.IJavaNodeRef.RefType;
import jadx.api.data.impl.JadxCodeData;
import jadx.api.data.impl.JadxCodeRef;
import jadx.api.metadata.annotations.VarNode;
import jadx.core.Consts;
import jadx.core.codegen.TypeGen;
import jadx.core.dex.info.ClassInfo;
import jadx.core.dex.info.FieldInfo;
import jadx.core.dex.info.MethodInfo;
import jadx.core.dex.nodes.ClassNode;
import jadx.core.dex.nodes.FieldNode;
import jadx.core.dex.nodes.MethodNode;
import jadx.core.dex.nodes.RootNode;
import jadx.core.utils.files.FileUtils;
import jadx.plugins.mappings.RenameMappingsData;
import jadx.plugins.mappings.utils.DalvikToJavaBytecodeUtils;
import jadx.plugins.mappings.utils.VariablesUtils;
public class MappingExporter {
private static final Logger LOG = LoggerFactory.getLogger(MappingExporter.class);
private final RootNode root;
private final @Nullable MappingTreeView loadedMappingTree;
public MappingExporter(RootNode root) {
this.root = root;
this.loadedMappingTree = RenameMappingsData.getTree(this.root);
}
public void exportMappings(Path path, JadxCodeData codeData, MappingFormat mappingFormat) {
VisitableMappingTree mappingTree = new MemoryMappingTree();
// Map < SrcName >
Set<String> mappedClasses = new HashSet<>();
// Map < DeclClass + ShortId >
Set<String> mappedFields = new HashSet<>();
Set<String> mappedMethods = new HashSet<>();
Set<String> methodsWithMappedElements = new HashSet<>();
// Map < DeclClass + MethodShortId + CodeRef, NewName >
Map<String, String> mappedMethodArgsAndVars = new HashMap<>();
// Map < DeclClass [+ ShortId] [+ CodeRef], Comment >
Map<String, String> comments = new HashMap<>();
// We have to do this so we know for sure which elements are *manually* renamed
for (ICodeRename codeRename : codeData.getRenames()) {
if (codeRename.getNodeRef().getType().equals(RefType.CLASS)) {
mappedClasses.add(codeRename.getNodeRef().getDeclaringClass());
} else if (codeRename.getNodeRef().getType().equals(RefType.FIELD)) {
mappedFields.add(codeRename.getNodeRef().getDeclaringClass() + codeRename.getNodeRef().getShortId());
} else if (codeRename.getNodeRef().getType().equals(RefType.METHOD)) {
if (codeRename.getCodeRef() == null) {
mappedMethods.add(codeRename.getNodeRef().getDeclaringClass() + codeRename.getNodeRef().getShortId());
} else {
methodsWithMappedElements.add(codeRename.getNodeRef().getDeclaringClass() + codeRename.getNodeRef().getShortId());
mappedMethodArgsAndVars.put(codeRename.getNodeRef().getDeclaringClass()
+ codeRename.getNodeRef().getShortId()
+ codeRename.getCodeRef(),
codeRename.getNewName());
}
}
}
for (ICodeComment codeComment : codeData.getComments()) {
comments.put(codeComment.getNodeRef().getDeclaringClass()
+ (codeComment.getNodeRef().getShortId() == null ? "" : codeComment.getNodeRef().getShortId())
+ (codeComment.getCodeRef() == null ? "" : codeComment.getCodeRef()),
codeComment.getComment());
if (codeComment.getCodeRef() != null) {
methodsWithMappedElements.add(codeComment.getNodeRef().getDeclaringClass() + codeComment.getNodeRef().getShortId());
}
}
try {
String srcNamespace = MappingUtil.NS_SOURCE_FALLBACK;
String dstNamespace = MappingUtil.NS_TARGET_FALLBACK;
// Copy mappings from potentially imported mappings file
if (loadedMappingTree != null && loadedMappingTree.getDstNamespaces() != null) {
loadedMappingTree.accept(mappingTree);
}
mappingTree.visitHeader();
mappingTree.visitNamespaces(srcNamespace, Collections.singletonList(dstNamespace));
mappingTree.visitContent();
for (ClassNode cls : root.getClasses()) {
ClassInfo classInfo = cls.getClassInfo();
String classPath = classInfo.makeRawFullName().replace('.', '/');
String rawClassName = classInfo.getRawName();
if (classInfo.hasAlias()
&& !classInfo.getAliasShortName().equals(classInfo.getShortName())
&& mappedClasses.contains(rawClassName)) {
mappingTree.visitClass(classPath);
String alias = classInfo.makeAliasRawFullName().replace('.', '/');
if (alias.startsWith(Consts.DEFAULT_PACKAGE_NAME)) {
alias = alias.substring(Consts.DEFAULT_PACKAGE_NAME.length() + 1);
}
mappingTree.visitDstName(MappedElementKind.CLASS, 0, alias);
}
if (comments.containsKey(rawClassName)) {
mappingTree.visitClass(classPath);
mappingTree.visitComment(MappedElementKind.CLASS, comments.get(rawClassName));
}
for (FieldNode fld : cls.getFields()) {
FieldInfo fieldInfo = fld.getFieldInfo();
if (fieldInfo.hasAlias() && mappedFields.contains(rawClassName + fieldInfo.getShortId())) {
visitField(mappingTree, classPath, fieldInfo.getName(), TypeGen.signature(fieldInfo.getType()));
mappingTree.visitDstName(MappedElementKind.FIELD, 0, fieldInfo.getAlias());
}
if (comments.containsKey(rawClassName + fieldInfo.getShortId())) {
visitField(mappingTree, classPath, fieldInfo.getName(), TypeGen.signature(fieldInfo.getType()));
mappingTree.visitComment(MappedElementKind.FIELD, comments.get(rawClassName + fieldInfo.getShortId()));
}
}
for (MethodNode mth : cls.getMethods()) {
MethodInfo methodInfo = mth.getMethodInfo();
String methodName = methodInfo.getName();
String methodDesc = methodInfo.getShortId().substring(methodName.length());
if (methodInfo.hasAlias() && mappedMethods.contains(rawClassName + methodInfo.getShortId())) {
visitMethod(mappingTree, classPath, methodName, methodDesc);
mappingTree.visitDstName(MappedElementKind.METHOD, 0, methodInfo.getAlias());
}
if (comments.containsKey(rawClassName + methodInfo.getShortId())) {
visitMethod(mappingTree, classPath, methodName, methodDesc);
mappingTree.visitComment(MappedElementKind.METHOD, comments.get(rawClassName + methodInfo.getShortId()));
}
if (!methodsWithMappedElements.contains(rawClassName + methodInfo.getShortId())) {
continue;
}
// Method args
int lvtIndex = mth.getAccessFlags().isStatic() ? 0 : 1;
List<VarNode> args = mth.collectArgNodes();
for (VarNode arg : args) {
Integer lvIndex = DalvikToJavaBytecodeUtils.getMethodArgLvIndex(arg);
if (lvIndex == null) {
lvIndex = -1;
}
String key = rawClassName + methodInfo.getShortId()
+ JadxCodeRef.forVar(arg.getReg(), arg.getSsa());
if (mappedMethodArgsAndVars.containsKey(key)) {
visitMethodArg(mappingTree, classPath, methodName, methodDesc, args.indexOf(arg), lvIndex);
mappingTree.visitDstName(MappedElementKind.METHOD_ARG, 0, mappedMethodArgsAndVars.get(key));
mappedMethodArgsAndVars.remove(key);
}
lvtIndex++;
// Not checking for comments since method args can't have any
}
// Method vars
for (VariablesUtils.VarInfo info : VariablesUtils.collect(mth)) {
VarNode var = info.getVar();
int startOpIdx = info.getStartOpIdx();
int endOpIdx = info.getEndOpIdx();
int lvIndex = DalvikToJavaBytecodeUtils.getMethodVarLvIndex(var);
String key = rawClassName + methodInfo.getShortId()
+ JadxCodeRef.forVar(var.getReg(), var.getSsa());
if (mappedMethodArgsAndVars.containsKey(key)) {
visitMethodVar(mappingTree, classPath, methodName, methodDesc, lvtIndex, lvIndex, startOpIdx, endOpIdx);
mappingTree.visitDstName(MappedElementKind.METHOD_VAR, 0, mappedMethodArgsAndVars.get(key));
}
key = rawClassName + methodInfo.getShortId() + JadxCodeRef.forInsn(startOpIdx);
if (comments.containsKey(key)) {
visitMethodVar(mappingTree, classPath, methodName, methodDesc, lvtIndex, lvIndex, startOpIdx, endOpIdx);
mappingTree.visitComment(MappedElementKind.METHOD_VAR, comments.get(key));
}
lvtIndex++;
}
}
}
// write file as late as possible because a mapping collection can fail with exception
if (mappingFormat.hasSingleFile()) {
FileUtils.deleteFileIfExists(path);
FileUtils.makeDirsForFile(path);
Files.createFile(path);
} else {
FileUtils.makeDirs(path);
}
// Write file
mappingTree.accept(MappingWriter.create(path, mappingFormat), VisitOrder.createByName());
mappingTree.visitEnd();
} catch (Exception e) {
LOG.error("Failed to save deobfuscation map file '{}'", path.toAbsolutePath(), e);
}
}
private void visitField(VisitableMappingTree tree, String classPath, String srcName, String srcDesc) throws IOException {
tree.visitClass(classPath);
tree.visitField(srcName, srcDesc);
}
private void visitMethod(VisitableMappingTree tree, String classPath, String srcName, String srcDesc) throws IOException {
tree.visitClass(classPath);
tree.visitMethod(srcName, srcDesc);
}
private void visitMethodArg(VisitableMappingTree tree, String classPath, String methodSrcName, String methodSrcDesc, int argPosition,
int lvIndex) throws IOException {
visitMethod(tree, classPath, methodSrcName, methodSrcDesc);
tree.visitMethodArg(argPosition, lvIndex, null);
}
private void visitMethodVar(VisitableMappingTree tree, String classPath, String methodSrcName, String methodSrcDesc, int lvtIndex,
int lvIndex, int startOpIdx, int endOpIdx) throws IOException {
visitMethod(tree, classPath, methodSrcName, methodSrcDesc);
tree.visitMethodVar(lvtIndex, lvIndex, startOpIdx, endOpIdx, null);
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/utils/VariablesUtils.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/utils/VariablesUtils.java | package jadx.plugins.mappings.utils;
import java.util.ArrayList;
import java.util.List;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jadx.api.ICodeInfo;
import jadx.api.metadata.ICodeAnnotation;
import jadx.api.metadata.ICodeNodeRef;
import jadx.api.metadata.annotations.InsnCodeOffset;
import jadx.api.metadata.annotations.NodeDeclareRef;
import jadx.api.metadata.annotations.VarNode;
import jadx.api.utils.CodeUtils;
import jadx.core.dex.nodes.MethodNode;
public class VariablesUtils {
private static final Logger LOG = LoggerFactory.getLogger(VariablesUtils.class);
public static class VarInfo {
private final VarNode var;
private final int startOpIdx;
private int endOpIdx;
public VarInfo(VarNode var, int startOpIdx) {
this.var = var;
this.startOpIdx = startOpIdx;
this.endOpIdx = startOpIdx;
}
public VarNode getVar() {
return var;
}
public int getStartOpIdx() {
return startOpIdx;
}
public int getEndOpIdx() {
return endOpIdx;
}
public void setEndOpIdx(int endOpIdx) {
this.endOpIdx = endOpIdx;
}
}
public static List<VarInfo> collect(MethodNode mth) {
ICodeInfo codeInfo = mth.getTopParentClass().getCode();
int mthDefPos = mth.getDefPosition();
int mthLineEndPos = CodeUtils.getLineEndForPos(codeInfo.getCodeStr(), mthDefPos);
CodeVisitor codeVisitor = new CodeVisitor(mth);
codeInfo.getCodeMetadata().searchDown(mthLineEndPos, codeVisitor::process);
return codeVisitor.getVars();
}
private static class CodeVisitor {
private final MethodNode mth;
private final List<VarInfo> vars = new ArrayList<>();
private int lastOffset = -1;
public CodeVisitor(MethodNode mth) {
this.mth = mth;
}
public @Nullable Boolean process(Integer pos, ICodeAnnotation ann) {
if (ann instanceof InsnCodeOffset) {
lastOffset = ((InsnCodeOffset) ann).getOffset();
}
if (ann instanceof NodeDeclareRef) {
ICodeNodeRef declRef = ((NodeDeclareRef) ann).getNode();
if (declRef instanceof VarNode) {
VarNode varNode = (VarNode) declRef;
if (!varNode.getMth().equals(mth)) { // Stop if we've gone too far and have entered a different method
if (!vars.isEmpty()) {
vars.get(vars.size() - 1).setEndOpIdx(declRef.getDefPosition() - 1);
}
return Boolean.TRUE;
}
if (lastOffset != -1) {
if (!vars.isEmpty()) {
vars.get(vars.size() - 1).setEndOpIdx(lastOffset - 1);
}
vars.add(new VarInfo(varNode, lastOffset));
} else {
LOG.warn("Local variable not present in bytecode, skipping: {}#{}",
mth.getMethodInfo().getRawFullId(), varNode.getName());
}
lastOffset = -1;
}
}
return null;
}
public List<VarInfo> getVars() {
return vars;
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/utils/DalvikToJavaBytecodeUtils.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/utils/DalvikToJavaBytecodeUtils.java | package jadx.plugins.mappings.utils;
import java.util.ArrayList;
import java.util.List;
import jadx.api.metadata.annotations.VarNode;
import jadx.core.dex.instructions.args.RegisterArg;
import jadx.core.dex.instructions.args.SSAVar;
import jadx.core.dex.nodes.MethodNode;
public class DalvikToJavaBytecodeUtils {
// ****************************
// Local variable index
// ****************************
// Method args
public static Integer getMethodArgLvIndex(VarNode methodArg) {
MethodNode mth = methodArg.getMth();
Integer lvIndex = getMethodArgLvIndexViaSsaVars(methodArg.getReg(), mth);
if (lvIndex != null) {
return lvIndex;
}
List<VarNode> args = mth.collectArgNodes();
for (VarNode arg : args) {
lvIndex = arg.getReg() - args.get(0).getReg() + (mth.getAccessFlags().isStatic() ? 0 : 1);
if (arg.equals(methodArg)) {
break;
}
}
return lvIndex;
}
public static Integer getMethodArgLvIndex(SSAVar methodArgSsaVar, MethodNode mth) {
return getMethodArgLvIndexViaSsaVars(methodArgSsaVar.getRegNum(), mth);
}
private static Integer getMethodArgLvIndexViaSsaVars(int regNum, MethodNode mth) {
List<SSAVar> ssaVars = mth.getSVars();
if (!ssaVars.isEmpty()) {
return regNum - ssaVars.get(0).getRegNum();
}
return null;
}
// Method vars
public static int getMethodVarLvIndex(VarNode methodVar) {
MethodNode mth = methodVar.getMth();
Integer lvIndex = getMethodVarLvIndexViaSsaVars(methodVar.getReg(), mth);
if (lvIndex != null) {
return lvIndex;
}
Integer lastArgLvIndex = mth.getAccessFlags().isStatic() ? -1 : 0;
List<VarNode> args = mth.collectArgNodes();
if (!args.isEmpty()) {
lastArgLvIndex = getMethodArgLvIndex(args.get(args.size() - 1));
}
return lastArgLvIndex + methodVar.getReg() + (mth.getAccessFlags().isStatic() ? 0 : 1);
}
public static Integer getMethodVarLvIndex(SSAVar methodVarSsaVar, MethodNode mth) {
return getMethodVarLvIndexViaSsaVars(methodVarSsaVar.getRegNum(), mth);
}
private static Integer getMethodVarLvIndexViaSsaVars(int regNum, MethodNode mth) {
List<SSAVar> ssaVars = mth.getSVars();
if (ssaVars.isEmpty()) {
return null;
}
Integer lastArgLvIndex = mth.getAccessFlags().isStatic() ? -1 : 0;
List<RegisterArg> args = mth.getArgRegs();
if (!args.isEmpty()) {
lastArgLvIndex = getMethodArgLvIndexViaSsaVars(args.get(args.size() - 1).getSVar().getRegNum(), mth);
}
return lastArgLvIndex + regNum + (mth.getAccessFlags().isStatic() ? 0 : 1);
}
// ****************************
// Local variable table index
// ****************************
// Method args
public static Integer getMethodArgLvtIndex(VarNode methodArg) {
MethodNode mth = methodArg.getMth();
int lvtIndex = mth.getAccessFlags().isStatic() ? 0 : 1;
List<VarNode> args = mth.collectArgNodes();
for (VarNode arg : args) {
if (arg.equals(methodArg)) {
return lvtIndex;
}
lvtIndex++;
}
return null;
}
public static Integer getMethodArgLvtIndex(SSAVar methodArgSsaVar, MethodNode mth) {
List<SSAVar> ssaVars = mth.getSVars();
if (ssaVars.isEmpty()) {
return null;
}
List<RegisterArg> args = mth.getArgRegs();
int lvtIndex = mth.getAccessFlags().isStatic() ? 0 : 1;
for (RegisterArg arg : args) {
if (arg.getSVar().equals(methodArgSsaVar)) {
return lvtIndex;
}
lvtIndex++;
}
return null;
}
// Method vars
// TODO: public static Integer getMethodVarLvtIndex(VarNode methodVar) {}
public static Integer getMethodVarLvtIndex(SSAVar methodVarSsaVar, MethodNode mth) {
List<SSAVar> ssaVars = new ArrayList<>(mth.getSVars());
if (ssaVars.isEmpty()) {
return null;
}
Integer lvtIndex = getMethodArgLvtIndex(methodVarSsaVar, mth);
if (lvtIndex != null) {
return lvtIndex;
}
lvtIndex = mth.getAccessFlags().isStatic() ? 0 : 1;
lvtIndex += mth.getArgTypes().size();
lvtIndex = getMethodArgLvtIndex(methodVarSsaVar, mth) + 1;
ssaVars.subList(0, ssaVars.indexOf(methodVarSsaVar) + 1).clear();
int lastRegNum = -1;
for (SSAVar ssaVar : ssaVars) {
if (ssaVar.getRegNum() == lastRegNum) {
// Not present in bytecode
// System.out.println("Duplicate RegNum: " + ssaVar.getRegNum());
continue;
}
lvtIndex++;
if (ssaVar.equals(methodVarSsaVar)) {
return lvtIndex;
}
lastRegNum = ssaVar.getRegNum();
}
return null;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/load/CodeMappingsPass.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/load/CodeMappingsPass.java | package jadx.plugins.mappings.load;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.fabricmc.mappingio.tree.MappingTreeView;
import net.fabricmc.mappingio.tree.MappingTreeView.ClassMappingView;
import net.fabricmc.mappingio.tree.MappingTreeView.MethodArgMappingView;
import net.fabricmc.mappingio.tree.MappingTreeView.MethodMappingView;
import jadx.api.plugins.pass.JadxPassInfo;
import jadx.api.plugins.pass.impl.OrderedJadxPassInfo;
import jadx.api.plugins.pass.types.JadxDecompilePass;
import jadx.core.dex.instructions.args.SSAVar;
import jadx.core.dex.nodes.ClassNode;
import jadx.core.dex.nodes.MethodNode;
import jadx.core.dex.nodes.RootNode;
import jadx.plugins.mappings.RenameMappingsData;
import jadx.plugins.mappings.utils.DalvikToJavaBytecodeUtils;
public class CodeMappingsPass implements JadxDecompilePass {
private Map<String, ClassMappingView> clsRenamesMap;
@Override
public JadxPassInfo getInfo() {
return new OrderedJadxPassInfo(
"CodeMappings",
"Apply mappings to method args and vars")
.before("CodeRenameVisitor");
}
@Override
public void init(RootNode root) {
RenameMappingsData data = RenameMappingsData.getData(root);
if (data == null) {
return;
}
MappingTreeView mappingTree = data.getMappings();
updateMappingsMap(mappingTree);
root.registerCodeDataUpdateListener(codeData -> updateMappingsMap(mappingTree));
}
@Override
public boolean visit(ClassNode cls) {
ClassMappingView classMapping = getMapping(cls);
if (classMapping != null) {
applyRenames(cls, classMapping);
}
cls.getInnerClasses().forEach(this::visit);
return false;
}
@Override
public void visit(MethodNode mth) {
}
private static void applyRenames(ClassNode cls, ClassMappingView classMapping) {
for (MethodNode mth : cls.getMethods()) {
String methodName = mth.getMethodInfo().getName();
String methodDesc = mth.getMethodInfo().getShortId().substring(methodName.length());
List<SSAVar> ssaVars = mth.getSVars();
if (ssaVars.isEmpty()) {
continue;
}
MethodMappingView methodMapping = classMapping.getMethod(methodName, methodDesc);
if (methodMapping == null) {
continue;
}
// Method args
for (MethodArgMappingView argMapping : methodMapping.getArgs()) {
Integer mappingLvIndex = argMapping.getLvIndex();
for (SSAVar ssaVar : ssaVars) {
Integer actualLvIndex = DalvikToJavaBytecodeUtils.getMethodArgLvIndex(ssaVar, mth);
if (actualLvIndex.equals(mappingLvIndex)) {
ssaVar.getCodeVar().setName(argMapping.getDstName(0));
break;
}
}
}
// TODO: Method vars (if ever feasible)
}
}
private ClassMappingView getMapping(ClassNode cls) {
if (clsRenamesMap == null || clsRenamesMap.isEmpty()) {
return null;
}
String classPath = cls.getClassInfo().makeRawFullName().replace('.', '/');
return clsRenamesMap.get(classPath);
}
private void updateMappingsMap(MappingTreeView mappings) {
clsRenamesMap = new HashMap<>();
for (ClassMappingView cls : mappings.getClasses()) {
for (MethodMappingView mth : cls.getMethods()) {
if (!mth.getArgs().isEmpty() || !mth.getVars().isEmpty()) {
clsRenamesMap.put(cls.getSrcName(), cls);
break;
}
}
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/load/LoadMappingsPass.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/load/LoadMappingsPass.java | package jadx.plugins.mappings.load;
import java.nio.file.Path;
import java.util.Collections;
import net.fabricmc.mappingio.MappingReader;
import net.fabricmc.mappingio.MappingUtil;
import net.fabricmc.mappingio.adapter.MappingSourceNsSwitch;
import net.fabricmc.mappingio.tree.MappingTreeView;
import net.fabricmc.mappingio.tree.MemoryMappingTree;
import net.fabricmc.mappingio.tree.VisitableMappingTree;
import jadx.api.JadxArgs;
import jadx.api.plugins.pass.JadxPassInfo;
import jadx.api.plugins.pass.impl.SimpleJadxPassInfo;
import jadx.api.plugins.pass.types.JadxPreparePass;
import jadx.core.dex.nodes.RootNode;
import jadx.core.utils.exceptions.JadxRuntimeException;
import jadx.plugins.mappings.RenameMappingsData;
import jadx.plugins.mappings.RenameMappingsOptions;
public class LoadMappingsPass implements JadxPreparePass {
private final RenameMappingsOptions options;
public LoadMappingsPass(RenameMappingsOptions options) {
this.options = options;
}
@Override
public JadxPassInfo getInfo() {
return new SimpleJadxPassInfo("LoadMappings", "Load mappings file");
}
@Override
public void init(RootNode root) {
MappingTreeView mappings = loadMapping(root.getArgs());
root.getAttributes().add(new RenameMappingsData(mappings));
}
private MappingTreeView loadMapping(JadxArgs args) {
try {
Path mappingsPath = args.getUserRenamesMappingsPath();
VisitableMappingTree mappingTree = new MemoryMappingTree();
MappingReader.read(mappingsPath, options.getFormat(), mappingTree);
if (mappingTree.getSrcNamespace() == null) {
mappingTree.setSrcNamespace(MappingUtil.NS_SOURCE_FALLBACK);
}
if (mappingTree.getDstNamespaces() == null || mappingTree.getDstNamespaces().isEmpty()) {
mappingTree.setDstNamespaces(Collections.singletonList(MappingUtil.NS_TARGET_FALLBACK));
} else if (mappingTree.getDstNamespaces().size() > 1) {
throw new JadxRuntimeException(
String.format("JADX only supports mappings with just one destination namespace! The provided ones have %s.",
mappingTree.getDstNamespaces().size()));
}
if (options.isInvert()) {
VisitableMappingTree invertedMappingTree = new MemoryMappingTree();
String dstNamespace = mappingTree.getDstNamespaces().get(0);
mappingTree.accept(new MappingSourceNsSwitch(invertedMappingTree, dstNamespace));
return invertedMappingTree;
}
return mappingTree;
} catch (Exception e) {
throw new JadxRuntimeException("Failed to load mappings", e);
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/load/ApplyMappingsPass.java | jadx-plugins/jadx-rename-mappings/src/main/java/jadx/plugins/mappings/load/ApplyMappingsPass.java | package jadx.plugins.mappings.load;
import net.fabricmc.mappingio.tree.MappingTreeView;
import net.fabricmc.mappingio.tree.MappingTreeView.ClassMappingView;
import net.fabricmc.mappingio.tree.MappingTreeView.FieldMappingView;
import net.fabricmc.mappingio.tree.MappingTreeView.MethodMappingView;
import jadx.api.plugins.pass.JadxPassInfo;
import jadx.api.plugins.pass.impl.OrderedJadxPassInfo;
import jadx.api.plugins.pass.types.JadxPreparePass;
import jadx.core.codegen.TypeGen;
import jadx.core.dex.info.FieldInfo;
import jadx.core.dex.info.MethodInfo;
import jadx.core.dex.nodes.ClassNode;
import jadx.core.dex.nodes.FieldNode;
import jadx.core.dex.nodes.MethodNode;
import jadx.core.dex.nodes.RootNode;
import jadx.plugins.mappings.RenameMappingsData;
public class ApplyMappingsPass implements JadxPreparePass {
@Override
public JadxPassInfo getInfo() {
return new OrderedJadxPassInfo(
"ApplyMappings",
"Apply mappings to classes, fields and methods")
.after("LoadMappings")
.before("RenameVisitor");
}
@Override
public void init(RootNode root) {
RenameMappingsData data = RenameMappingsData.getData(root);
if (data == null) {
return;
}
MappingTreeView mappingTree = data.getMappings();
process(root, mappingTree);
root.registerCodeDataUpdateListener(codeData -> process(root, mappingTree));
}
private void process(RootNode root, MappingTreeView mappingTree) {
for (ClassNode cls : root.getClasses()) {
String clsRawName = cls.getClassInfo().getRawName().replace('.', '/');
ClassMappingView mapping = mappingTree.getClass(clsRawName);
if (mapping != null) {
processClass(cls, mapping);
}
}
}
private static void processClass(ClassNode cls, ClassMappingView classMapping) {
String alias = classMapping.getDstName(0);
if (alias != null) {
cls.rename(alias.replace('/', '.'));
}
if (classMapping.getComment() != null) {
cls.addCodeComment(classMapping.getComment());
}
for (FieldNode field : cls.getFields()) {
FieldInfo fieldInfo = field.getFieldInfo();
String signature = TypeGen.signature(fieldInfo.getType());
FieldMappingView fieldMapping = classMapping.getField(fieldInfo.getName(), signature);
if (fieldMapping != null) {
processField(field, fieldMapping);
}
}
for (MethodNode method : cls.getMethods()) {
MethodInfo methodInfo = method.getMethodInfo();
String methodName = methodInfo.getName();
String methodDesc = methodInfo.getShortId().substring(methodName.length());
MethodMappingView methodMapping = classMapping.getMethod(methodName, methodDesc);
if (methodMapping != null) {
processMethod(method, methodMapping);
}
}
}
private static void processField(FieldNode field, FieldMappingView fieldMapping) {
String alias = fieldMapping.getDstName(0);
if (alias != null) {
field.rename(alias);
}
String comment = fieldMapping.getComment();
if (comment != null) {
field.addCodeComment(comment);
}
}
private static void processMethod(MethodNode method, MethodMappingView methodMapping) {
String alias = methodMapping.getDstName(0);
if (alias != null) {
method.rename(alias);
}
String comment = methodMapping.getComment();
if (comment != null) {
method.addCodeComment(comment);
}
// Method args & vars are handled in CodeMappingsPass
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/XApkInputPlugin.java | jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/XApkInputPlugin.java | package jadx.plugins.input.xapk;
import jadx.api.plugins.JadxPlugin;
import jadx.api.plugins.JadxPluginContext;
import jadx.api.plugins.JadxPluginInfo;
import jadx.api.plugins.JadxPluginInfoBuilder;
public class XApkInputPlugin implements JadxPlugin {
private XApkLoader loader;
@Override
public JadxPluginInfo getPluginInfo() {
return JadxPluginInfoBuilder.pluginId("xapk-input")
.name("XApk Input")
.description("Load .xapk files")
.build();
}
@Override
public void init(JadxPluginContext context) {
loader = new XApkLoader(context);
XApkCustomInput customInput = new XApkCustomInput(context, loader);
context.addCodeInput(customInput);
context.getDecompiler().addCustomResourcesLoader(customInput);
}
@Override
public void unload() {
if (loader != null) {
loader.unload();
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/XApkCustomInput.java | jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/XApkCustomInput.java | package jadx.plugins.input.xapk;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import jadx.api.ResourceFile;
import jadx.api.ResourcesLoader;
import jadx.api.plugins.CustomResourcesLoader;
import jadx.api.plugins.JadxPluginContext;
import jadx.api.plugins.input.ICodeLoader;
import jadx.api.plugins.input.JadxCodeInput;
import jadx.api.plugins.input.data.impl.EmptyCodeLoader;
import jadx.plugins.input.dex.DexInputPlugin;
import jadx.plugins.input.xapk.data.XApkData;
public class XApkCustomInput implements JadxCodeInput, CustomResourcesLoader {
private final JadxPluginContext context;
private final XApkLoader loader;
public XApkCustomInput(JadxPluginContext context, XApkLoader loader) {
this.context = context;
this.loader = loader;
}
@Override
public ICodeLoader loadFiles(List<Path> input) {
List<Path> apks = new ArrayList<>();
for (Path inputPath : input) {
XApkData data = loader.checkAndLoad(inputPath);
if (data != null) {
apks.addAll(data.getApks());
}
}
if (apks.isEmpty()) {
return EmptyCodeLoader.INSTANCE;
}
DexInputPlugin dexInputPlugin = context.plugins().getInstance(DexInputPlugin.class);
return dexInputPlugin.loadFiles(apks);
}
@Override
public boolean load(ResourcesLoader resLoader, List<ResourceFile> list, File file) {
XApkData xApkData = loader.checkAndLoad(file.toPath());
if (xApkData == null) {
return false;
}
for (Path apkPath : xApkData.getApks()) {
resLoader.defaultLoadFile(list, apkPath.toFile(), apkPath.getFileName() + "/");
}
for (Path filePath : xApkData.getFiles()) {
resLoader.defaultLoadFile(list, filePath.toFile(), "");
}
return true;
}
@Override
public void close() throws IOException {
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/XApkLoader.java | jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/XApkLoader.java | package jadx.plugins.input.xapk;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jadx.api.plugins.JadxPluginContext;
import jadx.core.utils.GsonUtils;
import jadx.core.utils.files.FileUtils;
import jadx.plugins.input.xapk.data.SplitApk;
import jadx.plugins.input.xapk.data.XApkData;
import jadx.plugins.input.xapk.data.XApkManifest;
import jadx.zip.IZipEntry;
import jadx.zip.ZipContent;
public class XApkLoader {
private static final Logger LOG = LoggerFactory.getLogger(XApkLoader.class);
private final JadxPluginContext context;
private final Map<String, XApkData> loaded = new HashMap<>();
public XApkLoader(JadxPluginContext context) {
this.context = context;
}
public @Nullable XApkData checkAndLoad(Path inputPath) {
String fileName = inputPath.getFileName().toString();
if (!fileName.toLowerCase(Locale.ROOT).endsWith(".xapk")) {
return null;
}
try {
XApkData loadedData = getLoaded(inputPath);
if (loadedData != null) {
return loadedData;
}
File xapkFile = inputPath.toFile();
if (!FileUtils.isZipFile(xapkFile)) {
return null;
}
try (ZipContent content = context.getZipReader().open(xapkFile)) {
IZipEntry manifestEntry = content.searchEntry("manifest.json");
if (manifestEntry == null) {
return null;
}
String manifestStr = new String(manifestEntry.getBytes(), StandardCharsets.UTF_8);
XApkManifest xApkManifest = GsonUtils.buildGson().fromJson(manifestStr, XApkManifest.class);
if (xApkManifest.getVersion() != 2 || xApkManifest.getSplitApks().isEmpty()) {
return null;
}
// checks complete
// unpack all files into temp directory
XApkData xApkData = unpackXApk(xapkFile, xApkManifest, content);
saveLoaded(inputPath, xApkData);
return xApkData;
}
} catch (Exception e) {
LOG.warn("Failed to load XApk file: {}", inputPath.toAbsolutePath(), e);
return null;
}
}
private XApkData unpackXApk(File xapkFile, XApkManifest xApkManifest, ZipContent content) throws IOException {
Set<String> declaredApks = xApkManifest.getSplitApks().stream()
.map(SplitApk::getFile).collect(Collectors.toSet());
List<Path> apks = new ArrayList<>(declaredApks.size());
List<Path> files = new ArrayList<>();
String dirName = xapkFile.getName() + '_' + System.currentTimeMillis();
Path tmpDir = context.files().getPluginTempDir().resolve(dirName);
FileUtils.makeDirs(tmpDir);
for (IZipEntry entry : content.getEntries()) {
String fileName = entry.getName();
Path file = tmpDir.resolve(fileName);
try (InputStream inputStream = entry.getInputStream()) {
Files.copy(inputStream, file, StandardCopyOption.REPLACE_EXISTING);
}
if (declaredApks.contains(fileName)) {
apks.add(file);
} else {
files.add(file);
}
}
return new XApkData(xApkManifest, tmpDir, apks, files);
}
private XApkData getLoaded(Path inputPath) throws IOException {
return loaded.get(pathToKey(inputPath));
}
private void saveLoaded(Path inputPath, XApkData xApkData) throws IOException {
loaded.put(pathToKey(inputPath), xApkData);
}
private static String pathToKey(Path path) throws IOException {
return path.toRealPath(LinkOption.NOFOLLOW_LINKS).toString();
}
public synchronized void unload() {
for (XApkData data : loaded.values()) {
FileUtils.deleteDirIfExists(data.getTmpDir());
}
loaded.clear();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/data/XApkData.java | jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/data/XApkData.java | package jadx.plugins.input.xapk.data;
import java.nio.file.Path;
import java.util.List;
public class XApkData {
private final XApkManifest manifest;
private final Path tmpDir;
private final List<Path> files;
private final List<Path> apks;
public XApkData(XApkManifest manifest, Path tmpDir, List<Path> apks, List<Path> files) {
this.manifest = manifest;
this.tmpDir = tmpDir;
this.apks = apks;
this.files = files;
}
public List<Path> getApks() {
return apks;
}
public List<Path> getFiles() {
return files;
}
public XApkManifest getManifest() {
return manifest;
}
public Path getTmpDir() {
return tmpDir;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/data/SplitApk.java | jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/data/SplitApk.java | package jadx.plugins.input.xapk.data;
public class SplitApk {
private String file;
private String id;
public String getFile() {
return file;
}
public void setFile(String file) {
this.file = file;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/data/XApkManifest.java | jadx-plugins/jadx-xapk-input/src/main/java/jadx/plugins/input/xapk/data/XApkManifest.java | package jadx.plugins.input.xapk.data;
import java.util.List;
import com.google.gson.annotations.SerializedName;
public class XApkManifest {
@SerializedName("xapk_version")
int version;
@SerializedName("split_apks")
List<SplitApk> splitApks;
public List<SplitApk> getSplitApks() {
return splitApks;
}
public void setSplitApks(List<SplitApk> splitApks) {
this.splitApks = splitApks;
}
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/ICodeLoader.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/ICodeLoader.java | package jadx.api.plugins.input;
import java.io.Closeable;
import java.util.function.Consumer;
import jadx.api.plugins.input.data.IClassData;
public interface ICodeLoader extends Closeable {
void visitClasses(Consumer<IClassData> consumer);
boolean isEmpty();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/JadxCodeInput.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/JadxCodeInput.java | package jadx.api.plugins.input;
import java.nio.file.Path;
import java.util.List;
public interface JadxCodeInput {
ICodeLoader loadFiles(List<Path> input);
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/InsnIndexType.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/InsnIndexType.java | package jadx.api.plugins.input.insns;
public enum InsnIndexType {
NONE,
TYPE_REF,
STRING_REF,
FIELD_REF,
METHOD_REF,
CALL_SITE
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/Opcode.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/Opcode.java | package jadx.api.plugins.input.insns;
public enum Opcode {
UNKNOWN,
NOP,
ADD_DOUBLE,
ADD_FLOAT,
ADD_INT,
ADD_INT_LIT,
ADD_LONG,
AND_INT,
AND_INT_LIT,
AND_LONG,
AGET,
AGET_BOOLEAN,
AGET_BYTE,
AGET_BYTE_BOOLEAN,
AGET_CHAR,
AGET_OBJECT,
AGET_SHORT,
AGET_WIDE,
APUT,
APUT_BOOLEAN,
APUT_BYTE,
APUT_BYTE_BOOLEAN,
APUT_CHAR,
APUT_OBJECT,
APUT_SHORT,
APUT_WIDE,
ARITH,
ARRAY_LENGTH,
CAST,
CHECK_CAST,
CMPG_DOUBLE,
CMPG_FLOAT,
CMPL_DOUBLE,
CMPL_FLOAT,
CMP_LONG,
CONST,
CONST_CLASS,
CONST_STRING,
CONST_WIDE,
DIV_DOUBLE,
DIV_FLOAT,
DIV_INT,
DIV_INT_LIT,
DIV_LONG,
DOUBLE_TO_FLOAT,
DOUBLE_TO_INT,
DOUBLE_TO_LONG,
FLOAT_TO_DOUBLE,
FLOAT_TO_INT,
FLOAT_TO_LONG,
GOTO,
IF,
IF_EQ,
IF_EQZ,
IF_GE,
IF_GEZ,
IF_GT,
IF_GTZ,
IF_LE,
IF_LEZ,
IF_LT,
IF_LTZ,
IF_NE,
IF_NEZ,
INSTANCE_OF,
INT_TO_BYTE,
INT_TO_CHAR,
INT_TO_DOUBLE,
INT_TO_FLOAT,
INT_TO_LONG,
INT_TO_SHORT,
INVOKE_DIRECT,
INVOKE_DIRECT_RANGE,
INVOKE_INTERFACE,
INVOKE_INTERFACE_RANGE,
INVOKE_STATIC,
INVOKE_STATIC_RANGE,
INVOKE_SUPER,
INVOKE_SUPER_RANGE,
INVOKE_VIRTUAL,
INVOKE_VIRTUAL_RANGE,
INVOKE_SPECIAL,
IGET,
IPUT,
SGET,
SPUT,
LONG_TO_DOUBLE,
LONG_TO_FLOAT,
LONG_TO_INT,
MONITOR_ENTER,
MONITOR_EXIT,
MOVE,
MOVE_MULTI,
MOVE_EXCEPTION,
MOVE_OBJECT,
MOVE_RESULT,
MOVE_WIDE,
MUL_DOUBLE,
MUL_FLOAT,
MUL_INT,
MUL_INT_LIT,
MUL_LONG,
NEG,
NEG_DOUBLE,
NEG_FLOAT,
NEG_INT,
NEG_LONG,
NEW_INSTANCE,
NOT_INT,
NOT_LONG,
OR_INT,
OR_INT_LIT,
OR_LONG,
REM_DOUBLE,
REM_FLOAT,
REM_INT,
REM_INT_LIT,
REM_LONG,
RETURN,
RETURN_VOID,
RSUB_INT,
SHL_INT,
SHL_INT_LIT,
SHL_LONG,
SHR_INT,
SHR_INT_LIT,
SHR_LONG,
SUB_DOUBLE,
SUB_FLOAT,
SUB_INT,
SUB_LONG,
THROW,
USHR_INT,
USHR_INT_LIT,
USHR_LONG,
XOR_INT,
XOR_INT_LIT,
XOR_LONG,
NEW_ARRAY,
FILLED_NEW_ARRAY,
FILLED_NEW_ARRAY_RANGE,
FILL_ARRAY_DATA,
FILL_ARRAY_DATA_PAYLOAD,
PACKED_SWITCH,
PACKED_SWITCH_PAYLOAD,
SPARSE_SWITCH,
SPARSE_SWITCH_PAYLOAD,
INVOKE_POLYMORPHIC,
INVOKE_POLYMORPHIC_RANGE,
INVOKE_CUSTOM,
INVOKE_CUSTOM_RANGE,
CONST_METHOD_HANDLE,
CONST_METHOD_TYPE,
// Java specific dynamic jump instructions
JAVA_JSR,
JAVA_RET,
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/InsnData.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/InsnData.java | package jadx.api.plugins.input.insns;
import jadx.api.plugins.input.data.ICallSite;
import jadx.api.plugins.input.data.IFieldRef;
import jadx.api.plugins.input.data.IMethodHandle;
import jadx.api.plugins.input.data.IMethodProto;
import jadx.api.plugins.input.data.IMethodRef;
import jadx.api.plugins.input.insns.custom.ICustomPayload;
public interface InsnData {
void decode();
int getOffset(); // offset within method
int getFileOffset(); // offset within dex file
Opcode getOpcode();
String getOpcodeMnemonic();
byte[] getByteCode();
InsnIndexType getIndexType();
int getRawOpcodeUnit();
int getRegsCount();
int getReg(int argNum);
/**
* Workaround to set result reg without additional move-result insn
*
* @return result reg number or -1 if not needed
*/
int getResultReg();
long getLiteral();
int getTarget();
int getIndex();
String getIndexAsString();
String getIndexAsType();
IFieldRef getIndexAsField();
IMethodRef getIndexAsMethod();
ICallSite getIndexAsCallSite();
IMethodProto getIndexAsProto(int protoIndex);
IMethodHandle getIndexAsMethodHandle();
ICustomPayload getPayload();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/IArrayPayload.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/IArrayPayload.java | package jadx.api.plugins.input.insns.custom;
public interface IArrayPayload extends ICustomPayload {
int getSize();
int getElementSize();
Object getData();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/ISwitchPayload.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/ISwitchPayload.java | package jadx.api.plugins.input.insns.custom;
public interface ISwitchPayload extends ICustomPayload {
int getSize();
int[] getKeys();
int[] getTargets();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/ICustomPayload.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/ICustomPayload.java | package jadx.api.plugins.input.insns.custom;
public interface ICustomPayload {
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/impl/SwitchPayload.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/insns/custom/impl/SwitchPayload.java | package jadx.api.plugins.input.insns.custom.impl;
import jadx.api.plugins.input.insns.custom.ISwitchPayload;
public class SwitchPayload implements ISwitchPayload {
private final int size;
private final int[] keys;
private final int[] targets;
public SwitchPayload(int size, int[] keys, int[] targets) {
this.size = size;
this.keys = keys;
this.targets = targets;
}
@Override
public int getSize() {
return size;
}
@Override
public int[] getKeys() {
return keys;
}
@Override
public int[] getTargets() {
return targets;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ICallSite.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ICallSite.java | package jadx.api.plugins.input.data;
import java.util.List;
import jadx.api.plugins.input.data.annotations.EncodedValue;
import jadx.api.plugins.input.insns.custom.ICustomPayload;
public interface ICallSite extends ICustomPayload {
List<EncodedValue> getValues();
void load();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ITry.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ITry.java | package jadx.api.plugins.input.data;
public interface ITry {
ICatch getCatch();
int getStartOffset();
int getEndOffset();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IFieldData.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IFieldData.java | package jadx.api.plugins.input.data;
import java.util.List;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
public interface IFieldData extends IFieldRef {
int getAccessFlags();
List<IJadxAttribute> getAttributes();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodProto.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodProto.java | package jadx.api.plugins.input.data;
import java.util.List;
public interface IMethodProto {
String getReturnType();
List<String> getArgTypes();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodRef.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodRef.java | package jadx.api.plugins.input.data;
import jadx.api.plugins.input.insns.custom.ICustomPayload;
public interface IMethodRef extends IMethodProto, ICustomPayload {
/**
* Method unique id (will be used for caching).
*
* @return 0 if can't calculate good unique identifier (disable caching)
*/
int getUniqId();
/**
* Lazy loading for method info, until load() is called only getUniqId() can be used
*/
void load();
String getParentClassType();
String getName();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IFieldRef.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IFieldRef.java | package jadx.api.plugins.input.data;
public interface IFieldRef {
String getParentClassType();
String getName();
String getType();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodData.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodData.java | package jadx.api.plugins.input.data;
import java.util.List;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
public interface IMethodData {
IMethodRef getMethodRef();
int getAccessFlags();
@Nullable
ICodeReader getCodeReader();
String disassembleMethod();
List<IJadxAttribute> getAttributes();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IResourceData.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IResourceData.java | package jadx.api.plugins.input.data;
public interface IResourceData {
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IDebugInfo.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IDebugInfo.java | package jadx.api.plugins.input.data;
import java.util.List;
import java.util.Map;
public interface IDebugInfo {
/**
* Map instruction offset to source line number
*/
Map<Integer, Integer> getSourceLineMapping();
List<ILocalVar> getLocalVars();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/AccessFlagsScope.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/AccessFlagsScope.java | package jadx.api.plugins.input.data;
public enum AccessFlagsScope {
CLASS, FIELD, METHOD
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/AccessFlags.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/AccessFlags.java | package jadx.api.plugins.input.data;
public class AccessFlags {
public static final int PUBLIC = 0x1;
public static final int PRIVATE = 0x2;
public static final int PROTECTED = 0x4;
public static final int STATIC = 0x8;
public static final int FINAL = 0x10;
public static final int SYNCHRONIZED = 0x20;
public static final int SUPER = 0x20;
public static final int VOLATILE = 0x40;
public static final int BRIDGE = 0x40;
public static final int TRANSIENT = 0x80;
public static final int VARARGS = 0x80;
public static final int NATIVE = 0x100;
public static final int INTERFACE = 0x200;
public static final int ABSTRACT = 0x400;
public static final int STRICT = 0x800;
public static final int SYNTHETIC = 0x1000;
public static final int ANNOTATION = 0x2000;
public static final int ENUM = 0x4000;
public static final int MODULE = 0x8000;
public static final int CONSTRUCTOR = 0x10000;
public static final int DECLARED_SYNCHRONIZED = 0x20000;
public static final int DATA = 0x40000;
public static boolean hasFlag(int flags, int flagValue) {
return (flags & flagValue) != 0;
}
public static String format(int flags, AccessFlagsScope scope) {
StringBuilder code = new StringBuilder();
if (hasFlag(flags, PUBLIC)) {
code.append("public ");
}
if (hasFlag(flags, PRIVATE)) {
code.append("private ");
}
if (hasFlag(flags, PROTECTED)) {
code.append("protected ");
}
if (hasFlag(flags, STATIC)) {
code.append("static ");
}
if (hasFlag(flags, FINAL)) {
code.append("final ");
}
if (hasFlag(flags, ABSTRACT)) {
code.append("abstract ");
}
if (hasFlag(flags, NATIVE)) {
code.append("native ");
}
switch (scope) {
case METHOD:
if (hasFlag(flags, SYNCHRONIZED)) {
code.append("synchronized ");
}
if (hasFlag(flags, BRIDGE)) {
code.append("bridge ");
}
if (hasFlag(flags, VARARGS)) {
code.append("varargs ");
}
break;
case FIELD:
if (hasFlag(flags, VOLATILE)) {
code.append("volatile ");
}
if (hasFlag(flags, TRANSIENT)) {
code.append("transient ");
}
break;
case CLASS:
if (hasFlag(flags, MODULE)) {
code.append("module ");
}
if (hasFlag(flags, STRICT)) {
code.append("strict ");
}
if (hasFlag(flags, SUPER)) {
code.append("super ");
}
if (hasFlag(flags, ENUM)) {
code.append("enum ");
}
if (hasFlag(flags, DATA)) {
code.append("data ");
}
break;
}
if (hasFlag(flags, SYNTHETIC)) {
code.append("synthetic ");
}
return code.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodHandle.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IMethodHandle.java | package jadx.api.plugins.input.data;
public interface IMethodHandle {
MethodHandleType getType();
IFieldRef getFieldRef();
IMethodRef getMethodRef();
void load();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IClassData.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/IClassData.java | package jadx.api.plugins.input.data;
import java.util.List;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
public interface IClassData {
IClassData copy();
String getInputFileName();
String getType();
int getAccessFlags();
@Nullable
String getSuperType();
List<String> getInterfacesTypes();
void visitFieldsAndMethods(ISeqConsumer<IFieldData> fieldsConsumer, ISeqConsumer<IMethodData> mthConsumer);
List<IJadxAttribute> getAttributes();
String getDisassembledCode();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ISeqConsumer.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ISeqConsumer.java | package jadx.api.plugins.input.data;
import java.util.function.Consumer;
/**
* "Sequence consumer" allows getting count of elements available
*/
public interface ISeqConsumer<T> extends Consumer<T> {
default void init(int count) {
// no-op implementation
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ICodeReader.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ICodeReader.java | package jadx.api.plugins.input.data;
import java.util.List;
import java.util.function.Consumer;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.insns.InsnData;
public interface ICodeReader {
ICodeReader copy();
void visitInstructions(Consumer<InsnData> insnConsumer);
int getRegistersCount();
int getArgsStartReg();
int getUnitsCount();
@Nullable
IDebugInfo getDebugInfo();
int getCodeOffset();
List<ITry> getTries();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ILocalVar.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ILocalVar.java | package jadx.api.plugins.input.data;
import org.jetbrains.annotations.Nullable;
public interface ILocalVar {
String getName();
int getRegNum();
String getType();
@Nullable
String getSignature();
int getStartOffset();
int getEndOffset();
/**
* Hint if variable is a method parameter.
* Can be incorrect and shouldn't be trusted.
*/
boolean isMarkedAsParameter();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/MethodHandleType.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/MethodHandleType.java | package jadx.api.plugins.input.data;
public enum MethodHandleType {
STATIC_PUT,
STATIC_GET,
INSTANCE_PUT,
INSTANCE_GET,
INVOKE_STATIC,
INVOKE_INSTANCE,
INVOKE_DIRECT,
INVOKE_CONSTRUCTOR,
INVOKE_INTERFACE;
public boolean isField() {
switch (this) {
case STATIC_PUT:
case STATIC_GET:
case INSTANCE_PUT:
case INSTANCE_GET:
return true;
default:
return false;
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ICatch.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/ICatch.java | package jadx.api.plugins.input.data;
public interface ICatch {
String[] getTypes();
int[] getHandlers();
int getCatchAllHandler();
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/AnnotationVisibility.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/AnnotationVisibility.java | package jadx.api.plugins.input.data.annotations;
public enum AnnotationVisibility {
BUILD,
RUNTIME,
SYSTEM
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/EncodedValue.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/EncodedValue.java | package jadx.api.plugins.input.data.annotations;
import java.util.Objects;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class EncodedValue extends PinnedAttribute {
public static final EncodedValue NULL = new EncodedValue(EncodedType.ENCODED_NULL, null);
private final EncodedType type;
private final Object value;
public EncodedValue(EncodedType type, Object value) {
this.type = type;
this.value = value;
}
public EncodedType getType() {
return type;
}
public Object getValue() {
return value;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
EncodedValue that = (EncodedValue) o;
return type == that.getType() && Objects.equals(value, that.getValue());
}
@Override
public IJadxAttrType<? extends IJadxAttribute> getAttrType() {
return JadxAttrType.CONSTANT_VALUE;
}
@Override
public int hashCode() {
return Objects.hash(getType(), getValue());
}
@Override
public String toString() {
switch (type) {
case ENCODED_NULL:
return "null";
case ENCODED_ARRAY:
return "[" + value + "]";
case ENCODED_STRING:
return "{STRING: \"" + value + "\"}";
default:
return "{" + type.toString().substring(8) + ": " + value + '}';
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/IAnnotation.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/IAnnotation.java | package jadx.api.plugins.input.data.annotations;
import java.util.Map;
import org.jetbrains.annotations.Nullable;
public interface IAnnotation {
String getAnnotationClass();
AnnotationVisibility getVisibility();
Map<String, EncodedValue> getValues();
@Nullable
default EncodedValue getDefaultValue() {
return getValues().get("value");
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/EncodedType.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/EncodedType.java | package jadx.api.plugins.input.data.annotations;
public enum EncodedType {
ENCODED_NULL,
ENCODED_BOOLEAN,
ENCODED_BYTE,
ENCODED_SHORT,
ENCODED_CHAR,
ENCODED_INT,
ENCODED_LONG,
ENCODED_FLOAT,
ENCODED_DOUBLE,
ENCODED_STRING,
ENCODED_TYPE,
ENCODED_ENUM,
ENCODED_FIELD,
ENCODED_METHOD,
ENCODED_METHOD_TYPE,
ENCODED_METHOD_HANDLE,
ENCODED_ARRAY,
ENCODED_ANNOTATION
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/JadxAnnotation.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/annotations/JadxAnnotation.java | package jadx.api.plugins.input.data.annotations;
import java.util.Map;
public class JadxAnnotation implements IAnnotation {
private final AnnotationVisibility visibility;
private final String type;
private final Map<String, EncodedValue> values;
public JadxAnnotation(AnnotationVisibility visibility, String type, Map<String, EncodedValue> values) {
this.visibility = visibility;
this.type = type;
this.values = values;
}
@Override
public String getAnnotationClass() {
return type;
}
@Override
public AnnotationVisibility getVisibility() {
return visibility;
}
@Override
public Map<String, EncodedValue> getValues() {
return values;
}
@Override
public String toString() {
return "Annotation{" + visibility + ", type=" + type + ", values=" + values + '}';
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/CallSite.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/CallSite.java | package jadx.api.plugins.input.data.impl;
import java.util.List;
import jadx.api.plugins.input.data.ICallSite;
import jadx.api.plugins.input.data.IMethodHandle;
import jadx.api.plugins.input.data.IMethodRef;
import jadx.api.plugins.input.data.annotations.EncodedValue;
public class CallSite implements ICallSite {
private final List<EncodedValue> values;
public CallSite(List<EncodedValue> values) {
this.values = values;
}
@Override
public void load() {
for (EncodedValue value : values) {
switch (value.getType()) {
case ENCODED_METHOD_HANDLE:
((IMethodHandle) value.getValue()).load();
break;
case ENCODED_METHOD:
((IMethodRef) value.getValue()).load();
break;
}
}
}
@Override
public List<EncodedValue> getValues() {
return values;
}
@Override
public String toString() {
return "CallSite{" + values + '}';
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/JadxFieldRef.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/JadxFieldRef.java | package jadx.api.plugins.input.data.impl;
import jadx.api.plugins.input.data.IFieldRef;
public class JadxFieldRef implements IFieldRef {
private String parentClassType;
private String name;
private String type;
public JadxFieldRef() {
}
public JadxFieldRef(String parentClassType, String name, String type) {
this.parentClassType = parentClassType;
this.name = name;
this.type = type;
}
@Override
public String getParentClassType() {
return parentClassType;
}
public void setParentClassType(String parentClassType) {
this.parentClassType = parentClassType;
}
@Override
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public String toString() {
return parentClassType + "->" + name + ":" + type;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/MergeCodeLoader.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/MergeCodeLoader.java | package jadx.api.plugins.input.data.impl;
import java.io.Closeable;
import java.io.IOException;
import java.util.List;
import java.util.function.Consumer;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.ICodeLoader;
import jadx.api.plugins.input.data.IClassData;
public class MergeCodeLoader implements ICodeLoader {
private final List<ICodeLoader> codeLoaders;
private final @Nullable Closeable closeable;
public MergeCodeLoader(List<ICodeLoader> codeLoaders) {
this(codeLoaders, null);
}
public MergeCodeLoader(List<ICodeLoader> codeLoaders, @Nullable Closeable closeable) {
this.codeLoaders = codeLoaders;
this.closeable = closeable;
}
@Override
public void visitClasses(Consumer<IClassData> consumer) {
for (ICodeLoader codeLoader : codeLoaders) {
codeLoader.visitClasses(consumer);
}
}
@Override
public boolean isEmpty() {
for (ICodeLoader codeLoader : codeLoaders) {
if (!codeLoader.isEmpty()) {
return false;
}
}
return true;
}
@Override
public void close() throws IOException {
for (ICodeLoader codeLoader : codeLoaders) {
codeLoader.close();
}
if (closeable != null) {
closeable.close();
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/CatchData.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/CatchData.java | package jadx.api.plugins.input.data.impl;
import jadx.api.plugins.input.data.ICatch;
import static jadx.api.plugins.input.data.impl.InputUtils.formatOffset;
public class CatchData implements ICatch {
private final int[] handlers;
private final String[] types;
private final int allHandler;
public CatchData(int[] handlers, String[] types, int allHandler) {
this.handlers = handlers;
this.types = types;
this.allHandler = allHandler;
}
@Override
public int[] getHandlers() {
return handlers;
}
@Override
public String[] getTypes() {
return types;
}
@Override
public int getCatchAllHandler() {
return allHandler;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("Catch:");
int size = types.length;
for (int i = 0; i < size; i++) {
sb.append(' ').append(types[i]).append("->").append(formatOffset(handlers[i]));
}
if (allHandler != -1) {
sb.append(" all->").append(formatOffset(allHandler));
}
return sb.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/FieldRefHandle.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/FieldRefHandle.java | package jadx.api.plugins.input.data.impl;
import jadx.api.plugins.input.data.IFieldRef;
import jadx.api.plugins.input.data.IMethodHandle;
import jadx.api.plugins.input.data.IMethodRef;
import jadx.api.plugins.input.data.MethodHandleType;
public class FieldRefHandle implements IMethodHandle {
private final IFieldRef fieldRef;
private final MethodHandleType type;
public FieldRefHandle(MethodHandleType type, IFieldRef fieldRef) {
this.fieldRef = fieldRef;
this.type = type;
}
@Override
public MethodHandleType getType() {
return type;
}
@Override
public IFieldRef getFieldRef() {
return fieldRef;
}
@Override
public IMethodRef getMethodRef() {
return null;
}
@Override
public void load() {
// already loaded
}
@Override
public String toString() {
return type + ": " + fieldRef;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/TryData.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/TryData.java | package jadx.api.plugins.input.data.impl;
import jadx.api.plugins.input.data.ICatch;
import jadx.api.plugins.input.data.ITry;
import static jadx.api.plugins.input.data.impl.InputUtils.formatOffset;
public class TryData implements ITry {
private final int startOffset;
private final int endOffset;
private final ICatch catchHandler;
public TryData(int startOffset, int endOffset, ICatch catchHandler) {
this.startOffset = startOffset;
this.endOffset = endOffset;
this.catchHandler = catchHandler;
}
@Override
public ICatch getCatch() {
return catchHandler;
}
@Override
public int getStartOffset() {
return startOffset;
}
@Override
public int getEndOffset() {
return endOffset;
}
@Override
public String toString() {
return "Try{" + formatOffset(startOffset) + " - " + formatOffset(endOffset) + ": " + catchHandler + '}';
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/InputUtils.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/InputUtils.java | package jadx.api.plugins.input.data.impl;
public class InputUtils {
public static String formatOffset(int offset) {
return String.format("0x%04x", offset);
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/EmptyCodeLoader.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/EmptyCodeLoader.java | package jadx.api.plugins.input.data.impl;
import java.io.IOException;
import java.util.function.Consumer;
import jadx.api.plugins.input.ICodeLoader;
import jadx.api.plugins.input.data.IClassData;
public class EmptyCodeLoader implements ICodeLoader {
public static final EmptyCodeLoader INSTANCE = new EmptyCodeLoader();
@Override
public boolean isEmpty() {
return true;
}
@Override
public void visitClasses(Consumer<IClassData> consumer) {
}
@Override
public void close() throws IOException {
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/MethodRefHandle.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/MethodRefHandle.java | package jadx.api.plugins.input.data.impl;
import jadx.api.plugins.input.data.IFieldData;
import jadx.api.plugins.input.data.IMethodHandle;
import jadx.api.plugins.input.data.IMethodRef;
import jadx.api.plugins.input.data.MethodHandleType;
public class MethodRefHandle implements IMethodHandle {
private final MethodHandleType type;
private final IMethodRef methodRef;
public MethodRefHandle(MethodHandleType type, IMethodRef methodRef) {
this.type = type;
this.methodRef = methodRef;
}
@Override
public MethodHandleType getType() {
return type;
}
@Override
public IMethodRef getMethodRef() {
return methodRef;
}
@Override
public IFieldData getFieldRef() {
return null;
}
@Override
public void load() {
methodRef.load();
}
@Override
public String toString() {
return type + ": " + methodRef;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/DebugInfo.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/DebugInfo.java | package jadx.api.plugins.input.data.impl;
import java.util.List;
import java.util.Map;
import jadx.api.plugins.input.data.IDebugInfo;
import jadx.api.plugins.input.data.ILocalVar;
public class DebugInfo implements IDebugInfo {
private final Map<Integer, Integer> sourceLineMap;
private final List<ILocalVar> localVars;
public DebugInfo(Map<Integer, Integer> sourceLineMap, List<ILocalVar> localVars) {
this.sourceLineMap = sourceLineMap;
this.localVars = localVars;
}
@Override
public Map<Integer, Integer> getSourceLineMapping() {
return sourceLineMap;
}
@Override
public List<ILocalVar> getLocalVars() {
return localVars;
}
@Override
public String toString() {
return "DebugInfo{lines=" + sourceLineMap + ", localVars=" + localVars + '}';
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/ListConsumer.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/impl/ListConsumer.java | package jadx.api.plugins.input.data.impl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import jadx.api.plugins.input.data.ISeqConsumer;
public class ListConsumer<T, R> implements ISeqConsumer<T> {
private final Function<T, R> convert;
private List<R> list;
public ListConsumer(Function<T, R> convert) {
this.convert = convert;
}
@Override
public void init(int count) {
list = count == 0 ? Collections.emptyList() : new ArrayList<>(count);
}
@Override
public void accept(T t) {
list.add(convert.apply(t));
}
public List<R> getResult() {
if (list == null) {
// init not called
return Collections.emptyList();
}
return list;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/JadxAttrType.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/JadxAttrType.java | package jadx.api.plugins.input.data.attributes;
import jadx.api.plugins.input.data.annotations.EncodedValue;
import jadx.api.plugins.input.data.attributes.types.AnnotationDefaultAttr;
import jadx.api.plugins.input.data.attributes.types.AnnotationDefaultClassAttr;
import jadx.api.plugins.input.data.attributes.types.AnnotationMethodParamsAttr;
import jadx.api.plugins.input.data.attributes.types.AnnotationsAttr;
import jadx.api.plugins.input.data.attributes.types.ExceptionsAttr;
import jadx.api.plugins.input.data.attributes.types.InnerClassesAttr;
import jadx.api.plugins.input.data.attributes.types.MethodParametersAttr;
import jadx.api.plugins.input.data.attributes.types.SignatureAttr;
import jadx.api.plugins.input.data.attributes.types.SourceFileAttr;
public final class JadxAttrType<T extends IJadxAttribute> implements IJadxAttrType<T> {
// class, method, field
public static final JadxAttrType<AnnotationsAttr> ANNOTATION_LIST = bind();
public static final JadxAttrType<SignatureAttr> SIGNATURE = bind();
// class
public static final JadxAttrType<SourceFileAttr> SOURCE_FILE = bind();
public static final JadxAttrType<InnerClassesAttr> INNER_CLASSES = bind();
public static final JadxAttrType<AnnotationDefaultClassAttr> ANNOTATION_DEFAULT_CLASS = bind(); // dex specific
// field
public static final JadxAttrType<EncodedValue> CONSTANT_VALUE = bind();
// method
public static final JadxAttrType<AnnotationMethodParamsAttr> ANNOTATION_MTH_PARAMETERS = bind();
public static final JadxAttrType<AnnotationDefaultAttr> ANNOTATION_DEFAULT = bind();
public static final JadxAttrType<ExceptionsAttr> EXCEPTIONS = bind();
public static final JadxAttrType<MethodParametersAttr> METHOD_PARAMETERS = bind();
private static <T extends IJadxAttribute> JadxAttrType<T> bind() {
return new JadxAttrType<>();
}
private JadxAttrType() {
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/IJadxAttrType.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/IJadxAttrType.java | package jadx.api.plugins.input.data.attributes;
/**
* Marker interface for attribute type.
* Similar to enumeration but extensible.
* <p>
* Used for attach attribute instance class information (T).
* T - class of attribute instance
* <p>
* To create new one define static field like this:
* {@code
* static final IJadxAttrType<AttrTypeClass> ATTR_TYPE = IJadxAttrType.create();
* }
*/
public interface IJadxAttrType<T extends IJadxAttribute> {
static <A extends IJadxAttribute> IJadxAttrType<A> create() {
return new IJadxAttrType<>() {
};
}
static <A extends IJadxAttribute> IJadxAttrType<A> create(String name) {
return new IJadxAttrType<>() {
@Override
public String toString() {
return name;
}
};
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/IJadxAttribute.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/IJadxAttribute.java | package jadx.api.plugins.input.data.attributes;
/**
* Jadx attribute: custom data container, can be added to most jadx nodes.
*/
public interface IJadxAttribute {
IJadxAttrType<? extends IJadxAttribute> getAttrType();
/**
* Mark type to skip unloading on node unload event
*/
default boolean keepLoaded() {
return false;
}
default String toAttrString() {
return this.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/PinnedAttribute.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/PinnedAttribute.java | package jadx.api.plugins.input.data.attributes;
public abstract class PinnedAttribute implements IJadxAttribute {
@Override
public final boolean keepLoaded() {
return true;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/ExceptionsAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/ExceptionsAttr.java | package jadx.api.plugins.input.data.attributes.types;
import java.util.List;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class ExceptionsAttr extends PinnedAttribute {
private final List<String> list;
public ExceptionsAttr(List<String> list) {
this.list = list;
}
public List<String> getList() {
return list;
}
@Override
public IJadxAttrType<ExceptionsAttr> getAttrType() {
return JadxAttrType.EXCEPTIONS;
}
@Override
public String toString() {
return "EXCEPTIONS:" + list;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationsAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationsAttr.java | package jadx.api.plugins.input.data.attributes.types;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.annotations.AnnotationVisibility;
import jadx.api.plugins.input.data.annotations.IAnnotation;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class AnnotationsAttr extends PinnedAttribute {
@Nullable
public static AnnotationsAttr pack(List<IAnnotation> annotationList) {
if (annotationList.isEmpty()) {
return null;
}
Map<String, IAnnotation> annMap = new HashMap<>(annotationList.size());
for (IAnnotation ann : annotationList) {
if (ann.getVisibility() != AnnotationVisibility.SYSTEM) {
annMap.put(ann.getAnnotationClass(), ann);
}
}
if (annMap.isEmpty()) {
return null;
}
return new AnnotationsAttr(annMap);
}
private final Map<String, IAnnotation> map;
public AnnotationsAttr(Map<String, IAnnotation> map) {
this.map = map;
}
public IAnnotation get(String className) {
return map.get(className);
}
public Collection<IAnnotation> getAll() {
return map.values();
}
public List<IAnnotation> getList() {
return map.isEmpty() ? Collections.emptyList() : new ArrayList<>(map.values());
}
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
@Override
public JadxAttrType<AnnotationsAttr> getAttrType() {
return JadxAttrType.ANNOTATION_LIST;
}
@Override
public String toString() {
return map.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/SignatureAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/SignatureAttr.java | package jadx.api.plugins.input.data.attributes.types;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class SignatureAttr extends PinnedAttribute {
private final String signature;
public SignatureAttr(String signature) {
this.signature = signature;
}
public String getSignature() {
return signature;
}
@Override
public IJadxAttrType<? extends IJadxAttribute> getAttrType() {
return JadxAttrType.SIGNATURE;
}
@Override
public String toString() {
return "SIGNATURE: " + signature;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/SourceFileAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/SourceFileAttr.java | package jadx.api.plugins.input.data.attributes.types;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class SourceFileAttr extends PinnedAttribute {
private final String fileName;
public SourceFileAttr(String fileName) {
this.fileName = fileName;
}
public String getFileName() {
return fileName;
}
@Override
public IJadxAttrType<SourceFileAttr> getAttrType() {
return JadxAttrType.SOURCE_FILE;
}
@Override
public String toString() {
return "SOURCE:" + fileName;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/MethodParametersAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/MethodParametersAttr.java | package jadx.api.plugins.input.data.attributes.types;
import java.util.List;
import jadx.api.plugins.input.data.AccessFlags;
import jadx.api.plugins.input.data.AccessFlagsScope;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class MethodParametersAttr extends PinnedAttribute {
public static class Info {
private final int accFlags;
private final String name;
public Info(int accFlags, String name) {
this.accFlags = accFlags;
this.name = name;
}
public int getAccFlags() {
return accFlags;
}
public String getName() {
return name;
}
public String toString() {
return AccessFlags.format(accFlags, AccessFlagsScope.METHOD) + name;
}
}
private final List<Info> list;
public MethodParametersAttr(List<Info> list) {
this.list = list;
}
public List<Info> getList() {
return list;
}
@Override
public IJadxAttrType<MethodParametersAttr> getAttrType() {
return JadxAttrType.METHOD_PARAMETERS;
}
@Override
public String toString() {
return "METHOD_PARAMETERS: " + list;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/InnerClsInfo.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/InnerClsInfo.java | package jadx.api.plugins.input.data.attributes.types;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.AccessFlags;
import jadx.api.plugins.input.data.AccessFlagsScope;
public class InnerClsInfo {
private final String innerCls;
private final @Nullable String outerCls;
private final @Nullable String name;
private final int accessFlags;
public InnerClsInfo(String innerCls, @Nullable String outerCls, @Nullable String name, int accessFlags) {
this.innerCls = innerCls;
this.outerCls = outerCls;
this.name = name;
this.accessFlags = accessFlags;
}
public String getInnerCls() {
return innerCls;
}
public @Nullable String getOuterCls() {
return outerCls;
}
public @Nullable String getName() {
return name;
}
public int getAccessFlags() {
return accessFlags;
}
@Override
public String toString() {
return "InnerCls{" + innerCls
+ ", outerCls=" + outerCls
+ ", name=" + name
+ ", accessFlags=" + AccessFlags.format(accessFlags, AccessFlagsScope.CLASS)
+ '}';
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationMethodParamsAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationMethodParamsAttr.java | package jadx.api.plugins.input.data.attributes.types;
import java.util.ArrayList;
import java.util.List;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.annotations.IAnnotation;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class AnnotationMethodParamsAttr extends PinnedAttribute {
@Nullable
public static AnnotationMethodParamsAttr pack(List<List<IAnnotation>> annotationRefList) {
if (annotationRefList.isEmpty()) {
return null;
}
List<AnnotationsAttr> list = new ArrayList<>(annotationRefList.size());
for (List<IAnnotation> annList : annotationRefList) {
list.add(AnnotationsAttr.pack(annList));
}
return new AnnotationMethodParamsAttr(list);
}
private final List<AnnotationsAttr> paramList;
private AnnotationMethodParamsAttr(List<AnnotationsAttr> paramsList) {
this.paramList = paramsList;
}
public List<AnnotationsAttr> getParamList() {
return paramList;
}
@Override
public JadxAttrType<AnnotationMethodParamsAttr> getAttrType() {
return JadxAttrType.ANNOTATION_MTH_PARAMETERS;
}
@Override
public String toString() {
return paramList.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/InnerClassesAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/InnerClassesAttr.java | package jadx.api.plugins.input.data.attributes.types;
import java.util.Map;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class InnerClassesAttr extends PinnedAttribute {
private final Map<String, InnerClsInfo> map;
public InnerClassesAttr(Map<String, InnerClsInfo> map) {
this.map = map;
}
public Map<String, InnerClsInfo> getMap() {
return map;
}
@Override
public IJadxAttrType<InnerClassesAttr> getAttrType() {
return JadxAttrType.INNER_CLASSES;
}
@Override
public String toString() {
return "INNER_CLASSES:" + map;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationDefaultClassAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationDefaultClassAttr.java | package jadx.api.plugins.input.data.attributes.types;
import java.util.Map;
import jadx.api.plugins.input.data.annotations.EncodedValue;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class AnnotationDefaultClassAttr extends PinnedAttribute {
private final Map<String, EncodedValue> values;
public AnnotationDefaultClassAttr(Map<String, EncodedValue> values) {
this.values = values;
}
public Map<String, EncodedValue> getValues() {
return values;
}
@Override
public IJadxAttrType<? extends IJadxAttribute> getAttrType() {
return JadxAttrType.ANNOTATION_DEFAULT_CLASS;
}
@Override
public String toString() {
return "ANNOTATION_DEFAULT_CLASS: " + values;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationDefaultAttr.java | jadx-plugins/jadx-input-api/src/main/java/jadx/api/plugins/input/data/attributes/types/AnnotationDefaultAttr.java | package jadx.api.plugins.input.data.attributes.types;
import jadx.api.plugins.input.data.annotations.EncodedValue;
import jadx.api.plugins.input.data.attributes.IJadxAttrType;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.input.data.attributes.JadxAttrType;
import jadx.api.plugins.input.data.attributes.PinnedAttribute;
public class AnnotationDefaultAttr extends PinnedAttribute {
private final EncodedValue value;
public AnnotationDefaultAttr(EncodedValue value) {
this.value = value;
}
public EncodedValue getValue() {
return value;
}
@Override
public IJadxAttrType<? extends IJadxAttribute> getAttrType() {
return JadxAttrType.ANNOTATION_DEFAULT;
}
@Override
public String toString() {
return "ANNOTATION_DEFAULT: " + value;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/test/java/jadx/plugins/input/java/CustomLoadTest.java | jadx-plugins/jadx-java-input/src/test/java/jadx/plugins/input/java/CustomLoadTest.java | package jadx.plugins.input.java;
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.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import jadx.api.JadxArgs;
import jadx.api.JadxDecompiler;
import jadx.api.plugins.input.ICodeLoader;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
class CustomLoadTest {
private JadxDecompiler jadx;
@BeforeEach
void init() {
jadx = new JadxDecompiler(new JadxArgs());
}
@AfterEach
void close() {
jadx.close();
}
@Test
void loadFiles() {
List<Path> files = Stream.of("HelloWorld.class", "HelloWorld$HelloInner.class")
.map(this::getSample)
.collect(Collectors.toList());
ICodeLoader loadResult = JavaInputPlugin.loadClassFiles(files);
loadDecompiler(loadResult);
assertThat(jadx.getClassesWithInners())
.hasSize(2)
.satisfiesOnlyOnce(cls -> assertThat(cls.getName()).isEqualTo("HelloWorld"))
.satisfiesOnlyOnce(cls -> assertThat(cls.getName()).isEqualTo("HelloInner"));
}
@Test
void loadFromInputStream() throws IOException {
String fileName = "HelloWorld$HelloInner.class";
try (InputStream in = Files.newInputStream(getSample(fileName))) {
ICodeLoader loadResult = JavaInputPlugin.loadFromInputStream(in, fileName);
loadDecompiler(loadResult);
assertThat(jadx.getClassesWithInners())
.hasSize(1)
.satisfiesOnlyOnce(cls -> assertThat(cls.getName()).isEqualTo("HelloWorld$HelloInner"));
System.out.println(jadx.getClassesWithInners().get(0).getCode());
}
}
@Test
void loadSingleClass() throws IOException {
String fileName = "HelloWorld.class";
byte[] content = Files.readAllBytes(getSample(fileName));
ICodeLoader loadResult = JavaInputPlugin.loadSingleClass(content, fileName);
loadDecompiler(loadResult);
assertThat(jadx.getClassesWithInners())
.hasSize(1)
.satisfiesOnlyOnce(cls -> assertThat(cls.getName()).isEqualTo("HelloWorld"));
System.out.println(jadx.getClassesWithInners().get(0).getCode());
}
@Test
void load() {
ICodeLoader loadResult = JavaInputPlugin.load(loader -> {
List<JavaClassReader> inputs = new ArrayList<>(2);
try {
String hello = "HelloWorld.class";
byte[] content = Files.readAllBytes(getSample(hello));
inputs.add(loader.loadClass(content, hello));
String helloInner = "HelloWorld$HelloInner.class";
InputStream in = Files.newInputStream(getSample(helloInner));
inputs.addAll(loader.loadInputStream(in, helloInner));
} catch (Exception e) {
fail(e);
}
return inputs;
});
loadDecompiler(loadResult);
assertThat(jadx.getClassesWithInners())
.hasSize(2)
.satisfiesOnlyOnce(cls -> assertThat(cls.getName()).isEqualTo("HelloWorld"))
.satisfiesOnlyOnce(cls -> {
assertThat(cls.getName()).isEqualTo("HelloInner");
assertThat(cls.getCode()).isEmpty(); // no code for moved inner class
});
assertThat(jadx.getClasses())
.hasSize(1)
.satisfiesOnlyOnce(cls -> assertThat(cls.getName()).isEqualTo("HelloWorld"))
.satisfiesOnlyOnce(cls -> assertThat(cls.getInnerClasses()).hasSize(1)
.satisfiesOnlyOnce(inner -> assertThat(inner.getName()).isEqualTo("HelloInner")));
jadx.getClassesWithInners().forEach(cls -> System.out.println(cls.getCode()));
}
public void loadDecompiler(ICodeLoader codeLoader) {
try {
jadx.addCustomCodeLoader(codeLoader);
jadx.load();
} catch (Exception e) {
fail("Failed to load sample", e);
}
}
public Path getSample(String name) {
try {
return Paths.get(ClassLoader.getSystemResource("samples/" + name).toURI());
} catch (Exception e) {
return fail("Failed to load sample", e);
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/test/java/jadx/plugins/input/java/utils/ModifiedUTF8DecoderTest.java | jadx-plugins/jadx-java-input/src/test/java/jadx/plugins/input/java/utils/ModifiedUTF8DecoderTest.java | package jadx.plugins.input.java.utils;
import org.junit.jupiter.api.Test;
import static jadx.plugins.input.java.utils.ModifiedUTF8Decoder.decodeString;
import static org.assertj.core.api.Assertions.assertThat;
/*
* TODO: find a way to enter 6-bytes char decode branch
*/
class ModifiedUTF8DecoderTest {
@Test
public void test() {
String str = "aÆřᛒቶ北𝄠😀🨄𐆙";
byte[] mUTF8Bytes = new byte[] { 97, -61, -122, -59, -103, -31, -101, -110, -31, -119, -74, -17,
-91, -93, -19, -96, -76, -19, -76, -96, -19, -96, -67, -19, -72,
-128, -19, -96, -66, -19, -72, -124, -19, -96, -128, -19, -74, -103 };
assertThat(decodeString(mUTF8Bytes)).isEqualTo(str);
}
@Test
public void testASCIIOnly() {
String str = "Hello, world!";
byte[] mUTF8Bytes = new byte[] { 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33 };
assertThat(decodeString(mUTF8Bytes)).isEqualTo(str);
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/test/java/jadx/plugins/input/java/utils/DescriptorParserTest.java | jadx-plugins/jadx-java-input/src/test/java/jadx/plugins/input/java/utils/DescriptorParserTest.java | package jadx.plugins.input.java.utils;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
import jadx.plugins.input.java.data.JavaMethodRef;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
class DescriptorParserTest {
@Test
public void testPrimitives() {
check("()V", "V");
check("(I)D", "D", "I");
}
@Test
public void testObjects() {
check("(Ljava/lang/String;Ljava/lang/Object;)V", "V", "Ljava/lang/String;", "Ljava/lang/Object;");
}
@SuppressWarnings("CatchMayIgnoreException")
private void check(String desc, String retType, String... argTypes) {
JavaMethodRef mthRef = new JavaMethodRef();
try {
DescriptorParser.fillMethodProto(desc, mthRef);
} catch (Exception e) {
fail("Parse failed for: " + desc, e);
}
assertThat(mthRef.getReturnType()).isEqualTo(retType);
assertThat(mthRef.getArgTypes()).isEqualTo(Arrays.asList(argTypes));
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaClassReader.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaClassReader.java | package jadx.plugins.input.java;
import jadx.api.plugins.input.data.IClassData;
import jadx.plugins.input.java.data.JavaClassData;
public class JavaClassReader {
private final int id;
private final String fileName;
private final byte[] data;
public JavaClassReader(int id, String fileName, byte[] data) {
this.id = id;
this.fileName = fileName;
this.data = data;
}
public IClassData loadClassData() {
return new JavaClassData(this);
}
public int getId() {
return id;
}
public String getFileName() {
return fileName;
}
public byte[] getData() {
return data;
}
@Override
public String toString() {
return fileName;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaInputPlugin.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaInputPlugin.java | package jadx.plugins.input.java;
import java.io.Closeable;
import java.io.InputStream;
import java.nio.file.Path;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.JadxPlugin;
import jadx.api.plugins.JadxPluginContext;
import jadx.api.plugins.JadxPluginInfo;
import jadx.api.plugins.input.ICodeLoader;
import jadx.api.plugins.input.data.impl.EmptyCodeLoader;
import jadx.plugins.input.java.utils.JavaClassParseException;
public class JavaInputPlugin implements JadxPlugin {
@Override
public JadxPluginInfo getPluginInfo() {
return new JadxPluginInfo("java-input", "Java Input", "Load .class and .jar files");
}
@Override
public void init(JadxPluginContext context) {
context.addCodeInput(inputFiles -> {
JavaInputLoader loader = new JavaInputLoader(context.getZipReader(), context.files().getPluginTempDir());
List<JavaClassReader> readers = loader.collectFiles(inputFiles);
if (readers.isEmpty()) {
return EmptyCodeLoader.INSTANCE;
}
return new JavaLoadResult(readers, null);
});
}
public static ICodeLoader loadClassFiles(List<Path> inputFiles) {
return loadClassFiles(inputFiles, null);
}
public static ICodeLoader loadClassFiles(List<Path> inputFiles, @Nullable Closeable closeable) {
List<JavaClassReader> readers = new JavaInputLoader().collectFiles(inputFiles);
if (readers.isEmpty()) {
return EmptyCodeLoader.INSTANCE;
}
return new JavaLoadResult(readers, closeable);
}
/**
* Method for provide several inputs by using load methods from {@link JavaInputLoader} class.
*/
public static ICodeLoader load(Function<JavaInputLoader, List<JavaClassReader>> loader) {
return wrapClassReaders(loader.apply(new JavaInputLoader()));
}
/**
* Convenient method for load class file or jar from input stream.
* Should be used only once per JadxDecompiler instance.
* For load several times use {@link JavaInputPlugin#load(Function)} method.
*/
public static ICodeLoader loadFromInputStream(InputStream in, String fileName) {
try {
return wrapClassReaders(new JavaInputLoader().loadInputStream(in, fileName));
} catch (Exception e) {
throw new JavaClassParseException("Failed to read input stream", e);
}
}
/**
* Convenient method for load single class file by content.
* Should be used only once per JadxDecompiler instance.
* For load several times use {@link JavaInputPlugin#load(Function)} method.
*/
public static ICodeLoader loadSingleClass(byte[] content, String fileName) {
JavaClassReader reader = new JavaInputLoader().loadClass(content, fileName);
return new JavaLoadResult(Collections.singletonList(reader));
}
public static ICodeLoader wrapClassReaders(List<JavaClassReader> readers) {
if (readers.isEmpty()) {
return EmptyCodeLoader.INSTANCE;
}
return new JavaLoadResult(readers);
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaInputLoader.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaInputLoader.java | package jadx.plugins.input.java;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jadx.api.plugins.utils.CommonFileUtils;
import jadx.core.plugins.files.TempFilesGetter;
import jadx.core.utils.files.FileUtils;
import jadx.zip.IZipEntry;
import jadx.zip.ZipContent;
import jadx.zip.ZipReader;
public class JavaInputLoader {
private static final Logger LOG = LoggerFactory.getLogger(JavaInputLoader.class);
private static final int MAX_MAGIC_SIZE = 4;
private static final byte[] JAVA_CLASS_FILE_MAGIC = { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE };
private static final byte[] ZIP_FILE_MAGIC = { 0x50, 0x4B, 0x03, 0x04 };
private final ZipReader zipReader;
private final Path tempPath;
private int classUniqId = 1;
public JavaInputLoader(ZipReader zipReader, Path tempPath) {
this.zipReader = zipReader;
this.tempPath = tempPath;
}
/**
* This will use zip reader with default options and ignore provided in jadx args
*/
@Deprecated
public JavaInputLoader() {
this(new ZipReader(), TempFilesGetter.INSTANCE.getTempDir());
}
public List<JavaClassReader> collectFiles(List<Path> inputFiles) {
return inputFiles.stream()
.map(Path::toFile)
.map(this::loadFromFile)
.filter(list -> !list.isEmpty())
.flatMap(Collection::stream)
.collect(Collectors.toList());
}
public List<JavaClassReader> loadInputStream(InputStream in, String name) throws IOException {
return loadReader(in, name, null, null);
}
public JavaClassReader loadClass(byte[] content, String fileName) {
return new JavaClassReader(getNextUniqId(), fileName, content);
}
private List<JavaClassReader> loadFromFile(File file) {
try (InputStream inputStream = new BufferedInputStream(new FileInputStream(file))) {
return loadReader(inputStream, file.getName(), file, null);
} catch (Exception e) {
LOG.error("File open error: {}", file.getAbsolutePath(), e);
return Collections.emptyList();
}
}
private List<JavaClassReader> loadReader(InputStream in, String name,
@Nullable File file, @Nullable String parentFileName) throws IOException {
byte[] magic = new byte[MAX_MAGIC_SIZE];
if (in.read(magic) != magic.length) {
return Collections.emptyList();
}
if (isStartWithBytes(magic, JAVA_CLASS_FILE_MAGIC) || name.endsWith(".class")) {
byte[] data = CommonFileUtils.loadBytes(magic, in);
String source = concatSource(parentFileName, name);
JavaClassReader reader = new JavaClassReader(getNextUniqId(), source, data);
return Collections.singletonList(reader);
}
if (isStartWithBytes(magic, ZIP_FILE_MAGIC) || CommonFileUtils.isZipFileExt(name)) {
if (file != null) {
return collectFromZip(file, name);
}
File zipFile = CommonFileUtils.saveToTempFile(magic, in, ".zip").toFile();
List<JavaClassReader> readers = collectFromZip(zipFile, concatSource(parentFileName, name));
CommonFileUtils.safeDeleteFile(zipFile);
return readers;
}
return Collections.emptyList();
}
private List<JavaClassReader> loadReaderFromZipEntry(byte[] content, String name, String parentFileName) throws IOException {
if (isStartWithBytes(content, JAVA_CLASS_FILE_MAGIC) || name.endsWith(".class")) {
String source = concatSource(parentFileName, name);
JavaClassReader reader = new JavaClassReader(getNextUniqId(), source, content);
return Collections.singletonList(reader);
}
if (isStartWithBytes(content, ZIP_FILE_MAGIC) || CommonFileUtils.isZipFileExt(name)) {
Path tempZip = Files.createTempFile(tempPath, "temp", ".zip");
FileUtils.writeFile(tempZip, content);
File zipFile = tempZip.toFile();
List<JavaClassReader> readers = collectFromZip(zipFile, concatSource(parentFileName, name));
CommonFileUtils.safeDeleteFile(zipFile);
return readers;
}
return Collections.emptyList();
}
private static String concatSource(@Nullable String parentFileName, String name) {
if (parentFileName == null) {
return name;
}
return parentFileName + ':' + name;
}
private List<JavaClassReader> collectFromZip(File file, String name) {
List<JavaClassReader> result = new ArrayList<>();
try (ZipContent zip = zipReader.open(file)) {
for (IZipEntry entry : zip.getEntries()) {
if (entry.isDirectory()) {
continue;
}
String entryName = entry.getName();
if (entryName.startsWith("META-INF/versions/")) {
// skip classes for different java versions
continue;
}
try {
List<JavaClassReader> readers;
if (entry.preferBytes()) {
readers = loadReaderFromZipEntry(entry.getBytes(), entryName, name);
} else {
readers = loadReader(entry.getInputStream(), entryName, null, name);
}
result.addAll(readers);
} catch (Exception e) {
LOG.error("Failed to read zip entry: {}", entry, e);
}
}
} catch (Exception e) {
LOG.error("Failed to process zip file: {}", name, e);
}
return result;
}
public static boolean isStartWithBytes(byte[] fileMagic, byte[] expectedBytes) {
int len = expectedBytes.length;
if (fileMagic.length < len) {
return false;
}
for (int i = 0; i < len; i++) {
if (fileMagic[i] != expectedBytes[i]) {
return false;
}
}
return true;
}
private int getNextUniqId() {
return classUniqId++;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaLoadResult.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/JavaLoadResult.java | package jadx.plugins.input.java;
import java.io.Closeable;
import java.io.IOException;
import java.util.List;
import java.util.function.Consumer;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jadx.api.plugins.input.ICodeLoader;
import jadx.api.plugins.input.data.IClassData;
public class JavaLoadResult implements ICodeLoader {
private static final Logger LOG = LoggerFactory.getLogger(JavaLoadResult.class);
private final List<JavaClassReader> readers;
@Nullable
private final Closeable closeable;
public JavaLoadResult(List<JavaClassReader> readers) {
this(readers, null);
}
public JavaLoadResult(List<JavaClassReader> readers, @Nullable Closeable closeable) {
this.readers = readers;
this.closeable = closeable;
}
@Override
public void visitClasses(Consumer<IClassData> consumer) {
for (JavaClassReader reader : readers) {
try {
consumer.accept(reader.loadClassData());
} catch (Exception e) {
LOG.error("Failed to load class data for file: {}", reader.getFileName(), e);
}
}
}
@Override
public boolean isEmpty() {
return readers.isEmpty();
}
@Override
public void close() throws IOException {
if (closeable != null) {
closeable.close();
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/JavaClassParseException.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/JavaClassParseException.java | package jadx.plugins.input.java.utils;
public class JavaClassParseException extends RuntimeException {
private static final long serialVersionUID = -8452845601753645491L;
public JavaClassParseException(String message, Throwable cause) {
super(message, cause);
}
public JavaClassParseException(String message) {
super(message);
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/ModifiedUTF8Decoder.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/ModifiedUTF8Decoder.java | package jadx.plugins.input.java.utils;
import java.nio.charset.StandardCharsets;
public class ModifiedUTF8Decoder {
public static String decodeString(byte[] bytes) {
int len = bytes.length;
// quick check if all chars are 7-bit
boolean asciiStr = true;
for (byte b : bytes) {
if ((b & 0x80) != 0) {
asciiStr = false;
break;
}
}
if (asciiStr) {
return new String(bytes, StandardCharsets.US_ASCII);
}
// parse modified UTF-8 according jvms-4.4.7
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i++) {
int x = bytes[i] & 0xff;
// 4.4 ascii characters 1-127 (0 is encoded as 0xc0 0x80)
if ((x & 0x80) == 0) {
// 1 byte 7-Bit ascii (Table 4.4./4.5)
sb.append((char) x);
} else {
if (i + 1 >= len) {
throw new JavaClassParseException("Inconsistent byte array structure: too short");
}
int y = bytes[i + 1] & 0xff;
// 0 is encoded as 0xc0 0x80 (jvms-4.4.7)
if (x == 0xc0 && y == 0x80) {
sb.appendCodePoint(0);
i++;
} else if ((x & 0xE0) == 0xC0 && (y & 0xC0) == 0x80) {
// 2 byte char (Table 4.8./4.9 )
sb.appendCodePoint(((x & 0x1f) << 6) + (y & 0x3f));
i++;
} else if (i + 2 < len) {
int z = bytes[i + 2] & 0xff;
if ((x & 0xF0) == 0xE0 && (y & 0xC0) == 0x80 && (z & 0xC0) == 0x80) {
// 3 byte char (Table 4.11/4.12)
sb.appendCodePoint(((x & 0xf) << 12) + ((y & 0x3f) << 6) + (z & 0x3f));
i += 2;
} else if (i + 5 < len
&& x == 0xED // u
&& (y & 0xF0) == 0xA0 // v
&& (bytes[i + 3] & 0xff) == 0xED // x
&& (bytes[i + 4] & 0xF0) == 0xA0 // y
) {
// 6 byte encoded Table 4.12.
int u = x; // 0
int v = y; // 1
int w = z; // 2
x = bytes[i + 3] & 0xff;
y = bytes[i + 4] & 0xff;
z = bytes[i + 5] & 0xff;
if (x == 0xED && (y & 0xF0) == 0xA0) {
sb.appendCodePoint(0x10000 + ((v & 0x0f) << 16) + ((w & 0x3f) << 10) + ((y & 0x0f) << 6) + (z & 0x3f));
i += 5;
} else {
throw new JavaClassParseException("Inconsistent byte array structure: invalid 6 bytes char");
}
} else {
throw new JavaClassParseException("Inconsistent byte array structure: unexpected char");
}
}
}
}
return sb.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/DescriptorParser.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/DescriptorParser.java | package jadx.plugins.input.java.utils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import jadx.plugins.input.java.data.JavaMethodProto;
public class DescriptorParser {
public static void fillMethodProto(String mthDesc, JavaMethodProto mthProto) {
new DescriptorParser(mthDesc).parseMethodDescriptor(mthProto);
}
public static JavaMethodProto parseToMethodProto(String mthDesc) {
JavaMethodProto mthProto = new JavaMethodProto();
new DescriptorParser(mthDesc).parseMethodDescriptor(mthProto);
return mthProto;
}
private final String desc;
private int pos;
private DescriptorParser(String desc) {
this.desc = desc;
}
private void parseMethodDescriptor(JavaMethodProto mthProto) {
validate('(');
if (check(')')) {
mthProto.setArgTypes(Collections.emptyList());
} else {
mthProto.setArgTypes(readArgsList());
}
validate(')');
mthProto.setReturnType(readType());
}
private List<String> readArgsList() {
List<String> list = new ArrayList<>(5);
do {
list.add(readType());
} while (!check(')'));
return list;
}
private String readType() {
int cur = pos;
if (cur >= desc.length()) {
return null;
}
char ch = desc.charAt(cur);
switch (ch) {
case 'L':
int end = desc.indexOf(';', cur);
if (end == -1) {
throw new JavaClassParseException("Unexpected object type descriptor: " + desc);
}
int lastChar = end + 1;
String type = desc.substring(cur, lastChar);
pos = lastChar;
return type;
case '[':
pos++;
return "[" + readType();
default:
String primitiveType = parsePrimitiveType(ch);
pos = cur + 1;
return primitiveType;
}
}
public String parsePrimitiveType(char f) {
switch (f) {
case 'Z':
return "Z";
case 'B':
return "B";
case 'C':
return "C";
case 'S':
return "S";
case 'I':
return "I";
case 'J':
return "J";
case 'F':
return "F";
case 'D':
return "D";
case 'V':
return "V";
default:
throw new JavaClassParseException("Unexpected char '" + f + "' in descriptor " + desc);
}
}
private boolean check(char exp) {
return desc.charAt(pos) == exp;
}
private void validate(char exp) {
if (!check(exp)) {
throw new JavaClassParseException("Unexpected char in descriptor: " + desc + " at pos " + pos + ", expected: " + exp);
}
pos++;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/DisasmUtils.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/utils/DisasmUtils.java | package jadx.plugins.input.java.utils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.github.skylot.raung.disasm.RaungDisasm;
public class DisasmUtils {
private static final Logger LOG = LoggerFactory.getLogger(DisasmUtils.class);
public static String get(byte[] bytes) {
return useRaung(bytes);
}
private static String useRaung(byte[] bytes) {
return RaungDisasm.create().executeForBytes(bytes);
}
/**
* Use javap as a temporary disassembler for java bytecode
* Don't remove! Useful for debug.
*/
private static String useSystemJavaP(byte[] bytes) {
try {
Path tmpCls = null;
try {
tmpCls = Files.createTempFile("jadx", ".class");
Files.write(tmpCls, bytes, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING);
Process process = Runtime.getRuntime().exec(new String[] {
"javap", "-constants", "-v", "-p", "-c",
tmpCls.toAbsolutePath().toString()
});
process.waitFor(2, TimeUnit.SECONDS);
return inputStreamToString(process.getInputStream());
} finally {
if (tmpCls != null) {
Files.delete(tmpCls);
}
}
} catch (Exception e) {
LOG.error("Java class disasm error", e);
return "error";
}
}
public static String inputStreamToString(InputStream in) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buf = new byte[8 * 1024];
while (true) {
int r = in.read(buf);
if (r == -1) {
break;
}
out.write(buf, 0, r);
}
return out.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaMethodProto.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaMethodProto.java | package jadx.plugins.input.java.data;
import java.util.List;
import jadx.api.plugins.input.data.IMethodProto;
import jadx.api.plugins.utils.Utils;
public class JavaMethodProto implements IMethodProto {
private String returnType;
private List<String> argTypes;
@Override
public String getReturnType() {
return returnType;
}
public void setReturnType(String returnType) {
this.returnType = returnType;
}
@Override
public List<String> getArgTypes() {
return argTypes;
}
public void setArgTypes(List<String> argTypes) {
this.argTypes = argTypes;
}
@Override
public String toString() {
return "(" + Utils.listToStr(argTypes) + ")" + returnType;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaMethodRef.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaMethodRef.java | package jadx.plugins.input.java.data;
import jadx.api.plugins.input.data.IMethodRef;
import jadx.plugins.input.java.JavaClassReader;
import jadx.plugins.input.java.utils.DescriptorParser;
public class JavaMethodRef extends JavaMethodProto implements IMethodRef {
private int uniqId;
private String parentClassType;
private String name;
private String descr;
@Override
public int getUniqId() {
return uniqId;
}
public void initUniqId(JavaClassReader clsReader, int id, boolean fromConstPool) {
int readerId = clsReader.getId();
if (readerId > 0xFFFF || id > 0x7FFF) {
// loaded more than 65535 classes or more than 32767 methods in this class -> disable caching
this.uniqId = 0;
} else {
int source = fromConstPool ? 0 : 0x8000;
this.uniqId = (readerId & 0xFFFF) << 16 | source | id & 0x7FFF;
}
}
@Override
public String getParentClassType() {
return parentClassType;
}
public void setParentClassType(String parentClassType) {
this.parentClassType = parentClassType;
}
@Override
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescriptor() {
return descr;
}
public void setDescr(String descr) {
this.descr = descr;
}
public void reset() {
this.setReturnType(null);
this.setArgTypes(null);
}
@Override
public void load() {
if (getReturnType() == null) {
DescriptorParser.fillMethodProto(descr, this);
}
}
@Override
public String toString() {
return parentClassType + "->" + name + descr;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaClassData.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaClassData.java | package jadx.plugins.input.java.data;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.AccessFlags;
import jadx.api.plugins.input.data.IClassData;
import jadx.api.plugins.input.data.IFieldData;
import jadx.api.plugins.input.data.IMethodData;
import jadx.api.plugins.input.data.ISeqConsumer;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.utils.Utils;
import jadx.plugins.input.java.JavaClassReader;
import jadx.plugins.input.java.data.attributes.AttributesReader;
import jadx.plugins.input.java.data.attributes.IJavaAttribute;
import jadx.plugins.input.java.data.attributes.JavaAttrStorage;
import jadx.plugins.input.java.data.attributes.JavaAttrType;
import jadx.plugins.input.java.data.attributes.types.JavaAnnotationsAttr;
import jadx.plugins.input.java.utils.DisasmUtils;
public class JavaClassData implements IClassData {
private final JavaClassReader clsReader;
private final DataReader data;
private final ClassOffsets offsets;
private final ConstPoolReader constPoolReader;
private final AttributesReader attributesReader;
public JavaClassData(JavaClassReader clsReader) {
this.clsReader = clsReader;
this.data = new DataReader(clsReader.getData());
this.offsets = new ClassOffsets(this.data);
this.constPoolReader = new ConstPoolReader(clsReader, this, this.data.copy(), this.offsets);
this.attributesReader = new AttributesReader(this, this.constPoolReader);
}
@Override
public IClassData copy() {
return this;
}
@Override
public int getAccessFlags() {
return data.absPos(offsets.getAccessFlagsOffset()).readU2();
}
@Override
public String getType() {
int idx = data.absPos(offsets.getClsTypeOffset()).readU2();
return constPoolReader.getClass(idx);
}
@Override
@Nullable
public String getSuperType() {
int idx = data.absPos(offsets.getSuperTypeOffset()).readU2();
if (idx == 0) {
return null;
}
return constPoolReader.getClass(idx);
}
@Override
public List<String> getInterfacesTypes() {
data.absPos(offsets.getInterfacesOffset());
return data.readClassesList(constPoolReader);
}
@Override
public String getInputFileName() {
return this.clsReader.getFileName();
}
@Override
public void visitFieldsAndMethods(ISeqConsumer<IFieldData> fieldsConsumer, ISeqConsumer<IMethodData> mthConsumer) {
int clsIdx = data.absPos(offsets.getClsTypeOffset()).readU2();
String classType = constPoolReader.getClass(clsIdx);
DataReader reader = data.absPos(offsets.getFieldsOffset()).copy();
int fieldsCount = reader.readU2();
fieldsConsumer.init(fieldsCount);
if (fieldsCount != 0) {
JavaFieldData field = new JavaFieldData();
field.setParentClassType(classType);
for (int i = 0; i < fieldsCount; i++) {
parseField(reader, field);
fieldsConsumer.accept(field);
}
}
int methodsCount = reader.readU2();
mthConsumer.init(methodsCount);
if (methodsCount != 0) {
JavaMethodRef methodRef = new JavaMethodRef();
methodRef.setParentClassType(classType);
JavaMethodData method = new JavaMethodData(this, methodRef);
for (int i = 0; i < methodsCount; i++) {
parseMethod(reader, method, i);
mthConsumer.accept(method);
}
}
}
private void parseField(DataReader reader, JavaFieldData field) {
int accessFlags = reader.readU2();
int nameIdx = reader.readU2();
int typeIdx = reader.readU2();
JavaAttrStorage attributes = attributesReader.loadAll(reader);
field.setAccessFlags(accessFlags);
field.setName(constPoolReader.getUtf8(nameIdx));
field.setType(constPoolReader.getUtf8(typeIdx));
field.setAttributes(attributes);
}
private void parseMethod(DataReader reader, JavaMethodData method, int id) {
int accessFlags = reader.readU2();
int nameIdx = reader.readU2();
int descriptorIdx = reader.readU2();
JavaAttrStorage attributes = attributesReader.loadAll(reader);
JavaMethodRef methodRef = method.getMethodRef();
methodRef.reset();
methodRef.initUniqId(clsReader, id, false);
methodRef.setName(constPoolReader.getUtf8(nameIdx));
methodRef.setDescr(constPoolReader.getUtf8(descriptorIdx));
if (methodRef.getName().equals("<init>")) {
accessFlags |= AccessFlags.CONSTRUCTOR; // java bytecode don't use that flag
}
method.setData(accessFlags, attributes);
}
public DataReader getData() {
return data;
}
@Override
public List<IJadxAttribute> getAttributes() {
data.absPos(offsets.getAttributesOffset());
JavaAttrStorage attributes = attributesReader.loadAll(data);
int size = attributes.size();
if (size == 0) {
return Collections.emptyList();
}
List<IJadxAttribute> list = new ArrayList<>(size);
Utils.addToList(list, JavaAnnotationsAttr.merge(attributes));
Utils.addToList(list, attributes.get(JavaAttrType.INNER_CLASSES));
Utils.addToList(list, attributes.get(JavaAttrType.SOURCE_FILE));
Utils.addToList(list, attributes.get(JavaAttrType.SIGNATURE));
return list;
}
public <T extends IJavaAttribute> T loadClassAttribute(DataReader reader, JavaAttrType<T> type) {
reader.absPos(offsets.getAttributesOffset());
return attributesReader.loadOne(reader, type);
}
@Override
public String getDisassembledCode() {
return DisasmUtils.get(data.getBytes());
}
public JavaClassReader getClsReader() {
return clsReader;
}
public ClassOffsets getOffsets() {
return offsets;
}
public ConstPoolReader getConstPoolReader() {
return constPoolReader;
}
public AttributesReader getAttributesReader() {
return attributesReader;
}
@Override
public String toString() {
return getInputFileName();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/ClassOffsets.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/ClassOffsets.java | package jadx.plugins.input.java.data;
public class ClassOffsets {
private final int[] constPoolOffsets;
private final int constPoolEnd;
private final int interfacesEnd;
private final int attributesOffset;
public ClassOffsets(DataReader data) {
this.constPoolOffsets = readConstPool(data);
this.constPoolEnd = data.getOffset();
int interfacesCount = data.absPos(constPoolEnd + 6).readU2();
data.skip(interfacesCount * 2);
this.interfacesEnd = data.getOffset();
skipFields(data);
skipMethods(data);
this.attributesOffset = data.getOffset();
}
private static int[] readConstPool(DataReader data) {
int cpSize = data.absPos(8).readU2();
int[] cpOffsets = new int[cpSize + 1];
for (int i = 1; i < cpSize; i++) {
int tag = data.readU1();
cpOffsets[i] = data.getOffset();
ConstantType constType = ConstantType.getTypeByTag(tag);
switch (constType) {
case UTF8:
data.skip(data.readU2());
break;
case LONG:
case DOUBLE:
data.skip(8);
i++;
break;
default:
data.skip(constType.getDataSize());
break;
}
}
return cpOffsets;
}
private void skipFields(DataReader data) {
int fieldsCount = data.readU2();
for (int i = 0; i < fieldsCount; i++) {
data.skip(6);
skipAttributes(data);
}
}
private void skipMethods(DataReader data) {
int methodsCount = data.readU2();
for (int i = 0; i < methodsCount; i++) {
data.skip(6);
skipAttributes(data);
}
}
private void skipAttributes(DataReader data) {
int attrCount = data.readU2();
for (int i = 0; i < attrCount; i++) {
data.skip(2);
int len = data.readU4();
data.skip(len);
}
}
public int getOffsetOfConstEntry(int num) {
return constPoolOffsets[num];
}
public int getAccessFlagsOffset() {
return constPoolEnd;
}
public int getClsTypeOffset() {
return constPoolEnd + 2;
}
public int getSuperTypeOffset() {
return constPoolEnd + 4;
}
public int getInterfacesOffset() {
return constPoolEnd + 6;
}
public int getFieldsOffset() {
return interfacesEnd;
}
public int getAttributesOffset() {
return attributesOffset;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaFieldData.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaFieldData.java | package jadx.plugins.input.java.data;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import jadx.api.plugins.input.data.IFieldData;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.utils.Utils;
import jadx.plugins.input.java.data.attributes.JavaAttrStorage;
import jadx.plugins.input.java.data.attributes.JavaAttrType;
import jadx.plugins.input.java.data.attributes.types.ConstValueAttr;
import jadx.plugins.input.java.data.attributes.types.JavaAnnotationsAttr;
public class JavaFieldData implements IFieldData {
private String name;
private String parentClassType;
private String type;
private int accessFlags;
private JavaAttrStorage attributes;
@Override
public String getParentClassType() {
return parentClassType;
}
public void setParentClassType(String parentClassType) {
this.parentClassType = parentClassType;
}
@Override
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int getAccessFlags() {
return accessFlags;
}
public void setAccessFlags(int accessFlags) {
this.accessFlags = accessFlags;
}
public void setAttributes(JavaAttrStorage attributes) {
this.attributes = attributes;
}
@Override
public List<IJadxAttribute> getAttributes() {
int size = attributes.size();
if (size == 0) {
return Collections.emptyList();
}
List<IJadxAttribute> list = new ArrayList<>(size);
Utils.addToList(list, JavaAnnotationsAttr.merge(attributes));
Utils.addToList(list, attributes.get(JavaAttrType.CONST_VALUE), ConstValueAttr::getValue);
Utils.addToList(list, attributes.get(JavaAttrType.SIGNATURE));
return list;
}
@Override
public String toString() {
return parentClassType + "->" + name + ":" + type;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaMethodData.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/JavaMethodData.java | package jadx.plugins.input.java.data;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.ICodeReader;
import jadx.api.plugins.input.data.IMethodData;
import jadx.api.plugins.input.data.attributes.IJadxAttribute;
import jadx.api.plugins.utils.Utils;
import jadx.plugins.input.java.data.attributes.JavaAttrStorage;
import jadx.plugins.input.java.data.attributes.JavaAttrType;
import jadx.plugins.input.java.data.attributes.types.CodeAttr;
import jadx.plugins.input.java.data.attributes.types.JavaAnnotationDefaultAttr;
import jadx.plugins.input.java.data.attributes.types.JavaAnnotationsAttr;
import jadx.plugins.input.java.data.attributes.types.JavaParamAnnsAttr;
import jadx.plugins.input.java.data.code.JavaCodeReader;
public class JavaMethodData implements IMethodData {
private final JavaClassData clsData;
private final JavaMethodRef methodRef;
private int accessFlags;
private JavaAttrStorage attributes;
public JavaMethodData(JavaClassData clsData, JavaMethodRef methodRef) {
this.clsData = clsData;
this.methodRef = methodRef;
}
public void setData(int accessFlags, JavaAttrStorage attributes) {
this.accessFlags = accessFlags;
this.attributes = attributes;
}
@Override
public JavaMethodRef getMethodRef() {
return methodRef;
}
@Override
public int getAccessFlags() {
return accessFlags;
}
@Override
public @Nullable ICodeReader getCodeReader() {
CodeAttr codeAttr = attributes.get(JavaAttrType.CODE);
if (codeAttr == null) {
return null;
}
return new JavaCodeReader(clsData, codeAttr.getOffset());
}
@Override
public String disassembleMethod() {
return "";
}
@Override
public List<IJadxAttribute> getAttributes() {
int size = attributes.size();
if (size == 0) {
return Collections.emptyList();
}
List<IJadxAttribute> list = new ArrayList<>(size);
Utils.addToList(list, JavaAnnotationsAttr.merge(attributes));
Utils.addToList(list, JavaParamAnnsAttr.merge(attributes));
Utils.addToList(list, JavaAnnotationDefaultAttr.convert(attributes));
Utils.addToList(list, attributes.get(JavaAttrType.SIGNATURE));
Utils.addToList(list, attributes.get(JavaAttrType.EXCEPTIONS));
Utils.addToList(list, attributes.get(JavaAttrType.METHOD_PARAMETERS));
return list;
}
@Override
public String toString() {
return getMethodRef().toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/ConstantType.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/ConstantType.java | package jadx.plugins.input.java.data;
import java.util.stream.Stream;
import jadx.plugins.input.java.utils.JavaClassParseException;
public enum ConstantType {
UTF8(1, -1),
INTEGER(3, 4),
FLOAT(4, 4),
LONG(5, 8),
DOUBLE(6, 8),
CLASS(7, 2),
STRING(8, 2),
FIELD_REF(9, 4),
METHOD_REF(10, 4),
INTERFACE_METHOD_REF(11, 4),
NAME_AND_TYPE(12, 4),
METHOD_HANDLE(15, 3),
METHOD_TYPE(16, 2),
DYNAMIC(17, 4),
INVOKE_DYNAMIC(18, 4),
MODULE(19, 2),
PACKAGE(20, 2);
private static final ConstantType[] TAG_MAP;
static {
ConstantType[] values = ConstantType.values();
int maxVal = Stream.of(values)
.mapToInt(ConstantType::getTag)
.max()
.orElseThrow(() -> new IllegalArgumentException("Empty ConstantType enum"));
ConstantType[] map = new ConstantType[maxVal + 1];
for (ConstantType value : values) {
map[value.getTag()] = value;
}
TAG_MAP = map;
}
public static ConstantType getTypeByTag(int tag) {
ConstantType type = TAG_MAP[tag];
if (type == null) {
throw new JavaClassParseException("Unknown constant pool tag: " + tag);
}
return type;
}
private final byte tag;
private final int dataSize;
ConstantType(int tag, int dataSize) {
this.tag = (byte) tag;
this.dataSize = dataSize;
}
public byte getTag() {
return tag;
}
public int getDataSize() {
return dataSize;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/ConstPoolReader.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/ConstPoolReader.java | package jadx.plugins.input.java.data;
import java.util.ArrayList;
import java.util.List;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.ICallSite;
import jadx.api.plugins.input.data.IFieldRef;
import jadx.api.plugins.input.data.IMethodHandle;
import jadx.api.plugins.input.data.IMethodRef;
import jadx.api.plugins.input.data.MethodHandleType;
import jadx.api.plugins.input.data.annotations.EncodedType;
import jadx.api.plugins.input.data.annotations.EncodedValue;
import jadx.api.plugins.input.data.impl.CallSite;
import jadx.api.plugins.input.data.impl.FieldRefHandle;
import jadx.api.plugins.input.data.impl.MethodRefHandle;
import jadx.plugins.input.java.JavaClassReader;
import jadx.plugins.input.java.data.attributes.JavaAttrType;
import jadx.plugins.input.java.data.attributes.types.JavaBootstrapMethodsAttr;
import jadx.plugins.input.java.data.attributes.types.data.RawBootstrapMethod;
import jadx.plugins.input.java.utils.DescriptorParser;
import jadx.plugins.input.java.utils.JavaClassParseException;
import jadx.plugins.input.java.utils.ModifiedUTF8Decoder;
public class ConstPoolReader {
private final JavaClassReader clsReader;
private final JavaClassData clsData;
private final DataReader data;
private final ClassOffsets offsets;
public ConstPoolReader(JavaClassReader clsReader, JavaClassData javaClassData, DataReader data, ClassOffsets offsets) {
this.clsReader = clsReader;
this.clsData = javaClassData;
this.data = data;
this.offsets = offsets;
}
@Nullable
public String getClass(int idx) {
jumpToData(idx);
int nameIdx = data.readU2();
return fixType(getUtf8(nameIdx));
}
public IFieldRef getFieldRef(int idx) {
jumpToData(idx);
int clsIdx = data.readU2();
int nameTypeIdx = data.readU2();
jumpToData(nameTypeIdx);
int nameIdx = data.readU2();
int typeIdx = data.readU2();
JavaFieldData fieldData = new JavaFieldData();
fieldData.setParentClassType(getClass(clsIdx));
fieldData.setName(getUtf8(nameIdx));
fieldData.setType(getUtf8(typeIdx));
return fieldData;
}
public String getFieldType(int idx) {
jumpToData(idx);
data.skip(2);
int nameTypeIdx = data.readU2();
jumpToData(nameTypeIdx);
data.skip(2);
int typeIdx = data.readU2();
return getUtf8(typeIdx);
}
public IMethodRef getMethodRef(int idx) {
jumpToData(idx);
int clsIdx = data.readU2();
int nameTypeIdx = data.readU2();
jumpToData(nameTypeIdx);
int nameIdx = data.readU2();
int descIdx = data.readU2();
JavaMethodRef mthRef = new JavaMethodRef();
mthRef.initUniqId(clsReader, idx, true);
mthRef.setParentClassType(getClass(clsIdx));
mthRef.setName(getUtf8(nameIdx));
mthRef.setDescr(getUtf8(descIdx));
return mthRef;
}
public ICallSite getCallSite(int idx) {
ConstantType constType = jumpToConst(idx);
switch (constType) {
case INVOKE_DYNAMIC:
int bootstrapMthIdx = data.readU2();
int nameAndTypeIdx = data.readU2();
jumpToData(nameAndTypeIdx);
int nameIdx = data.readU2();
int descIdx = data.readU2();
return resolveMethodCallSite(bootstrapMthIdx, nameIdx, descIdx);
case DYNAMIC:
throw new JavaClassParseException("Field call site not yet implemented");
default:
throw new JavaClassParseException("Unexpected tag type for call site: " + constType);
}
}
private CallSite resolveMethodCallSite(int bootstrapMthIdx, int nameIdx, int descIdx) {
JavaBootstrapMethodsAttr bootstrapMethodsAttr = clsData.loadClassAttribute(data, JavaAttrType.BOOTSTRAP_METHODS);
if (bootstrapMethodsAttr == null) {
throw new JavaClassParseException("Unexpected missing BootstrapMethods attribute");
}
RawBootstrapMethod rawBootstrapMethod = bootstrapMethodsAttr.getList().get(bootstrapMthIdx);
List<EncodedValue> values = new ArrayList<>(6);
values.add(new EncodedValue(EncodedType.ENCODED_METHOD_HANDLE, getMethodHandle(rawBootstrapMethod.getMethodHandleIdx())));
values.add(new EncodedValue(EncodedType.ENCODED_STRING, getUtf8(nameIdx)));
values.add(new EncodedValue(EncodedType.ENCODED_METHOD_TYPE, DescriptorParser.parseToMethodProto(getUtf8(descIdx))));
for (int argConstIdx : rawBootstrapMethod.getArgs()) {
values.add(readAsEncodedValue(argConstIdx));
}
return new CallSite(values);
}
private IMethodHandle getMethodHandle(int idx) {
jumpToData(idx);
int kind = data.readU1();
int refIdx = data.readU2();
MethodHandleType handleType = convertMethodHandleKind(kind);
if (handleType.isField()) {
return new FieldRefHandle(handleType, getFieldRef(refIdx));
}
return new MethodRefHandle(handleType, getMethodRef(refIdx));
}
private MethodHandleType convertMethodHandleKind(int kind) {
switch (kind) {
case 1:
return MethodHandleType.STATIC_PUT;
case 2:
return MethodHandleType.STATIC_GET;
case 3:
return MethodHandleType.INSTANCE_PUT;
case 4:
return MethodHandleType.INSTANCE_GET;
case 5:
return MethodHandleType.INVOKE_INSTANCE;
case 6:
return MethodHandleType.INVOKE_STATIC;
case 7:
return MethodHandleType.INVOKE_DIRECT;
case 8:
return MethodHandleType.INVOKE_CONSTRUCTOR;
case 9:
return MethodHandleType.INVOKE_INTERFACE;
default:
throw new IllegalArgumentException("Unknown method handle type: " + kind);
}
}
public String getUtf8(int idx) {
if (idx == 0) {
return null;
}
jumpToData(idx);
return readString();
}
public ConstantType jumpToConst(int idx) {
jumpToTag(idx);
return ConstantType.getTypeByTag(data.readU1());
}
public String readString() {
int len = data.readU2();
byte[] bytes = data.readBytes(len);
return parseString(bytes);
}
public int readU2() {
return data.readU2();
}
public int readU4() {
return data.readU4();
}
public long readU8() {
return data.readU8();
}
public int getInt(int idx) {
jumpToData(idx);
return data.readS4();
}
public long getLong(int idx) {
jumpToData(idx);
return data.readS8();
}
public double getDouble(int idx) {
jumpToData(idx);
return Double.longBitsToDouble(data.readU8());
}
public float getFloat(int idx) {
jumpToData(idx);
return Float.intBitsToFloat(data.readU4());
}
public EncodedValue readAsEncodedValue(int idx) {
ConstantType constantType = jumpToConst(idx);
switch (constantType) {
case UTF8:
return new EncodedValue(EncodedType.ENCODED_STRING, readString());
case STRING:
return new EncodedValue(EncodedType.ENCODED_STRING, getUtf8(readU2()));
case INTEGER:
return new EncodedValue(EncodedType.ENCODED_INT, data.readS4());
case FLOAT:
return new EncodedValue(EncodedType.ENCODED_FLOAT, Float.intBitsToFloat(data.readU4()));
case LONG:
return new EncodedValue(EncodedType.ENCODED_LONG, data.readS8());
case DOUBLE:
return new EncodedValue(EncodedType.ENCODED_DOUBLE, Double.longBitsToDouble(data.readU8()));
case CLASS:
return new EncodedValue(EncodedType.ENCODED_TYPE, getClass(idx));
case METHOD_TYPE:
return new EncodedValue(EncodedType.ENCODED_METHOD_TYPE, DescriptorParser.parseToMethodProto(getUtf8(readU2())));
case METHOD_HANDLE:
return new EncodedValue(EncodedType.ENCODED_METHOD_HANDLE, getMethodHandle(idx));
default:
throw new JavaClassParseException("Can't encode constant " + constantType + " as encoded value");
}
}
@NotNull
private String parseString(byte[] bytes) {
return ModifiedUTF8Decoder.decodeString(bytes);
}
private String fixType(String clsName) {
switch (clsName.charAt(0)) {
case '[':
return clsName;
case 'L':
case 'T':
if (clsName.endsWith(";")) {
return clsName;
}
break;
}
return 'L' + clsName + ';';
}
private void jumpToData(int idx) {
data.absPos(offsets.getOffsetOfConstEntry(idx));
}
private void jumpToTag(int idx) {
data.absPos(offsets.getOffsetOfConstEntry(idx) - 1);
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/DataReader.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/DataReader.java | package jadx.plugins.input.java.data;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class DataReader {
private final byte[] data;
private int offset;
public DataReader(byte[] data) {
this(data, 0);
}
public DataReader(byte[] data, int offset) {
this.data = data;
this.offset = offset;
}
public DataReader copy() {
return new DataReader(data, offset);
}
public DataReader absPos(int offset) {
this.offset = offset;
return this;
}
public int getOffset() {
return offset;
}
public void skip(int size) {
this.offset += size;
}
public int readS1() {
int pos = this.offset;
byte b1 = this.data[pos];
this.offset = pos + 1;
return b1;
}
public int readU1() {
int pos = this.offset;
byte b1 = this.data[pos];
this.offset = pos + 1;
return b1 & 0xFF;
}
public int readS2() {
int pos = this.offset;
byte[] d = this.data;
byte b1 = d[pos++];
byte b2 = d[pos++];
this.offset = pos;
return b1 << 8 | (b2 & 0xFF);
}
public int readU2() {
int pos = this.offset;
byte[] d = this.data;
byte b1 = d[pos++];
byte b2 = d[pos++];
this.offset = pos;
return (b1 & 0xFF) << 8 | (b2 & 0xFF);
}
public int readS4() {
int pos = this.offset;
byte[] d = this.data;
byte b1 = d[pos++];
byte b2 = d[pos++];
byte b3 = d[pos++];
byte b4 = d[pos++];
this.offset = pos;
return b1 << 24 | (b2 & 0xFF) << 16 | (b3 & 0xFF) << 8 | (b4 & 0xFF);
}
public int readU4() {
int pos = this.offset;
byte[] d = this.data;
byte b1 = d[pos++];
byte b2 = d[pos++];
byte b3 = d[pos++];
byte b4 = d[pos++];
this.offset = pos;
return (b1 & 0xFF) << 24 | (b2 & 0xFF) << 16 | (b3 & 0xFF) << 8 | (b4 & 0xFF);
}
public long readS8() {
long high = readS4();
long low = readU4() & 0xFFFF_FFFFL;
return high << 32 | low;
}
public long readU8() {
long high = readU4() & 0xFFFF_FFFFL;
long low = readU4() & 0xFFFF_FFFFL;
return high << 32 | low;
}
public byte[] readBytes(int len) {
int pos = this.offset;
this.offset = pos + len;
return Arrays.copyOfRange(data, pos, pos + len);
}
public List<String> readClassesList(ConstPoolReader constPool) {
int len = readU2();
if (len == 0) {
return Collections.emptyList();
}
List<String> list = new ArrayList<>(len);
for (int i = 0; i < len; i++) {
list.add(constPool.getClass(readU2()));
}
return list;
}
public byte[] getBytes() {
return data;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/CodeDecodeState.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/CodeDecodeState.java | package jadx.plugins.input.java.data.code;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.insns.Opcode;
import jadx.core.utils.Utils;
import jadx.plugins.input.java.data.DataReader;
import jadx.plugins.input.java.data.JavaClassData;
import jadx.plugins.input.java.data.attributes.stack.StackFrame;
import jadx.plugins.input.java.data.attributes.stack.StackValueType;
import jadx.plugins.input.java.data.attributes.types.StackMapTableAttr;
@SuppressWarnings("UnusedReturnValue")
public class CodeDecodeState {
private final JavaClassData clsData;
private final DataReader reader;
private final int maxStack;
private final Set<Integer> excHandlers;
private final StackMapTableAttr stackMapTable;
private final Map<Integer, StackState> jumpStack = new HashMap<>(); // save current stack for jump target
private JavaInsnData insn;
private StackState stack;
private boolean excHandler;
public CodeDecodeState(JavaClassData clsData, DataReader reader, int maxStack,
Set<Integer> excHandlers, @Nullable StackMapTableAttr stackMapTable) {
this.clsData = clsData;
this.reader = reader;
this.maxStack = maxStack;
this.excHandlers = excHandlers;
this.stack = new StackState(maxStack);
this.stackMapTable = Utils.getOrElse(stackMapTable, StackMapTableAttr.EMPTY);
}
public void onInsn(int offset) {
StackState newStack = loadStack(offset);
if (newStack != null) {
this.stack = newStack;
}
if (excHandlers.contains(offset)) {
clear();
stack.push(StackValueType.NARROW); // push exception
excHandler = true;
} else {
excHandler = false;
}
}
private @Nullable StackState loadStack(int offset) {
StackState stackState = jumpStack.get(offset);
if (stackState != null) {
return stackState.copy();
}
StackFrame frame = stackMapTable.getFor(offset);
if (frame != null) {
return new StackState(maxStack).fillFromFrame(frame);
}
return null;
}
public void registerJump(int jumpOffset) {
Integer key = jumpOffset;
if (!jumpStack.containsKey(key)) {
jumpStack.put(key, stack.copy());
}
}
public void decoded() {
if (excHandler && insn.getOpcode() == Opcode.MOVE) {
// replace first 'move' in exception handler with 'move-exception'
insn.setOpcode(Opcode.MOVE_EXCEPTION);
insn.setRegsCount(1);
}
}
public JavaInsnData insn() {
return insn;
}
public void setInsn(JavaInsnData insn) {
this.insn = insn;
}
public DataReader reader() {
return reader;
}
public JavaClassData clsData() {
return clsData;
}
public CodeDecodeState local(int arg, int local) {
insn.setArgReg(arg, localToReg(local));
return this;
}
public CodeDecodeState pop(int arg) {
insn.setArgReg(arg, stack.pop());
return this;
}
public CodeDecodeState peek(int arg) {
insn.setArgReg(arg, stack.peek());
return this;
}
public StackValueType peekType(int at) {
return stack.peekTypeAt(at);
}
public CodeDecodeState peekFrom(int pos, int arg) {
insn.setArgReg(arg, stack.peekAt(pos));
return this;
}
public CodeDecodeState push(int arg) {
insn.setArgReg(arg, stack.push(StackValueType.NARROW));
return this;
}
public CodeDecodeState push(int arg, StackValueType type) {
insn.setArgReg(arg, stack.push(type));
return this;
}
public CodeDecodeState pushWide(int arg) {
insn.setArgReg(arg, stack.push(StackValueType.WIDE));
return this;
}
public int insert(int pos, StackValueType type) {
return stack.insert(pos, type);
}
public void discard() {
stack.pop();
}
public void discardWord() {
StackValueType type = stack.peekTypeAt(0);
stack.pop();
if (type == StackValueType.NARROW) {
stack.pop();
}
}
public CodeDecodeState clear() {
stack.clear();
return this;
}
public int push(String type) {
return stack.push(getSVType(type));
}
/**
* Must be after all pop and push
*/
public void jump(int offset) {
int jumpOffset = insn.getOffset() + offset;
insn.setTarget(jumpOffset);
registerJump(jumpOffset);
}
public CodeDecodeState idx(int idx) {
insn.setIndex(idx);
return this;
}
public CodeDecodeState lit(long lit) {
insn.setLiteral(lit);
return this;
}
private int localToReg(int local) {
return maxStack + local;
}
public StackValueType fieldType() {
String type = insn.constPoolReader().getFieldType(insn().getIndex());
return getSVType(type);
}
public StackValueType getSVType(String type) {
if (type.equals("J") || type.equals("D")) {
return StackValueType.WIDE;
}
return StackValueType.NARROW;
}
public int u1() {
return reader.readU1();
}
public int u2() {
return reader.readU2();
}
public int s1() {
return reader.readS1();
}
public int s2() {
return reader.readS2();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaCodeReader.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaCodeReader.java | package jadx.plugins.input.java.data.code;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.ICodeReader;
import jadx.api.plugins.input.data.IDebugInfo;
import jadx.api.plugins.input.data.ILocalVar;
import jadx.api.plugins.input.data.ITry;
import jadx.api.plugins.input.data.impl.CatchData;
import jadx.api.plugins.input.data.impl.DebugInfo;
import jadx.api.plugins.input.insns.InsnData;
import jadx.plugins.input.java.data.ConstPoolReader;
import jadx.plugins.input.java.data.DataReader;
import jadx.plugins.input.java.data.JavaClassData;
import jadx.plugins.input.java.data.attributes.JavaAttrStorage;
import jadx.plugins.input.java.data.attributes.JavaAttrType;
import jadx.plugins.input.java.data.attributes.debuginfo.JavaLocalVar;
import jadx.plugins.input.java.data.attributes.debuginfo.LineNumberTableAttr;
import jadx.plugins.input.java.data.attributes.debuginfo.LocalVarTypesAttr;
import jadx.plugins.input.java.data.attributes.debuginfo.LocalVarsAttr;
import jadx.plugins.input.java.data.attributes.types.StackMapTableAttr;
import jadx.plugins.input.java.data.code.trycatch.JavaSingleCatch;
import jadx.plugins.input.java.data.code.trycatch.JavaTryData;
import jadx.plugins.input.java.utils.JavaClassParseException;
public class JavaCodeReader implements ICodeReader {
private final JavaClassData clsData;
private final DataReader reader;
private final int codeOffset;
public JavaCodeReader(JavaClassData clsData, int offset) {
this.clsData = clsData;
this.reader = clsData.getData();
this.codeOffset = offset;
}
@Override
public ICodeReader copy() {
return this;
}
@Override
public void visitInstructions(Consumer<InsnData> insnConsumer) {
Set<Integer> excHandlers = getExcHandlers();
jumpToCodeAttributes();
StackMapTableAttr stackMapTable = clsData.getAttributesReader().loadOne(reader, JavaAttrType.STACK_MAP_TABLE);
int maxStack = readMaxStack();
reader.skip(2);
int codeSize = reader.readU4();
CodeDecodeState state = new CodeDecodeState(clsData, reader, maxStack, excHandlers, stackMapTable);
JavaInsnData insn = new JavaInsnData(state);
state.setInsn(insn);
int offset = 0;
while (offset < codeSize) {
insn.setDecoded(false);
insn.setOffset(offset);
insn.setInsnStart(reader.getOffset());
int opcode = reader.readU1();
JavaInsnInfo insnInfo = JavaInsnsRegister.get(opcode);
if (insnInfo == null) {
throw new JavaClassParseException("Unknown opcode: 0x" + Integer.toHexString(opcode));
}
insn.setOpcodeUnit(opcode);
insn.setInsnInfo(insnInfo);
insn.setRegsCount(insnInfo.getRegsCount());
insn.setOpcode(insnInfo.getApiOpcode());
insn.setPayloadSize(insnInfo.getPayloadSize());
insn.setPayload(null);
state.onInsn(offset);
insnConsumer.accept(insn);
int payloadSize = insn.getPayloadSize();
if (!insn.isDecoded()) {
if (payloadSize == -1) {
insn.skip();
payloadSize = insn.getPayloadSize();
} else {
reader.skip(payloadSize);
}
}
offset += 1 + payloadSize;
}
}
@Override
public int getRegistersCount() {
int maxStack = readMaxStack();
int maxLocals = reader.readU2();
return maxStack + maxLocals;
}
@Override
public int getArgsStartReg() {
return readMaxStack();
}
private int readMaxStack() {
reader.absPos(codeOffset);
int maxStack = reader.readU2();
return maxStack + 1; // add one temporary register (for `swap` opcode)
}
@Override
public int getUnitsCount() {
return reader.absPos(codeOffset + 4).readU4();
}
private static final Set<JavaAttrType<?>> DEBUG_INFO_ATTRIBUTES = Set.of(
JavaAttrType.LINE_NUMBER_TABLE,
JavaAttrType.LOCAL_VAR_TABLE,
JavaAttrType.LOCAL_VAR_TYPE_TABLE);
@Override
@Nullable
public IDebugInfo getDebugInfo() {
int maxStack = readMaxStack();
jumpToCodeAttributes();
JavaAttrStorage attrs = clsData.getAttributesReader().loadMulti(reader, DEBUG_INFO_ATTRIBUTES);
LineNumberTableAttr linesAttr = attrs.get(JavaAttrType.LINE_NUMBER_TABLE);
LocalVarsAttr varsAttr = attrs.get(JavaAttrType.LOCAL_VAR_TABLE);
if (linesAttr == null && varsAttr == null) {
return null;
}
Map<Integer, Integer> linesMap = linesAttr != null ? linesAttr.getLineMap() : Collections.emptyMap();
List<ILocalVar> vars;
if (varsAttr == null) {
vars = Collections.emptyList();
} else {
List<JavaLocalVar> javaVars = varsAttr.getVars();
LocalVarTypesAttr typedVars = attrs.get(JavaAttrType.LOCAL_VAR_TYPE_TABLE);
if (typedVars != null && !typedVars.getVars().isEmpty()) {
// merge signature from typedVars into javaVars
Map<JavaLocalVar, JavaLocalVar> varsMap = new HashMap<>(javaVars.size());
javaVars.forEach(v -> varsMap.put(v, v));
for (JavaLocalVar typedVar : typedVars.getVars()) {
JavaLocalVar jv = varsMap.get(typedVar);
if (jv != null) {
jv.setSignature(typedVar.getSignature());
}
}
}
javaVars.forEach(v -> v.shiftRegNum(maxStack));
vars = Collections.unmodifiableList(javaVars);
}
return new DebugInfo(linesMap, vars);
}
@Override
public int getCodeOffset() {
return codeOffset;
}
@Override
public List<ITry> getTries() {
jumpToTries();
int excTableLen = reader.readU2();
if (excTableLen == 0) {
return Collections.emptyList();
}
ConstPoolReader constPool = clsData.getConstPoolReader();
Map<JavaTryData, List<JavaSingleCatch>> tries = new HashMap<>(excTableLen);
for (int i = 0; i < excTableLen; i++) {
int start = reader.readU2();
int end = reader.readU2();
int handler = reader.readU2();
int type = reader.readU2();
JavaTryData tryData = new JavaTryData(start, end);
List<JavaSingleCatch> catches = tries.computeIfAbsent(tryData, k -> new ArrayList<>());
if (type == 0) {
catches.add(new JavaSingleCatch(handler, null));
} else {
catches.add(new JavaSingleCatch(handler, constPool.getClass(type)));
}
}
return tries.entrySet().stream()
.map(e -> {
JavaTryData tryData = e.getKey();
tryData.setCatch(convertSingleCatches(e.getValue()));
return tryData;
})
.collect(Collectors.toList());
}
private static CatchData convertSingleCatches(List<JavaSingleCatch> list) {
int allHandler = -1;
for (JavaSingleCatch singleCatch : list) {
if (singleCatch.getType() == null) {
allHandler = singleCatch.getHandler();
list.remove(singleCatch);
break;
}
}
int len = list.size();
int[] handlers = new int[len];
String[] types = new String[len];
for (int i = 0; i < len; i++) {
JavaSingleCatch singleCatch = list.get(i);
handlers[i] = singleCatch.getHandler();
types[i] = singleCatch.getType();
}
return new CatchData(handlers, types, allHandler);
}
private Set<Integer> getExcHandlers() {
jumpToTries();
int excTableLen = reader.readU2();
if (excTableLen == 0) {
return Collections.emptySet();
}
Set<Integer> set = new HashSet<>(excTableLen);
for (int i = 0; i < excTableLen; i++) {
reader.skip(4);
int handler = reader.readU2();
reader.skip(2);
set.add(handler);
}
return set;
}
private void jumpToTries() {
reader.absPos(codeOffset + 4);
reader.skip(reader.readU4()); // code length
}
private void jumpToCodeAttributes() {
jumpToTries();
reader.skip(reader.readU2() * 8); // exceptions table
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/StackState.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/StackState.java | package jadx.plugins.input.java.data.code;
import java.util.Arrays;
import jadx.plugins.input.java.data.attributes.stack.StackFrame;
import jadx.plugins.input.java.data.attributes.stack.StackValueType;
public class StackState {
private int pos = -1;
private final StackValueType[] stack;
public StackState(int maxStack) {
this.stack = new StackValueType[maxStack];
}
private StackState(int pos, StackValueType[] stack) {
this.pos = pos;
this.stack = stack;
}
public StackState copy() {
return new StackState(pos, Arrays.copyOf(stack, stack.length));
}
public StackState fillFromFrame(StackFrame frame) {
int stackSize = frame.getStackSize();
this.pos = stackSize - 1;
if (stackSize > 0) {
System.arraycopy(frame.getStackValueTypes(), 0, this.stack, 0, stackSize);
}
return this;
}
public int peek() {
return pos;
}
public int peekAt(int at) {
return pos - at;
}
public StackValueType peekTypeAt(int at) {
int p = pos - at;
if (checkStackIndex(p)) {
return stack[p];
}
return StackValueType.NARROW;
}
public int insert(int at, StackValueType type) {
int p = pos - at;
System.arraycopy(stack, p, stack, p + 1, at);
stack[p] = type;
pos++;
return p;
}
public int push(StackValueType type) {
int p = ++pos;
if (checkStackIndex(p)) {
stack[p] = type;
}
return p;
}
private boolean checkStackIndex(int p) {
return p >= 0 && p < stack.length;
}
public int pop() {
return pos--;
}
public void clear() {
pos = -1;
}
@Override
public String toString() {
int size = pos + 1;
String arr;
if (size == 0) {
arr = "empty";
} else if (size > 0 && size < stack.length) {
arr = Arrays.toString(Arrays.copyOf(stack, size));
} else {
arr = Arrays.toString(stack) + " (max)";
}
return "Stack: " + size + ": " + arr;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaInsnInfo.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaInsnInfo.java | package jadx.plugins.input.java.data.code;
import jadx.api.plugins.input.insns.InsnIndexType;
import jadx.api.plugins.input.insns.Opcode;
import jadx.plugins.input.java.data.code.decoders.IJavaInsnDecoder;
public class JavaInsnInfo {
private final int opcode;
private final String name;
private final int payloadSize;
private final int regsCount;
private final Opcode apiOpcode;
private final InsnIndexType indexType;
private final IJavaInsnDecoder decoder;
public JavaInsnInfo(int opcode, String name, int payloadSize, int regsCount, Opcode apiOpcode,
InsnIndexType indexType, IJavaInsnDecoder decoder) {
this.opcode = opcode;
this.name = name;
this.payloadSize = payloadSize;
this.regsCount = regsCount;
this.apiOpcode = apiOpcode;
this.indexType = indexType;
this.decoder = decoder;
}
public int getOpcode() {
return opcode;
}
public String getName() {
return name;
}
public int getPayloadSize() {
return payloadSize;
}
public int getRegsCount() {
return regsCount;
}
public Opcode getApiOpcode() {
return apiOpcode;
}
public InsnIndexType getIndexType() {
return indexType;
}
public IJavaInsnDecoder getDecoder() {
return decoder;
}
@Override
public String toString() {
return "0x" + Integer.toHexString(opcode) + ": " + name;
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaInsnData.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaInsnData.java | package jadx.plugins.input.java.data.code;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.data.ICallSite;
import jadx.api.plugins.input.data.IFieldRef;
import jadx.api.plugins.input.data.IMethodHandle;
import jadx.api.plugins.input.data.IMethodProto;
import jadx.api.plugins.input.data.IMethodRef;
import jadx.api.plugins.input.insns.InsnData;
import jadx.api.plugins.input.insns.InsnIndexType;
import jadx.api.plugins.input.insns.Opcode;
import jadx.api.plugins.input.insns.custom.ICustomPayload;
import jadx.plugins.input.java.data.ConstPoolReader;
import jadx.plugins.input.java.data.DataReader;
import jadx.plugins.input.java.data.code.decoders.IJavaInsnDecoder;
public class JavaInsnData implements InsnData {
private final CodeDecodeState state;
private JavaInsnInfo insnInfo;
private Opcode opcode;
private boolean decoded;
private int opcodeUnit;
private int payloadSize;
private int insnStart;
private int offset;
private int regsCount;
private int[] argsReg = new int[16];
private int resultReg;
private long literal;
private int target;
private int index;
@Nullable
private ICustomPayload payload;
public JavaInsnData(CodeDecodeState state) {
this.state = state;
}
@Override
public void decode() {
IJavaInsnDecoder decoder = insnInfo.getDecoder();
if (decoder != null) {
decoder.decode(state);
state.decoded();
}
decoded = true;
}
public void skip() {
IJavaInsnDecoder decoder = insnInfo.getDecoder();
if (decoder != null) {
decoder.skip(state);
}
}
@Override
public int getOffset() {
return offset;
}
@Override
public int getFileOffset() {
return insnStart;
}
@Override
public Opcode getOpcode() {
return opcode;
}
public void setOpcode(Opcode opcode) {
this.opcode = opcode;
}
@Override
public String getOpcodeMnemonic() {
return insnInfo.getName();
}
@Override
public byte[] getByteCode() {
DataReader reader = state.reader();
int startOffset = reader.getOffset();
try {
reader.absPos(insnStart);
return reader.readBytes(1 + payloadSize);
} finally {
reader.absPos(startOffset);
}
}
@Override
public InsnIndexType getIndexType() {
return insnInfo.getIndexType();
}
@Override
public int getRawOpcodeUnit() {
return opcodeUnit;
}
@Override
public int getRegsCount() {
return regsCount;
}
@Override
public int getReg(int argNum) {
return argsReg[argNum];
}
@Override
public int getResultReg() {
return resultReg;
}
public void setResultReg(int resultReg) {
this.resultReg = resultReg;
}
@Override
public long getLiteral() {
return literal;
}
@Override
public int getTarget() {
return target;
}
@Override
public int getIndex() {
return index;
}
public int getPayloadSize() {
return payloadSize;
}
@Override
public String getIndexAsString() {
return constPoolReader().getUtf8(index);
}
@Override
public String getIndexAsType() {
if (insnInfo.getOpcode() == 0xbc) { // newarray
return ArrayType.byValue(index);
}
return constPoolReader().getClass(index);
}
@Override
public IFieldRef getIndexAsField() {
return constPoolReader().getFieldRef(index);
}
@Override
public IMethodRef getIndexAsMethod() {
return constPoolReader().getMethodRef(index);
}
@Override
public ICallSite getIndexAsCallSite() {
return constPoolReader().getCallSite(index);
}
@Override
public IMethodProto getIndexAsProto(int protoIndex) {
return null;
}
@Override
public IMethodHandle getIndexAsMethodHandle() {
return null;
}
@Override
public @Nullable ICustomPayload getPayload() {
return payload;
}
public void setInsnInfo(JavaInsnInfo insnInfo) {
this.insnInfo = insnInfo;
}
public boolean isDecoded() {
return decoded;
}
public void setDecoded(boolean decoded) {
this.decoded = decoded;
}
public void setOpcodeUnit(int opcodeUnit) {
this.opcodeUnit = opcodeUnit;
}
public void setPayloadSize(int payloadSize) {
this.payloadSize = payloadSize;
}
public void setInsnStart(int insnStart) {
this.insnStart = insnStart;
}
public void setOffset(int offset) {
this.offset = offset;
}
public void setArgReg(int arg, int reg) {
this.argsReg[arg] = reg;
}
public void setRegsCount(int regsCount) {
this.regsCount = regsCount;
if (argsReg.length < regsCount) {
argsReg = new int[regsCount];
}
}
public int[] getRegsArray() {
return argsReg;
}
public void setLiteral(long literal) {
this.literal = literal;
}
public void setTarget(int target) {
this.target = target;
}
public void setIndex(int index) {
this.index = index;
}
public void setPayload(ICustomPayload payload) {
this.payload = payload;
}
public ConstPoolReader constPoolReader() {
return state.clsData().getConstPoolReader();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(String.format("0x%04X", offset));
sb.append(": ").append(getOpcode());
if (insnInfo == null) {
sb.append(String.format("(0x%04X)", opcodeUnit));
} else {
int regsCount = getRegsCount();
if (isDecoded()) {
sb.append(' ');
for (int i = 0; i < regsCount; i++) {
if (i != 0) {
sb.append(", ");
}
sb.append("r").append(argsReg[i]);
}
}
}
return sb.toString();
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaInsnsRegister.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/JavaInsnsRegister.java | package jadx.plugins.input.java.data.code;
import org.jetbrains.annotations.Nullable;
import jadx.api.plugins.input.insns.InsnIndexType;
import jadx.api.plugins.input.insns.Opcode;
import jadx.plugins.input.java.data.attributes.stack.StackValueType;
import jadx.plugins.input.java.data.code.decoders.IJavaInsnDecoder;
import jadx.plugins.input.java.data.code.decoders.InvokeDecoder;
import jadx.plugins.input.java.data.code.decoders.LoadConstDecoder;
import jadx.plugins.input.java.data.code.decoders.LookupSwitchDecoder;
import jadx.plugins.input.java.data.code.decoders.TableSwitchDecoder;
import jadx.plugins.input.java.data.code.decoders.WideDecoder;
import static jadx.plugins.input.java.data.attributes.stack.StackValueType.NARROW;
import static jadx.plugins.input.java.data.attributes.stack.StackValueType.WIDE;
@SuppressWarnings("SpellCheckingInspection")
public class JavaInsnsRegister {
private static final JavaInsnInfo[] INSN_INFO;
public static final long FLOAT_ZERO = Float.floatToIntBits(0.0f);
public static final long FLOAT_ONE = Float.floatToIntBits(1.0f);
public static final long FLOAT_TWO = Float.floatToIntBits(2.0f);
public static final long DOUBLE_ZERO = Double.doubleToLongBits(0.0d);
public static final long DOUBLE_ONE = Double.doubleToLongBits(1.0d);
static {
JavaInsnInfo[] arr = new JavaInsnInfo[0xCA];
INSN_INFO = arr;
register(arr, 0x00, "nop", 0, 0, Opcode.NOP, null);
constInsn(arr, 0x01, "aconst_null", Opcode.CONST, 0);
constInsn(arr, 0x02, "iconst_m1", Opcode.CONST, -1);
constInsn(arr, 0x03, "iconst_0", Opcode.CONST, 0);
constInsn(arr, 0x04, "iconst_1", Opcode.CONST, 1);
constInsn(arr, 0x05, "iconst_2", Opcode.CONST, 2);
constInsn(arr, 0x06, "iconst_3", Opcode.CONST, 3);
constInsn(arr, 0x07, "iconst_4", Opcode.CONST, 4);
constInsn(arr, 0x08, "iconst_5", Opcode.CONST, 5);
constInsn(arr, 0x09, "lconst_0", Opcode.CONST_WIDE, 0L);
constInsn(arr, 0x0a, "lconst_1", Opcode.CONST_WIDE, 1L);
constInsn(arr, 0x0b, "fconst_0", Opcode.CONST, FLOAT_ZERO);
constInsn(arr, 0x0c, "fconst_1", Opcode.CONST, FLOAT_ONE);
constInsn(arr, 0x0d, "fconst_2", Opcode.CONST, FLOAT_TWO);
constInsn(arr, 0x0e, "dconst_0", Opcode.CONST_WIDE, DOUBLE_ZERO);
constInsn(arr, 0x0f, "dconst_1", Opcode.CONST_WIDE, DOUBLE_ONE);
register(arr, 0x10, "bipush", 1, 2, Opcode.CONST, s -> s.lit(s.s1()).push(0));
register(arr, 0x11, "sipush", 2, 2, Opcode.CONST, s -> s.lit(s.s2()).push(0));
loadConst(arr, 0x12, "ldc", false);
loadConst(arr, 0x13, "ldc_w", true);
loadConst(arr, 0x14, "ldc2_w", true);
register(arr, 0x15, "iload", 1, 2, Opcode.MOVE, s -> s.local(1, s.u1()).push(0));
register(arr, 0x16, "lload", 1, 2, Opcode.MOVE_WIDE, s -> s.local(1, s.u1()).pushWide(0));
register(arr, 0x17, "fload", 1, 2, Opcode.MOVE, s -> s.local(1, s.u1()).push(0));
register(arr, 0x18, "dload", 1, 2, Opcode.MOVE_WIDE, s -> s.local(1, s.u1()).pushWide(0));
register(arr, 0x19, "aload", 1, 2, Opcode.MOVE, s -> s.local(1, s.u1()).push(0));
register(arr, 0x1a, "iload_0", 0, 2, Opcode.MOVE, s -> s.local(1, 0).push(0));
register(arr, 0x1b, "iload_1", 0, 2, Opcode.MOVE, s -> s.local(1, 1).push(0));
register(arr, 0x1c, "iload_2", 0, 2, Opcode.MOVE, s -> s.local(1, 2).push(0));
register(arr, 0x1d, "iload_3", 0, 2, Opcode.MOVE, s -> s.local(1, 3).push(0));
register(arr, 0x1e, "lload_0", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 0).pushWide(0));
register(arr, 0x1f, "lload_1", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 1).pushWide(0));
register(arr, 0x20, "lload_2", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 2).pushWide(0));
register(arr, 0x21, "lload_3", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 3).pushWide(0));
register(arr, 0x22, "fload_0", 0, 2, Opcode.MOVE, s -> s.local(1, 0).push(0));
register(arr, 0x23, "fload_1", 0, 2, Opcode.MOVE, s -> s.local(1, 1).push(0));
register(arr, 0x24, "fload_2", 0, 2, Opcode.MOVE, s -> s.local(1, 2).push(0));
register(arr, 0x25, "fload_3", 0, 2, Opcode.MOVE, s -> s.local(1, 3).push(0));
register(arr, 0x26, "dload_0", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 0).pushWide(0));
register(arr, 0x27, "dload_1", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 1).pushWide(0));
register(arr, 0x28, "dload_2", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 2).pushWide(0));
register(arr, 0x29, "dload_3", 0, 2, Opcode.MOVE_WIDE, s -> s.local(1, 3).pushWide(0));
register(arr, 0x2a, "aload_0", 0, 2, Opcode.MOVE, s -> s.local(1, 0).push(0));
register(arr, 0x2b, "aload_1", 0, 2, Opcode.MOVE, s -> s.local(1, 1).push(0));
register(arr, 0x2c, "aload_2", 0, 2, Opcode.MOVE, s -> s.local(1, 2).push(0));
register(arr, 0x2d, "aload_3", 0, 2, Opcode.MOVE, s -> s.local(1, 3).push(0));
register(arr, 0x2e, "iaload", 0, 3, Opcode.AGET, aget());
register(arr, 0x2f, "laload", 0, 3, Opcode.AGET_WIDE, agetWide());
register(arr, 0x30, "faload", 0, 3, Opcode.AGET, aget());
register(arr, 0x31, "daload", 0, 3, Opcode.AGET_WIDE, agetWide());
register(arr, 0x32, "aaload", 0, 3, Opcode.AGET_OBJECT, aget());
register(arr, 0x33, "baload", 0, 3, Opcode.AGET_BYTE_BOOLEAN, aget());
register(arr, 0x34, "caload", 0, 3, Opcode.AGET_CHAR, aget());
register(arr, 0x35, "saload", 0, 3, Opcode.AGET_SHORT, aget());
register(arr, 0x36, "istore", 1, 2, Opcode.MOVE, s -> s.pop(1).local(0, s.u1()));
register(arr, 0x37, "lstore", 1, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, s.u1()));
register(arr, 0x38, "fstore", 1, 2, Opcode.MOVE, s -> s.pop(1).local(0, s.u1()));
register(arr, 0x39, "dstore", 1, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, s.u1()));
register(arr, 0x3a, "astore", 1, 2, Opcode.MOVE, s -> s.pop(1).local(0, s.u1()));
register(arr, 0x3b, "istore_0", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 0));
register(arr, 0x3c, "istore_1", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 1));
register(arr, 0x3d, "istore_2", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 2));
register(arr, 0x3e, "istore_3", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 3));
register(arr, 0x3f, "lstore_0", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 0));
register(arr, 0x40, "lstore_1", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 1));
register(arr, 0x41, "lstore_2", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 2));
register(arr, 0x42, "lstore_3", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 3));
register(arr, 0x43, "fstore_0", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 0));
register(arr, 0x44, "fstore_1", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 1));
register(arr, 0x45, "fstore_2", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 2));
register(arr, 0x46, "fstore_3", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 3));
register(arr, 0x47, "dstore_0", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 0));
register(arr, 0x48, "dstore_1", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 1));
register(arr, 0x49, "dstore_2", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 2));
register(arr, 0x4a, "dstore_3", 0, 2, Opcode.MOVE_WIDE, s -> s.pop(1).local(0, 3));
register(arr, 0x4b, "astore_0", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 0));
register(arr, 0x4c, "astore_1", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 1));
register(arr, 0x4d, "astore_2", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 2));
register(arr, 0x4e, "astore_3", 0, 2, Opcode.MOVE, s -> s.pop(1).local(0, 3));
register(arr, 0x4f, "iastore", 0, 3, Opcode.APUT, aput());
register(arr, 0x50, "lastore", 0, 3, Opcode.APUT_WIDE, aput());
register(arr, 0x51, "fastore", 0, 3, Opcode.APUT, aput());
register(arr, 0x52, "dastore", 0, 3, Opcode.APUT_WIDE, aput());
register(arr, 0x53, "aastore", 0, 3, Opcode.APUT_OBJECT, aput());
register(arr, 0x54, "bastore", 0, 3, Opcode.APUT_BYTE_BOOLEAN, aput());
register(arr, 0x55, "castore", 0, 3, Opcode.APUT_CHAR, aput());
register(arr, 0x56, "sastore", 0, 3, Opcode.APUT_SHORT, aput());
register(arr, 0x57, "pop", 0, 0, Opcode.NOP, CodeDecodeState::discard);
register(arr, 0x58, "pop2", 0, 0, Opcode.NOP, CodeDecodeState::discardWord);
register(arr, 0x59, "dup", 0, 2, Opcode.MOVE, s -> s.peek(1).push(0, s.peekType(1)));
register(arr, 0x5a, "dup_x1", 0, 6, Opcode.MOVE_MULTI,
s -> s.push(0, s.peekType(1)).peekFrom(1, 1)
.peekFrom(1, 2).peekFrom(2, 3)
.peekFrom(2, 4).peekFrom(0, 5));
register(arr, 0x5b, "dup_x2", 0, 8, Opcode.MOVE_MULTI,
s -> s.push(0, s.peekType(1)).peekFrom(1, 1)
.peekFrom(1, 2).peekFrom(2, 3)
.peekFrom(2, 4).peekFrom(3, 5)
.peekFrom(3, 6).peekFrom(0, 7));
register(arr, 0x5c, "dup2", 0, 4, Opcode.MOVE_MULTI, s -> {
if (s.peekType(0) == NARROW) {
s.peekFrom(0, 3).peekFrom(1, 1).push(0, NARROW).push(2, NARROW);
} else {
s.peek(1).push(0, s.peekType(1));
}
});
register(arr, 0x5d, "dup2_x1", 0, 10, Opcode.MOVE_MULTI, JavaInsnsRegister::dup2x1);
register(arr, 0x5e, "dup2_x2", 0, 12, Opcode.MOVE_MULTI, JavaInsnsRegister::dup2x2);
register(arr, 0x5f, "swap", 0, 6, Opcode.MOVE_MULTI,
s -> s.peekFrom(-1, 0).peekFrom(1, 1)
.peekFrom(1, 2).peekFrom(0, 3)
.peekFrom(0, 4).peekFrom(-1, 5));
register(arr, 0x60, "iadd", 0, 3, Opcode.ADD_INT, twoRegsWithResult(NARROW));
register(arr, 0x61, "ladd", 0, 3, Opcode.ADD_LONG, twoRegsWithResult(WIDE));
register(arr, 0x62, "fadd", 0, 3, Opcode.ADD_FLOAT, twoRegsWithResult(NARROW));
register(arr, 0x63, "dadd", 0, 3, Opcode.ADD_DOUBLE, twoRegsWithResult(WIDE));
register(arr, 0x64, "isub", 0, 3, Opcode.SUB_INT, twoRegsWithResult(NARROW));
register(arr, 0x65, "lsub", 0, 3, Opcode.SUB_LONG, twoRegsWithResult(WIDE));
register(arr, 0x66, "fsub", 0, 3, Opcode.SUB_FLOAT, twoRegsWithResult(NARROW));
register(arr, 0x67, "dsub", 0, 3, Opcode.SUB_DOUBLE, twoRegsWithResult(WIDE));
register(arr, 0x68, "imul", 0, 3, Opcode.MUL_INT, twoRegsWithResult(NARROW));
register(arr, 0x69, "lmul", 0, 3, Opcode.MUL_LONG, twoRegsWithResult(WIDE));
register(arr, 0x6a, "fmul", 0, 3, Opcode.MUL_FLOAT, twoRegsWithResult(NARROW));
register(arr, 0x6b, "dmul", 0, 3, Opcode.MUL_DOUBLE, twoRegsWithResult(WIDE));
register(arr, 0x6c, "idiv", 0, 3, Opcode.DIV_INT, twoRegsWithResult(NARROW));
register(arr, 0x6d, "ldiv", 0, 3, Opcode.DIV_LONG, twoRegsWithResult(WIDE));
register(arr, 0x6e, "fdiv", 0, 3, Opcode.DIV_FLOAT, twoRegsWithResult(NARROW));
register(arr, 0x6f, "ddiv", 0, 3, Opcode.DIV_DOUBLE, twoRegsWithResult(WIDE));
register(arr, 0x70, "irem", 0, 3, Opcode.REM_INT, twoRegsWithResult(NARROW));
register(arr, 0x71, "lrem", 0, 3, Opcode.REM_LONG, twoRegsWithResult(WIDE));
register(arr, 0x72, "frem", 0, 3, Opcode.REM_FLOAT, twoRegsWithResult(NARROW));
register(arr, 0x73, "drem", 0, 3, Opcode.REM_DOUBLE, twoRegsWithResult(WIDE));
register(arr, 0x74, "ineg", 0, 2, Opcode.NEG_INT, oneRegWithResult(NARROW));
register(arr, 0x75, "lneg", 0, 2, Opcode.NEG_LONG, oneRegWithResult(WIDE));
register(arr, 0x76, "fneg", 0, 2, Opcode.NEG_FLOAT, oneRegWithResult(NARROW));
register(arr, 0x77, "dneg", 0, 2, Opcode.NEG_DOUBLE, oneRegWithResult(WIDE));
register(arr, 0x78, "ishl", 0, 3, Opcode.SHL_INT, twoRegsWithResult(NARROW));
register(arr, 0x79, "lshl", 0, 3, Opcode.SHL_LONG, twoRegsWithResult(WIDE));
register(arr, 0x7a, "ishr", 0, 3, Opcode.SHR_INT, twoRegsWithResult(NARROW));
register(arr, 0x7b, "lshr", 0, 3, Opcode.SHR_LONG, twoRegsWithResult(WIDE));
register(arr, 0x7c, "iushr", 0, 3, Opcode.USHR_INT, twoRegsWithResult(NARROW));
register(arr, 0x7d, "lushr", 0, 3, Opcode.USHR_LONG, twoRegsWithResult(WIDE));
register(arr, 0x7e, "iand", 0, 3, Opcode.AND_INT, twoRegsWithResult(NARROW));
register(arr, 0x7f, "land", 0, 3, Opcode.AND_LONG, twoRegsWithResult(WIDE));
register(arr, 0x80, "ior", 0, 3, Opcode.OR_INT, twoRegsWithResult(NARROW));
register(arr, 0x81, "lor", 0, 3, Opcode.OR_LONG, twoRegsWithResult(WIDE));
register(arr, 0x82, "ixor", 0, 3, Opcode.XOR_INT, twoRegsWithResult(NARROW));
register(arr, 0x83, "lxor", 0, 3, Opcode.XOR_LONG, twoRegsWithResult(WIDE));
register(arr, 0x84, "iinc", 2, 2, Opcode.ADD_INT_LIT, s -> {
int varNum = s.u1();
s.local(0, varNum).local(1, varNum).lit(s.reader().readS1());
});
register(arr, 0x85, "i2l", 0, 2, Opcode.INT_TO_LONG, oneRegWithResult(WIDE));
register(arr, 0x86, "i2f", 0, 2, Opcode.INT_TO_FLOAT, oneRegWithResult(NARROW));
register(arr, 0x87, "i2d", 0, 2, Opcode.INT_TO_DOUBLE, oneRegWithResult(WIDE));
register(arr, 0x88, "l2i", 0, 2, Opcode.LONG_TO_INT, oneRegWithResult(NARROW));
register(arr, 0x89, "l2f", 0, 2, Opcode.LONG_TO_FLOAT, oneRegWithResult(NARROW));
register(arr, 0x8a, "l2d", 0, 2, Opcode.LONG_TO_DOUBLE, oneRegWithResult(WIDE));
register(arr, 0x8b, "f2i", 0, 2, Opcode.FLOAT_TO_INT, oneRegWithResult(NARROW));
register(arr, 0x8c, "f2l", 0, 2, Opcode.FLOAT_TO_LONG, oneRegWithResult(WIDE));
register(arr, 0x8d, "f2d", 0, 2, Opcode.FLOAT_TO_DOUBLE, oneRegWithResult(WIDE));
register(arr, 0x8e, "d2i", 0, 2, Opcode.DOUBLE_TO_INT, oneRegWithResult(NARROW));
register(arr, 0x8f, "d2l", 0, 2, Opcode.DOUBLE_TO_LONG, oneRegWithResult(WIDE));
register(arr, 0x90, "d2f", 0, 2, Opcode.DOUBLE_TO_FLOAT, oneRegWithResult(NARROW));
register(arr, 0x91, "i2b", 0, 2, Opcode.INT_TO_BYTE, oneRegWithResult(NARROW));
register(arr, 0x92, "i2c", 0, 2, Opcode.INT_TO_CHAR, oneRegWithResult(NARROW));
register(arr, 0x93, "i2s", 0, 2, Opcode.INT_TO_SHORT, oneRegWithResult(NARROW));
register(arr, 0x94, "lcmp", 0, 3, Opcode.CMP_LONG, twoRegsWithResult(NARROW));
register(arr, 0x95, "fcmpl", 0, 3, Opcode.CMPL_FLOAT, twoRegsWithResult(NARROW));
register(arr, 0x96, "fcmpg", 0, 3, Opcode.CMPG_FLOAT, twoRegsWithResult(NARROW));
register(arr, 0x97, "dcmpl", 0, 3, Opcode.CMPL_DOUBLE, twoRegsWithResult(NARROW));
register(arr, 0x98, "dcmpg", 0, 3, Opcode.CMPG_DOUBLE, twoRegsWithResult(NARROW));
register(arr, 0x99, "ifeq", 2, 1, Opcode.IF_EQZ, zeroCmp());
register(arr, 0x9a, "ifne", 2, 1, Opcode.IF_NEZ, zeroCmp());
register(arr, 0x9b, "iflt", 2, 1, Opcode.IF_LTZ, zeroCmp());
register(arr, 0x9c, "ifge", 2, 1, Opcode.IF_GEZ, zeroCmp());
register(arr, 0x9d, "ifgt", 2, 1, Opcode.IF_GTZ, zeroCmp());
register(arr, 0x9e, "ifle", 2, 1, Opcode.IF_LEZ, zeroCmp());
register(arr, 0x9f, "if_icmpeq", 2, 2, Opcode.IF_EQ, cmp());
register(arr, 0xa0, "if_icmpne", 2, 2, Opcode.IF_NE, cmp());
register(arr, 0xa1, "if_icmplt", 2, 2, Opcode.IF_LT, cmp());
register(arr, 0xa2, "if_icmpge", 2, 2, Opcode.IF_GE, cmp());
register(arr, 0xa3, "if_icmpgt", 2, 2, Opcode.IF_GT, cmp());
register(arr, 0xa4, "if_icmple", 2, 2, Opcode.IF_LE, cmp());
register(arr, 0xa5, "if_acmpeq", 2, 2, Opcode.IF_EQ, cmp());
register(arr, 0xa6, "if_acmpne", 2, 2, Opcode.IF_NE, cmp());
register(arr, 0xa7, "goto", 2, 0, Opcode.GOTO, s -> s.jump(s.s2()));
register(arr, 0xa8, "jsr", 2, 1, Opcode.JAVA_JSR, s -> s.push(0).jump(s.s2()));
register(arr, 0xa9, "ret", 1, 1, Opcode.JAVA_RET, s -> s.local(0, s.u1()));
register(arr, 0xaa, "tableswitch", -1, 1, Opcode.PACKED_SWITCH, new TableSwitchDecoder());
register(arr, 0xab, "lookupswitch", -1, 1, Opcode.SPARSE_SWITCH, new LookupSwitchDecoder());
register(arr, 0xac, "ireturn", 0, 1, Opcode.RETURN, s -> s.pop(0));
register(arr, 0xad, "lreturn", 0, 1, Opcode.RETURN, s -> s.pop(0));
register(arr, 0xae, "freturn", 0, 1, Opcode.RETURN, s -> s.pop(0));
register(arr, 0xaf, "dreturn", 0, 1, Opcode.RETURN, s -> s.pop(0));
register(arr, 0xb0, "areturn", 0, 1, Opcode.RETURN, s -> s.pop(0));
register(arr, 0xb1, "return", 0, 0, Opcode.RETURN_VOID, null);
register(arr, 0xb2, "getstatic", 2, 1, Opcode.SGET, InsnIndexType.FIELD_REF, s -> s.idx(s.u2()).push(0, s.fieldType()));
register(arr, 0xb3, "putstatic", 2, 1, Opcode.SPUT, InsnIndexType.FIELD_REF, s -> s.idx(s.u2()).pop(0));
register(arr, 0xb4, "getfield", 2, 2, Opcode.IGET, InsnIndexType.FIELD_REF, s -> s.idx(s.u2()).pop(1).push(0, s.fieldType()));
register(arr, 0xb5, "putfield", 2, 2, Opcode.IPUT, InsnIndexType.FIELD_REF, s -> s.idx(s.u2()).pop(0).pop(1));
invoke(arr, 0xb6, "invokevirtual", 2, Opcode.INVOKE_VIRTUAL);
invoke(arr, 0xb7, "invokespecial", 2, Opcode.INVOKE_SPECIAL);
invoke(arr, 0xb8, "invokestatic", 2, Opcode.INVOKE_STATIC);
invoke(arr, 0xb9, "invokeinterface", 4, Opcode.INVOKE_INTERFACE);
invoke(arr, 0xba, "invokedynamic", 4, Opcode.INVOKE_CUSTOM);
register(arr, 0xbb, "new", 2, 1, Opcode.NEW_INSTANCE, InsnIndexType.TYPE_REF, s -> s.idx(s.u2()).push(0));
register(arr, 0xbc, "newarray", 1, 2, Opcode.NEW_ARRAY, InsnIndexType.TYPE_REF, s -> s.idx(s.u1()).pop(1).push(0).lit(1));
register(arr, 0xbd, "anewarray", 2, 2, Opcode.NEW_ARRAY, InsnIndexType.TYPE_REF, s -> s.idx(s.u2()).pop(1).push(0).lit(1));
register(arr, 0xbe, "arraylength", 0, 2, Opcode.ARRAY_LENGTH, oneRegWithResult(NARROW));
register(arr, 0xbf, "athrow", 0, 1, Opcode.THROW, s -> s.pop(0).clear());
register(arr, 0xc0, "checkcast", 2, 2, Opcode.CHECK_CAST, InsnIndexType.TYPE_REF, s -> s.idx(s.u2()).pop(1).push(0));
register(arr, 0xc1, "instanceof", 2, 2, Opcode.INSTANCE_OF, InsnIndexType.TYPE_REF, s -> s.idx(s.u2()).pop(1).push(0));
register(arr, 0xc2, "monitorenter", 0, 1, Opcode.MONITOR_ENTER, s -> s.pop(0));
register(arr, 0xc3, "monitorexit", 0, 1, Opcode.MONITOR_EXIT, s -> s.pop(0));
register(arr, 0xc4, "wide", -1, -1, Opcode.NOP, new WideDecoder());
register(arr, 0xc5, "multianewarray", 3, -1, Opcode.NEW_ARRAY, InsnIndexType.TYPE_REF, newArrayMulti());
register(arr, 0xc6, "ifnull", 2, 1, Opcode.IF_EQZ, zeroCmp());
register(arr, 0xc7, "ifnonnull", 2, 1, Opcode.IF_NEZ, zeroCmp());
register(arr, 0xc8, "goto_w", 4, 0, Opcode.GOTO, s -> s.jump(s.reader().readS4()));
register(arr, 0xc9, "jsr_w", 4, 1, Opcode.JAVA_JSR, s -> s.push(0).jump(s.reader().readS4()));
}
private static void dup2x1(CodeDecodeState s) {
if (s.peekType(0) == NARROW) {
s.insert(2, NARROW);
s.insert(2, NARROW);
s.peekFrom(0, 0).peekFrom(2, 1);
s.peekFrom(1, 2).peekFrom(3, 3);
s.peekFrom(2, 4).peekFrom(4, 5);
s.peekFrom(3, 6).peekFrom(0, 7);
s.peekFrom(4, 8).peekFrom(1, 9);
} else {
s.insn().setRegsCount(6);
s.insert(2, WIDE);
s.peekFrom(0, 0).peekFrom(1, 1);
s.peekFrom(1, 2).peekFrom(2, 3);
s.peekFrom(2, 4).peekFrom(0, 5);
}
}
private static void dup2x2(CodeDecodeState s) {
if (s.peekType(0) == NARROW) {
s.insert(2, NARROW);
s.insert(2, NARROW);
s.peekFrom(0, 0).peekFrom(2, 1);
s.peekFrom(1, 2).peekFrom(3, 3);
s.peekFrom(2, 4).peekFrom(4, 5);
s.peekFrom(3, 6).peekFrom(5, 7);
s.peekFrom(4, 8).peekFrom(0, 9);
s.peekFrom(5, 10).peekFrom(1, 11);
} else {
s.insn().setRegsCount(8);
s.insert(2, WIDE);
s.peekFrom(0, 0).peekFrom(1, 1);
s.peekFrom(1, 2).peekFrom(2, 3);
s.peekFrom(2, 4).peekFrom(3, 5);
s.peekFrom(3, 6).peekFrom(0, 7);
}
}
private static IJavaInsnDecoder newArrayMulti() {
return s -> {
s.idx(s.u2());
int dim = s.u1();
JavaInsnData insn = s.insn();
insn.setLiteral(dim);
insn.setRegsCount(dim + 1);
for (int i = dim; i > 0; i--) {
s.pop(i);
}
s.push(0);
};
}
private static IJavaInsnDecoder oneRegWithResult(StackValueType type) {
return s -> s.pop(1).push(0, type);
}
private static IJavaInsnDecoder twoRegsWithResult(StackValueType type) {
return s -> s.pop(2).pop(1).push(0, type);
}
private static IJavaInsnDecoder aget() {
return s -> s.pop(2).pop(1).push(0);
}
private static IJavaInsnDecoder agetWide() {
return s -> s.pop(2).pop(1).pushWide(0);
}
private static IJavaInsnDecoder aput() {
return s -> s.pop(0).pop(2).pop(1);
}
private static IJavaInsnDecoder zeroCmp() {
return s -> s.pop(0).jump(s.s2());
}
private static IJavaInsnDecoder cmp() {
return s -> s.pop(1).pop(0).jump(s.s2());
}
private static void invoke(JavaInsnInfo[] arr, int opcode, String name, int payloadSize, Opcode apiOpcode) {
InsnIndexType indexType = apiOpcode == Opcode.INVOKE_CUSTOM ? InsnIndexType.CALL_SITE : InsnIndexType.METHOD_REF;
register(arr, opcode, name, payloadSize, -1, apiOpcode, indexType, new InvokeDecoder(payloadSize, apiOpcode));
}
private static void constInsn(JavaInsnInfo[] arr, int opcode, String name, Opcode apiOpcode, long literal) {
register(arr, opcode, name, 0, 1, apiOpcode, InsnIndexType.NONE, state -> {
state.insn().setLiteral(literal);
state.push(0, apiOpcode == Opcode.CONST_WIDE ? StackValueType.WIDE : NARROW);
});
}
private static void loadConst(JavaInsnInfo[] arr, int opcode, String name, boolean wide) {
register(arr, opcode, name, wide ? 2 : 1, 2, Opcode.CONST, InsnIndexType.NONE, new LoadConstDecoder(wide));
}
private static void register(JavaInsnInfo[] arr, int opcode, String name, int payloadSize, int regsCount,
Opcode apiOpcode, IJavaInsnDecoder decoder) {
register(arr, opcode, name, payloadSize, regsCount, apiOpcode, InsnIndexType.NONE, decoder);
}
private static void register(JavaInsnInfo[] arr, int opcode, String name, int payloadSize, int regsCount,
Opcode apiOpcode, InsnIndexType indexType, IJavaInsnDecoder decoder) {
if (arr[opcode] != null) {
throw new IllegalStateException("Duplicate opcode init: 0x" + Integer.toHexString(opcode));
}
arr[opcode] = new JavaInsnInfo(opcode, name, payloadSize, regsCount, apiOpcode, indexType, decoder);
}
@Nullable
public static JavaInsnInfo get(int opcode) {
return INSN_INFO[opcode];
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/ArrayType.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/ArrayType.java | package jadx.plugins.input.java.data.code;
import jadx.plugins.input.java.utils.JavaClassParseException;
public class ArrayType {
public static String byValue(int val) {
switch (val) {
case 4:
return "Z";
case 5:
return "C";
case 6:
return "F";
case 7:
return "D";
case 8:
return "B";
case 9:
return "S";
case 10:
return "I";
case 11:
return "J";
default:
throw new JavaClassParseException("Unknown array type value: " + val);
}
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
skylot/jadx | https://github.com/skylot/jadx/blob/7bbb58863b8a80c0b862425d2701d23be40aeae8/jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/trycatch/JavaTryData.java | jadx-plugins/jadx-java-input/src/main/java/jadx/plugins/input/java/data/code/trycatch/JavaTryData.java | package jadx.plugins.input.java.data.code.trycatch;
import jadx.api.plugins.input.data.ICatch;
import jadx.api.plugins.input.data.ITry;
import jadx.api.plugins.utils.Utils;
public class JavaTryData implements ITry {
private final int startOffset;
private final int endOffset;
private ICatch catchHandler;
public JavaTryData(int startOffset, int endOffset) {
this.startOffset = startOffset;
this.endOffset = endOffset;
}
@Override
public ICatch getCatch() {
return catchHandler;
}
public void setCatch(ICatch catchHandler) {
this.catchHandler = catchHandler;
}
@Override
public int getStartOffset() {
return startOffset;
}
@Override
public int getEndOffset() {
return endOffset;
}
@Override
public int hashCode() {
return startOffset + 31 * endOffset;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof JavaTryData)) {
return false;
}
JavaTryData that = (JavaTryData) o;
return startOffset == that.startOffset && endOffset == that.endOffset;
}
@Override
public String toString() {
return "Try{" + Utils.formatOffset(startOffset) + " - " + Utils.formatOffset(endOffset) + ": " + catchHandler + '}';
}
}
| java | Apache-2.0 | 7bbb58863b8a80c0b862425d2701d23be40aeae8 | 2026-01-04T14:45:57.033910Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.