From 84c1762a62d7fc6638432c6c56e0422aa8cc6939 Mon Sep 17 00:00:00 2001 From: Ben Gruver Date: Tue, 1 Jan 2013 18:16:06 -0800 Subject: [PATCH] Merge DexBuffer functionality into DexBackedDexFile --- .../java/org/jf/dexlib2/DexFileFactory.java | 4 +- .../dexbacked/DexBackedAnnotation.java | 14 +- .../dexbacked/DexBackedAnnotationElement.java | 6 +- .../dexlib2/dexbacked/DexBackedClassDef.java | 38 +-- .../dexlib2/dexbacked/DexBackedDexFile.java | 252 +++++++++++++++-- .../dexbacked/DexBackedExceptionHandler.java | 6 +- .../jf/dexlib2/dexbacked/DexBackedField.java | 12 +- .../jf/dexlib2/dexbacked/DexBackedMethod.java | 31 +-- .../DexBackedMethodImplementation.java | 20 +- .../dexlib2/dexbacked/DexBackedTryBlock.java | 16 +- .../org/jf/dexlib2/dexbacked/DexBuffer.java | 255 ------------------ .../org/jf/dexlib2/dexbacked/DexReader.java | 6 +- .../instruction/DexBackedArrayPayload.java | 18 +- .../instruction/DexBackedInstruction.java | 66 ++--- .../instruction/DexBackedInstruction10t.java | 8 +- .../instruction/DexBackedInstruction10x.java | 6 +- .../instruction/DexBackedInstruction11n.java | 10 +- .../instruction/DexBackedInstruction11x.java | 8 +- .../instruction/DexBackedInstruction12x.java | 10 +- .../instruction/DexBackedInstruction20t.java | 8 +- .../instruction/DexBackedInstruction21c.java | 10 +- .../instruction/DexBackedInstruction21ih.java | 10 +- .../instruction/DexBackedInstruction21lh.java | 10 +- .../instruction/DexBackedInstruction21s.java | 10 +- .../instruction/DexBackedInstruction21t.java | 10 +- .../instruction/DexBackedInstruction22b.java | 12 +- .../instruction/DexBackedInstruction22c.java | 12 +- .../instruction/DexBackedInstruction22s.java | 12 +- .../instruction/DexBackedInstruction22t.java | 12 +- .../instruction/DexBackedInstruction22x.java | 10 +- .../instruction/DexBackedInstruction23x.java | 12 +- .../instruction/DexBackedInstruction30t.java | 8 +- .../instruction/DexBackedInstruction31c.java | 12 +- .../instruction/DexBackedInstruction31i.java | 10 +- .../instruction/DexBackedInstruction31t.java | 10 +- .../instruction/DexBackedInstruction32x.java | 10 +- .../instruction/DexBackedInstruction35c.java | 22 +- .../instruction/DexBackedInstruction3rc.java | 14 +- .../instruction/DexBackedInstruction51l.java | 10 +- .../DexBackedPackedSwitchPayload.java | 12 +- .../DexBackedSparseSwitchPayload.java | 12 +- .../reference/DexBackedFieldReference.java | 16 +- .../reference/DexBackedMethodReference.java | 32 ++- .../reference/DexBackedReference.java | 12 +- .../reference/DexBackedStringReference.java | 10 +- .../reference/DexBackedTypeReference.java | 10 +- .../dexbacked/util/AnnotationsDirectory.java | 46 ++-- .../jf/dexlib2/dexbacked/util/DebugInfo.java | 32 +-- .../util/StaticInitialValueIterator.java | 10 +- .../util/VariableSizeCollection.java | 11 +- .../dexbacked/util/VariableSizeIterator.java | 6 +- .../dexbacked/util/VariableSizeList.java | 10 +- .../util/VariableSizeListIterator.java | 6 +- .../util/VariableSizeLookaheadIterator.java | 6 +- .../dexbacked/util/VariableSizeSet.java | 11 +- .../DexBackedAnnotationEncodedValue.java | 10 +- .../value/DexBackedArrayEncodedValue.java | 8 +- .../value/DexBackedEnumEncodedValue.java | 8 +- .../value/DexBackedFieldEncodedValue.java | 8 +- .../value/DexBackedMethodEncodedValue.java | 8 +- .../value/DexBackedStringEncodedValue.java | 8 +- .../value/DexBackedTypeEncodedValue.java | 8 +- 62 files changed, 636 insertions(+), 674 deletions(-) delete mode 100644 dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBuffer.java diff --git a/dexlib2/src/main/java/org/jf/dexlib2/DexFileFactory.java b/dexlib2/src/main/java/org/jf/dexlib2/DexFileFactory.java index 1de9e4c8..8b6aea03 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/DexFileFactory.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/DexFileFactory.java @@ -34,7 +34,6 @@ package org.jf.dexlib2; import com.google.common.io.ByteStreams; import com.google.common.io.Files; import org.jf.dexlib2.dexbacked.DexBackedDexFile; -import org.jf.dexlib2.dexbacked.DexBuffer; import org.jf.dexlib2.iface.DexFile; import org.jf.util.ExceptionWithContext; @@ -94,8 +93,7 @@ public final class DexFileFactory { dexBytes = Files.toByteArray(dexFile); } - DexBuffer dexBuf = new DexBuffer(dexBytes); - return new DexBackedDexFile(dexBuf); + return new DexBackedDexFile.Impl(dexBytes); } public static void writeDexFile(String path, DexFile dexFile) throws IOException { diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java index 804d7032..480c6998 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java @@ -38,32 +38,32 @@ import javax.annotation.Nonnull; import java.util.Set; public class DexBackedAnnotation extends BaseAnnotation { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; public final int visibility; public final int typeIndex; private final int elementsOffset; - public DexBackedAnnotation(@Nonnull DexBuffer dexBuf, + public DexBackedAnnotation(@Nonnull DexBackedDexFile dexFile, int annotationOffset) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; - DexReader reader = dexBuf.readerAt(annotationOffset); + DexReader reader = dexFile.readerAt(annotationOffset); this.visibility = reader.readUbyte(); this.typeIndex = reader.readSmallUleb128(); this.elementsOffset = reader.getOffset(); } @Override public int getVisibility() { return visibility; } - @Nonnull @Override public String getType() { return dexBuf.getType(typeIndex); } + @Nonnull @Override public String getType() { return dexFile.getType(typeIndex); } @Nonnull @Override public Set getElements() { - DexReader reader = dexBuf.readerAt(elementsOffset); + DexReader reader = dexFile.readerAt(elementsOffset); final int size = reader.readSmallUleb128(); - return new VariableSizeSet(dexBuf, reader.getOffset(), size) { + return new VariableSizeSet(dexFile, reader.getOffset(), size) { @Nonnull @Override protected DexBackedAnnotationElement readNextItem(@Nonnull DexReader reader, int index) { diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java index 10806c2a..d55bf4c2 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java @@ -38,16 +38,16 @@ import org.jf.dexlib2.iface.value.EncodedValue; import javax.annotation.Nonnull; public class DexBackedAnnotationElement extends BaseAnnotationElement { - @Nonnull private final DexBuffer dexBuf; + @Nonnull private final DexBackedDexFile dexFile; public final int nameIndex; @Nonnull public final EncodedValue value; public DexBackedAnnotationElement(@Nonnull DexReader reader) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; this.nameIndex = reader.readSmallUleb128(); this.value = DexBackedEncodedValue.readFrom(reader); } - @Nonnull @Override public String getName() { return dexBuf.getString(nameIndex); } + @Nonnull @Override public String getName() { return dexFile.getString(nameIndex); } @Nonnull @Override public EncodedValue getValue() { return value; } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java index f788b0d4..c6dc2326 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java @@ -46,7 +46,7 @@ import java.util.Iterator; import java.util.Set; public class DexBackedClassDef extends BaseTypeReference implements ClassDef { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int classDefOffset; private int classDataOffset = -1; @@ -63,46 +63,46 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { private static final int CLASS_DATA_OFFSET = 24; private static final int STATIC_INITIAL_VALUES_OFFSET = 28; - public DexBackedClassDef(@Nonnull DexBuffer dexBuf, + public DexBackedClassDef(@Nonnull DexBackedDexFile dexFile, int classDefOffset) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; this.classDefOffset = classDefOffset; } @Nonnull @Override public String getType() { - return dexBuf.getType(dexBuf.readSmallUint(classDefOffset + CLASS_NAME_OFFSET)); + return dexFile.getType(dexFile.readSmallUint(classDefOffset + CLASS_NAME_OFFSET)); } @Nullable @Override public String getSuperclass() { - return dexBuf.getOptionalType(dexBuf.readOptionalUint(classDefOffset + SUPERCLASS_OFFSET)); + return dexFile.getOptionalType(dexFile.readOptionalUint(classDefOffset + SUPERCLASS_OFFSET)); } @Override public int getAccessFlags() { - return dexBuf.readSmallUint(classDefOffset + ACCESS_FLAGS_OFFSET); + return dexFile.readSmallUint(classDefOffset + ACCESS_FLAGS_OFFSET); } @Nullable @Override public String getSourceFile() { - return dexBuf.getOptionalString(dexBuf.readOptionalUint(classDefOffset + SOURCE_FILE_OFFSET)); + return dexFile.getOptionalString(dexFile.readOptionalUint(classDefOffset + SOURCE_FILE_OFFSET)); } @Nonnull @Override public Set getInterfaces() { - final int interfacesOffset = dexBuf.readSmallUint(classDefOffset + INTERFACES_OFFSET); + final int interfacesOffset = dexFile.readSmallUint(classDefOffset + INTERFACES_OFFSET); if (interfacesOffset > 0) { - final int size = dexBuf.readSmallUint(interfacesOffset); + final int size = dexFile.readSmallUint(interfacesOffset); return new FixedSizeSet() { @Nonnull @Override public String readItem(int index) { - return dexBuf.getType(dexBuf.readUshort(interfacesOffset + 4 + (2*index))); + return dexFile.getType(dexFile.readUshort(interfacesOffset + 4 + (2*index))); } @Override public int size() { return size; } @@ -122,7 +122,7 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { public Set getFields() { int classDataOffset = getClassDataOffset(); if (getClassDataOffset() != 0) { - DexReader reader = dexBuf.readerAt(classDataOffset); + DexReader reader = dexFile.readerAt(classDataOffset); final int staticFieldCount = reader.readSmallUleb128(); int instanceFieldCount = reader.readSmallUleb128(); final int fieldCount = staticFieldCount + instanceFieldCount; @@ -132,19 +132,19 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { final AnnotationsDirectory annotationsDirectory = getAnnotationsDirectory(); final int staticInitialValuesOffset = - dexBuf.readSmallUint(classDefOffset + STATIC_INITIAL_VALUES_OFFSET); + dexFile.readSmallUint(classDefOffset + STATIC_INITIAL_VALUES_OFFSET); final int fieldsStartOffset = reader.getOffset(); return new AbstractSet() { @Nonnull @Override public Iterator iterator() { - return new VariableSizeIterator(dexBuf, fieldsStartOffset, fieldCount) { + return new VariableSizeIterator(dexFile, fieldsStartOffset, fieldCount) { private int previousFieldIndex = 0; @Nonnull private final AnnotationsDirectory.AnnotationIterator annotationIterator = annotationsDirectory.getFieldAnnotationIterator(); @Nonnull private final StaticInitialValueIterator staticInitialValueIterator = - StaticInitialValueIterator.newOrEmpty(dexBuf, staticInitialValuesOffset); + StaticInitialValueIterator.newOrEmpty(dexFile, staticInitialValuesOffset); @Nonnull @Override @@ -175,7 +175,7 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { public Set getMethods() { int classDataOffset = getClassDataOffset(); if (classDataOffset > 0) { - DexReader reader = dexBuf.readerAt(classDataOffset); + DexReader reader = dexFile.readerAt(classDataOffset); int staticFieldCount = reader.readSmallUleb128(); int instanceFieldCount = reader.readSmallUleb128(); final int directMethodCount = reader.readSmallUleb128(); @@ -191,7 +191,7 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { @Nonnull @Override public Iterator iterator() { - return new VariableSizeIterator(dexBuf, methodsStartOffset, methodCount) { + return new VariableSizeIterator(dexFile, methodsStartOffset, methodCount) { private int previousMethodIndex = 0; @Nonnull private final AnnotationsDirectory.AnnotationIterator methodAnnotationIterator = annotationsDirectory.getMethodAnnotationIterator(); @@ -225,15 +225,15 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { private int getClassDataOffset() { if (classDataOffset == -1) { - classDataOffset = dexBuf.readSmallUint(classDefOffset + CLASS_DATA_OFFSET); + classDataOffset = dexFile.readSmallUint(classDefOffset + CLASS_DATA_OFFSET); } return classDataOffset; } private AnnotationsDirectory getAnnotationsDirectory() { if (annotationsDirectory == null) { - int annotationsDirectoryOffset = dexBuf.readSmallUint(classDefOffset + ANNOTATIONS_OFFSET); - annotationsDirectory = AnnotationsDirectory.newOrEmpty(dexBuf, annotationsDirectoryOffset); + int annotationsDirectoryOffset = dexFile.readSmallUint(classDefOffset + ANNOTATIONS_OFFSET); + annotationsDirectory = AnnotationsDirectory.newOrEmpty(dexFile, annotationsDirectoryOffset); } return annotationsDirectory; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java index 4b1b66fd..6faf0b08 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java @@ -33,34 +33,246 @@ package org.jf.dexlib2.dexbacked; import org.jf.dexlib2.dexbacked.util.FixedSizeSet; import org.jf.dexlib2.iface.DexFile; +import org.jf.util.ExceptionWithContext; +import org.jf.util.Utf8Utils; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import java.util.Set; -public class DexBackedDexFile implements DexFile { - @Nonnull public final DexBuffer dexBuf; - - public DexBackedDexFile(@Nonnull DexBuffer dexBuf) { - this.dexBuf = dexBuf; +public abstract class DexBackedDexFile extends BaseDexBuffer implements DexFile { + public DexBackedDexFile(@Nonnull byte[] buf) { + super(buf); } - @Nonnull - @Override - public Set getClasses() { - final int classCount = dexBuf.getClassCount(); + @Nonnull public abstract String getString(int stringIndex); + @Nullable public abstract String getOptionalString(int stringIndex); + @Nonnull public abstract String getType(int typeIndex); + @Nullable public abstract String getOptionalType(int typeIndex); - return new FixedSizeSet() { - @Nonnull - @Override - public DexBackedClassDef readItem(int index) { - int classOffset = dexBuf.getClassDefItemOffset(index); - return new DexBackedClassDef(dexBuf, classOffset); - } + // TODO: refactor how dex items are read + public abstract int getMethodIdItemOffset(int methodIndex); + public abstract int getProtoIdItemOffset(int protoIndex); + public abstract int getFieldIdItemOffset(int fieldIndex); - @Override - public int size() { - return classCount; + @Override @Nonnull public abstract DexReader readerAt(int offset); + + public static class Impl extends DexBackedDexFile { + private final int stringCount; + private final int stringStartOffset; + private final int typeCount; + private final int typeStartOffset; + private final int protoCount; + private final int protoStartOffset; + private final int fieldCount; + private final int fieldStartOffset; + private final int methodCount; + private final int methodStartOffset; + private final int classCount; + private final int classStartOffset; + + private static final byte[][] MAGIC_VALUES= new byte[][] { + new byte[]{0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x35, 0x00}, + new byte[]{0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x36, 0x00}}; + + private static final int LITTLE_ENDIAN_TAG = 0x12345678; + private static final int BIG_ENDIAN_TAG = 0x78563412; + + private static final int CHECKSUM_OFFSET = 8; + private static final int SIGNATURE_OFFSET = 12; + private static final int ENDIAN_TAG_OFFSET = 40; + private static final int MAP_OFFSET = 52; + private static final int STRING_COUNT_OFFSET = 56; + private static final int STRING_START_OFFSET = 60; + private static final int TYPE_COUNT_OFFSET = 64; + private static final int TYPE_START_OFFSET = 68; + private static final int PROTO_COUNT_OFFSET = 72; + private static final int PROTO_START_OFFSET = 76; + private static final int FIELD_COUNT_OFFSET = 80; + private static final int FIELD_START_OFFSET = 84; + private static final int METHOD_COUNT_OFFSET = 88; + private static final int METHOD_START_OFFSET = 92; + private static final int CLASS_COUNT_OFFSET = 96; + private static final int CLASS_START_OFFSET = 100; + + private static final int SIGNATURE_SIZE = 20; + + private static final int STRING_ID_ITEM_SIZE = 4; + private static final int TYPE_ID_ITEM_SIZE = 4; + private static final int PROTO_ID_ITEM_SIZE = 12; + private static final int FIELD_ID_ITEM_SIZE = 8; + private static final int METHOD_ID_ITEM_SIZE = 8; + private static final int CLASS_DEF_ITEM_SIZE = 32; + public static final int MAP_ITEM_SIZE = 12; + + public static final int FIELD_CLASS_IDX_OFFSET = 0; + public static final int FIELD_TYPE_IDX_OFFSET = 2; + public static final int FIELD_NAME_IDX_OFFSET = 4; + + public static final int METHOD_CLASS_IDX_OFFSET = 0; + public static final int METHOD_PROTO_IDX_OFFSET = 2; + public static final int METHOD_NAME_IDX_OFFSET = 4; + + public static final int PROTO_RETURN_TYPE_IDX_OFFSET = 4; + public static final int PROTO_PARAM_LIST_OFF_OFFSET = 8; + + public static final int TYPE_LIST_SIZE_OFFSET = 0; + public static final int TYPE_LIST_LIST_OFFSET = 4; + + public Impl(@Nonnull byte[] buf) { + super(buf); + + verifyMagic(); + verifyEndian(); + stringCount = readSmallUint(STRING_COUNT_OFFSET); + stringStartOffset = readSmallUint(STRING_START_OFFSET); + typeCount = readSmallUint(TYPE_COUNT_OFFSET); + typeStartOffset = readSmallUint(TYPE_START_OFFSET); + protoCount = readSmallUint(PROTO_COUNT_OFFSET); + protoStartOffset = readSmallUint(PROTO_START_OFFSET); + fieldCount = readSmallUint(FIELD_COUNT_OFFSET); + fieldStartOffset = readSmallUint(FIELD_START_OFFSET); + methodCount = readSmallUint(METHOD_COUNT_OFFSET); + methodStartOffset = readSmallUint(METHOD_START_OFFSET); + classCount = readSmallUint(CLASS_COUNT_OFFSET); + classStartOffset = readSmallUint(CLASS_START_OFFSET); + } + + @Nonnull + @Override + public Set getClasses() { + return new FixedSizeSet() { + @Nonnull + @Override + public DexBackedClassDef readItem(int index) { + return new DexBackedClassDef(Impl.this, getClassDefItemOffset(index)); + } + + @Override + public int size() { + return classCount; + } + }; + } + + private void verifyMagic() { + outer: for (byte[] magic: MAGIC_VALUES) { + for (int i=0; i= stringCount) { + throw new ExceptionWithContext("String index out of bounds: %d", stringIndex); + } + return stringStartOffset + stringIndex*STRING_ID_ITEM_SIZE; + } + + public int getTypeIdItemOffset(int typeIndex) { + if (typeIndex < 0 || typeIndex >= typeCount) { + throw new ExceptionWithContext("Type index out of bounds: %d", typeIndex); + } + return typeStartOffset + typeIndex*TYPE_ID_ITEM_SIZE; + } + + @Override + public int getFieldIdItemOffset(int fieldIndex) { + if (fieldIndex < 0 || fieldIndex >= fieldCount) { + throw new ExceptionWithContext("Field index out of bounds: %d", fieldIndex); + } + return fieldStartOffset + fieldIndex*FIELD_ID_ITEM_SIZE; + } + + @Override + public int getMethodIdItemOffset(int methodIndex) { + if (methodIndex < 0 || methodIndex >= methodCount) { + throw new ExceptionWithContext("Method index out of bounds: %d", methodIndex); + } + return methodStartOffset + methodIndex*METHOD_ID_ITEM_SIZE; + } + + @Override + public int getProtoIdItemOffset(int protoIndex) { + if (protoIndex < 0 || protoIndex >= protoCount) { + throw new ExceptionWithContext("Proto index out of bounds: %d", protoIndex); + } + return protoStartOffset + protoIndex*PROTO_ID_ITEM_SIZE; + } + + public int getClassDefItemOffset(int classIndex) { + if (classIndex < 0 || classIndex >= classCount) { + throw new ExceptionWithContext("Class index out of bounds: %d", classIndex); + } + return classStartOffset + classIndex*CLASS_DEF_ITEM_SIZE; + } + + public int getClassCount() { + return classCount; + } + + @Override + @Nonnull + public String getString(int stringIndex) { + int stringOffset = getStringIdItemOffset(stringIndex); + int stringDataOffset = readSmallUint(stringOffset); + DexReader reader = readerAt(stringDataOffset); + int utf16Length = reader.readSmallUleb128(); + return Utf8Utils.utf8BytesWithUtf16LengthToString(buf, reader.getOffset(), utf16Length); + } + + @Override + @Nullable + public String getOptionalString(int stringIndex) { + if (stringIndex == -1) { + return null; + } + return getString(stringIndex); + } + + @Override + @Nonnull + public String getType(int typeIndex) { + int typeOffset = getTypeIdItemOffset(typeIndex); + int stringIndex = readSmallUint(typeOffset); + return getString(stringIndex); + } + + @Override + @Nullable + public String getOptionalType(int typeIndex) { + if (typeIndex == -1) { + return null; + } + return getType(typeIndex); + } + + @Override + @Nonnull + public DexReader readerAt(int offset) { + return new DexReader(this, offset); + } } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java index 9aca7352..a8ce5833 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java @@ -37,17 +37,17 @@ import org.jf.dexlib2.iface.ExceptionHandler; import javax.annotation.Nonnull; public class DexBackedExceptionHandler extends BaseExceptionHandler implements ExceptionHandler { - @Nonnull private final DexBuffer dexBuf; + @Nonnull private final DexBackedDexFile dexFile; private final int typeId; private final int handlerCodeAddress; public DexBackedExceptionHandler(@Nonnull DexReader reader) { // TODO: verify dalvik doesn't accept an exception handler that points in the middle of an instruction - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; this.typeId = reader.readSmallUleb128(); this.handlerCodeAddress = reader.readSmallUleb128(); } - @Nonnull @Override public String getExceptionType() { return dexBuf.getType(typeId); } + @Nonnull @Override public String getExceptionType() { return dexFile.getType(typeId); } @Override public int getHandlerCodeAddress() { return handlerCodeAddress; } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java index 847c55c7..a3539c3f 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java @@ -43,7 +43,7 @@ import javax.annotation.Nullable; import java.util.Set; public class DexBackedField extends BaseFieldReference implements Field { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; @Nonnull public final ClassDef classDef; public final int accessFlags; @@ -63,7 +63,7 @@ public class DexBackedField extends BaseFieldReference implements Field { int previousFieldIndex, @Nonnull StaticInitialValueIterator staticInitialValueIterator, @Nonnull AnnotationsDirectory.AnnotationIterator annotationIterator) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; this.classDef = classDef; int fieldIndexDiff = reader.readSmallUleb128(); @@ -77,13 +77,13 @@ public class DexBackedField extends BaseFieldReference implements Field { @Nonnull @Override public String getName() { - return dexBuf.getString(dexBuf.readSmallUint(getFieldIdItemOffset() + NAME_OFFSET)); + return dexFile.getString(dexFile.readSmallUint(getFieldIdItemOffset() + NAME_OFFSET)); } @Nonnull @Override public String getType() { - return dexBuf.getType(dexBuf.readUshort(getFieldIdItemOffset() + TYPE_OFFSET)); + return dexFile.getType(dexFile.readUshort(getFieldIdItemOffset() + TYPE_OFFSET)); } @Nonnull @Override public String getDefiningClass() { return classDef.getType(); } @@ -93,7 +93,7 @@ public class DexBackedField extends BaseFieldReference implements Field { @Nonnull @Override public Set getAnnotations() { - return AnnotationsDirectory.getAnnotations(dexBuf, annotationSetOffset); + return AnnotationsDirectory.getAnnotations(dexFile, annotationSetOffset); } /** @@ -111,7 +111,7 @@ public class DexBackedField extends BaseFieldReference implements Field { private int getFieldIdItemOffset() { if (fieldIdItemOffset == 0) { - fieldIdItemOffset = dexBuf.getFieldIdItemOffset(fieldIndex); + fieldIdItemOffset = dexFile.getFieldIdItemOffset(fieldIndex); } return fieldIdItemOffset; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java index 352c95e4..13cee37f 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java @@ -49,7 +49,7 @@ import java.util.List; import java.util.Set; public class DexBackedMethod extends BaseMethodReference implements Method { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; @Nonnull public final DexBackedClassDef classDef; public final int accessFlags; @@ -75,7 +75,7 @@ public class DexBackedMethod extends BaseMethodReference implements Method { public DexBackedMethod(@Nonnull DexReader reader, @Nonnull DexBackedClassDef classDef, int previousMethodIndex) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; this.classDef = classDef; int methodIndexDiff = reader.readSmallUleb128(); @@ -92,7 +92,7 @@ public class DexBackedMethod extends BaseMethodReference implements Method { int previousMethodIndex, @Nonnull AnnotationsDirectory.AnnotationIterator methodAnnotationIterator, @Nonnull AnnotationsDirectory.AnnotationIterator paramaterAnnotationIterator) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; this.classDef = classDef; int methodIndexDiff = reader.readSmallUleb128(); @@ -111,13 +111,13 @@ public class DexBackedMethod extends BaseMethodReference implements Method { @Nonnull @Override public String getName() { - return dexBuf.getString(dexBuf.readSmallUint(getMethodIdItemOffset() + NAME_OFFSET)); + return dexFile.getString(dexFile.readSmallUint(getMethodIdItemOffset() + NAME_OFFSET)); } @Nonnull @Override public String getReturnType() { - return dexBuf.getType(dexBuf.readSmallUint(getProtoIdItemOffset() + RETURN_TYPE_OFFSET)); + return dexFile.getType(dexFile.readSmallUint(getProtoIdItemOffset() + RETURN_TYPE_OFFSET)); } @Nonnull @@ -144,7 +144,7 @@ public class DexBackedMethod extends BaseMethodReference implements Method { @Nonnull public List> getParameterAnnotations() { - return AnnotationsDirectory.getParameterAnnotations(dexBuf, parameterAnnotationSetListOffset); + return AnnotationsDirectory.getParameterAnnotations(dexFile, parameterAnnotationSetListOffset); } @Nonnull @@ -161,13 +161,14 @@ public class DexBackedMethod extends BaseMethodReference implements Method { public List getParameterTypes() { final int parametersOffset = getParametersOffset(); if (parametersOffset > 0) { - final int parameterCount = dexBuf.readSmallUint(parametersOffset + DexBuffer.TYPE_LIST_SIZE_OFFSET); - final int paramListStart = parametersOffset + DexBuffer.TYPE_LIST_LIST_OFFSET; + final int parameterCount = dexFile.readSmallUint(parametersOffset + + DexBackedDexFile.Impl.TYPE_LIST_SIZE_OFFSET); + final int paramListStart = parametersOffset + DexBackedDexFile.Impl.TYPE_LIST_LIST_OFFSET; return new FixedSizeList() { @Nonnull @Override public String readItem(final int index) { - return dexBuf.getType(dexBuf.readUshort(paramListStart + 2*index)); + return dexFile.getType(dexFile.readUshort(paramListStart + 2*index)); } @Override public int size() { return parameterCount; } }; @@ -178,36 +179,36 @@ public class DexBackedMethod extends BaseMethodReference implements Method { @Nonnull @Override public Set getAnnotations() { - return AnnotationsDirectory.getAnnotations(dexBuf, methodAnnotationSetOffset); + return AnnotationsDirectory.getAnnotations(dexFile, methodAnnotationSetOffset); } @Nullable @Override public DexBackedMethodImplementation getImplementation() { if (codeOffset > 0) { - return new DexBackedMethodImplementation(dexBuf, this, codeOffset); + return new DexBackedMethodImplementation(dexFile, this, codeOffset); } return null; } private int getMethodIdItemOffset() { if (methodIdItemOffset == 0) { - methodIdItemOffset = dexBuf.getMethodIdItemOffset(methodIndex); + methodIdItemOffset = dexFile.getMethodIdItemOffset(methodIndex); } return methodIdItemOffset; } private int getProtoIdItemOffset() { if (protoIdItemOffset == 0) { - int protoIndex = dexBuf.readUshort(getMethodIdItemOffset() + PROTO_OFFSET); - protoIdItemOffset = dexBuf.getProtoIdItemOffset(protoIndex); + int protoIndex = dexFile.readUshort(getMethodIdItemOffset() + PROTO_OFFSET); + protoIdItemOffset = dexFile.getProtoIdItemOffset(protoIndex); } return protoIdItemOffset; } private int getParametersOffset() { if (parametersOffset == -1) { - parametersOffset = dexBuf.readSmallUint(getProtoIdItemOffset() + PARAMETERS_OFFSET); + parametersOffset = dexFile.readSmallUint(getProtoIdItemOffset() + PARAMETERS_OFFSET); } return parametersOffset; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java index c485b2e7..90d99a46 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java @@ -48,7 +48,7 @@ import java.util.Iterator; import java.util.List; public class DexBackedMethodImplementation implements MethodImplementation { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; @Nonnull public final DexBackedMethod method; private final int codeOffset; @@ -60,26 +60,26 @@ public class DexBackedMethodImplementation implements MethodImplementation { private static final int TRY_ITEM_SIZE = 8; - public DexBackedMethodImplementation(@Nonnull DexBuffer dexBuf, + public DexBackedMethodImplementation(@Nonnull DexBackedDexFile dexFile, @Nonnull DexBackedMethod method, int codeOffset) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; this.method = method; this.codeOffset = codeOffset; } - @Override public int getRegisterCount() { return dexBuf.readUshort(codeOffset); } + @Override public int getRegisterCount() { return dexFile.readUshort(codeOffset); } @Nonnull @Override public Iterable getInstructions() { // instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions - int instructionsSize = dexBuf.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET); + int instructionsSize = dexFile.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET); final int instructionsStartOffset = codeOffset + INSTRUCTIONS_START_OFFSET; final int endOffset = instructionsStartOffset + (instructionsSize*2); return new Iterable() { @Override public Iterator iterator() { - return new VariableSizeLookaheadIterator(dexBuf, instructionsStartOffset) { + return new VariableSizeLookaheadIterator(dexFile, instructionsStartOffset) { @Override protected Instruction readNextItem(@Nonnull DexReader reader) { if (reader.getOffset() >= endOffset) { @@ -96,9 +96,9 @@ public class DexBackedMethodImplementation implements MethodImplementation { @Override public List getTryBlocks() { // TODO: provide utility to put try blocks into a "canonical", easy to use format, which more closely matches java's try blocks - final int triesSize = dexBuf.readUshort(codeOffset + TRIES_SIZE_OFFSET); + final int triesSize = dexFile.readUshort(codeOffset + TRIES_SIZE_OFFSET); if (triesSize > 0) { - int instructionsSize = dexBuf.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET); + int instructionsSize = dexFile.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET); final int triesStartOffset = AlignmentUtils.alignOffset( codeOffset + INSTRUCTIONS_START_OFFSET + (instructionsSize*2), 4); final int handlersStartOffset = triesStartOffset + triesSize*TRY_ITEM_SIZE; @@ -107,7 +107,7 @@ public class DexBackedMethodImplementation implements MethodImplementation { @Nonnull @Override public TryBlock readItem(int index) { - return new DexBackedTryBlock(dexBuf, + return new DexBackedTryBlock(dexFile, triesStartOffset + index*TRY_ITEM_SIZE, handlersStartOffset); } @@ -123,7 +123,7 @@ public class DexBackedMethodImplementation implements MethodImplementation { @Nonnull private DebugInfo getDebugInfo() { - return DebugInfo.newOrEmpty(dexBuf, dexBuf.readSmallUint(codeOffset + DEBUG_OFFSET_OFFSET), this); + return DebugInfo.newOrEmpty(dexFile, dexFile.readSmallUint(codeOffset + DEBUG_OFFSET_OFFSET), this); } @Nonnull @Override diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java index 7f120842..e39f4c5b 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java @@ -39,7 +39,7 @@ import javax.annotation.Nonnull; import java.util.List; public class DexBackedTryBlock implements TryBlock { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int tryItemOffset; private final int handlersStartOffset; @@ -47,27 +47,27 @@ public class DexBackedTryBlock implements TryBlock { private static final int CODE_UNIT_COUNT_OFFSET = 4; private static final int HANDLER_OFFSET_OFFSET = 6; - public DexBackedTryBlock(@Nonnull DexBuffer dexBuf, + public DexBackedTryBlock(@Nonnull DexBackedDexFile dexFile, int tryItemOffset, int handlersStartOffset) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; this.tryItemOffset = tryItemOffset; this.handlersStartOffset = handlersStartOffset; } - @Override public int getStartCodeAddress() { return dexBuf.readSmallUint(tryItemOffset + START_ADDRESS_OFFSET); } - @Override public int getCodeUnitCount() { return dexBuf.readUshort(tryItemOffset + CODE_UNIT_COUNT_OFFSET); } + @Override public int getStartCodeAddress() { return dexFile.readSmallUint(tryItemOffset + START_ADDRESS_OFFSET); } + @Override public int getCodeUnitCount() { return dexFile.readUshort(tryItemOffset + CODE_UNIT_COUNT_OFFSET); } @Nonnull @Override public List getExceptionHandlers() { DexReader reader = - dexBuf.readerAt(handlersStartOffset + dexBuf.readUshort(tryItemOffset + HANDLER_OFFSET_OFFSET)); + dexFile.readerAt(handlersStartOffset + dexFile.readUshort(tryItemOffset + HANDLER_OFFSET_OFFSET)); final int encodedSize = reader.readSleb128(); if (encodedSize > 0) { //no catch-all - return new VariableSizeList(dexBuf, reader.getOffset(), encodedSize) { + return new VariableSizeList(dexFile, reader.getOffset(), encodedSize) { @Nonnull @Override protected ExceptionHandler readNextItem(@Nonnull DexReader reader, int index) { @@ -77,7 +77,7 @@ public class DexBackedTryBlock implements TryBlock { } else { //with catch-all final int sizeWithCatchAll = (-1 * encodedSize) + 1; - return new VariableSizeList(dexBuf, reader.getOffset(), sizeWithCatchAll) { + return new VariableSizeList(dexFile, reader.getOffset(), sizeWithCatchAll) { @Nonnull @Override protected ExceptionHandler readNextItem(@Nonnull DexReader dexReader, int index) { diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBuffer.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBuffer.java deleted file mode 100644 index 601f1b2d..00000000 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBuffer.java +++ /dev/null @@ -1,255 +0,0 @@ -/* - * Copyright 2013, Google Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following disclaimer - * in the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Google Inc. nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -package org.jf.dexlib2.dexbacked; - -import org.jf.util.ExceptionWithContext; -import org.jf.util.Utf8Utils; - -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import java.util.Arrays; - -public class DexBuffer extends BaseDexBuffer { - public final int stringCount; - public final int stringStartOffset; - public final int typeCount; - public final int typeStartOffset; - public final int protoCount; - public final int protoStartOffset; - public final int fieldCount; - public final int fieldStartOffset; - public final int methodCount; - public final int methodStartOffset; - public final int classCount; - public final int classStartOffset; - - @Nonnull private final String[] stringCache; - - private static final byte[][] MAGIC_VALUES= new byte[][] { - new byte[]{0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x35, 0x00}, - new byte[]{0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x36, 0x00}}; - - private static final int LITTLE_ENDIAN_TAG = 0x12345678; - private static final int BIG_ENDIAN_TAG = 0x78563412; - - private static final int CHECKSUM_OFFSET = 8; - private static final int SIGNATURE_OFFSET = 12; - private static final int ENDIAN_TAG_OFFSET = 40; - private static final int MAP_OFFSET = 52; - private static final int STRING_COUNT_OFFSET = 56; - private static final int STRING_START_OFFSET = 60; - private static final int TYPE_COUNT_OFFSET = 64; - private static final int TYPE_START_OFFSET = 68; - private static final int PROTO_COUNT_OFFSET = 72; - private static final int PROTO_START_OFFSET = 76; - private static final int FIELD_COUNT_OFFSET = 80; - private static final int FIELD_START_OFFSET = 84; - private static final int METHOD_COUNT_OFFSET = 88; - private static final int METHOD_START_OFFSET = 92; - private static final int CLASS_COUNT_OFFSET = 96; - private static final int CLASS_START_OFFSET = 100; - - private static final int SIGNATURE_SIZE = 20; - - private static final int STRING_ID_ITEM_SIZE = 4; - private static final int TYPE_ID_ITEM_SIZE = 4; - private static final int PROTO_ID_ITEM_SIZE = 12; - private static final int FIELD_ID_ITEM_SIZE = 8; - private static final int METHOD_ID_ITEM_SIZE = 8; - private static final int CLASS_DEF_ITEM_SIZE = 32; - public static final int MAP_ITEM_SIZE = 12; - - public static final int FIELD_CLASS_IDX_OFFSET = 0; - public static final int FIELD_TYPE_IDX_OFFSET = 2; - public static final int FIELD_NAME_IDX_OFFSET = 4; - - public static final int METHOD_CLASS_IDX_OFFSET = 0; - public static final int METHOD_PROTO_IDX_OFFSET = 2; - public static final int METHOD_NAME_IDX_OFFSET = 4; - - public static final int PROTO_RETURN_TYPE_IDX_OFFSET = 4; - public static final int PROTO_PARAM_LIST_OFF_OFFSET = 8; - - public static final int TYPE_LIST_SIZE_OFFSET = 0; - public static final int TYPE_LIST_LIST_OFFSET = 4; - - public DexBuffer(@Nonnull byte[] buf) { - super(buf); - - verifyMagic(); - verifyEndian(); - stringCount = readSmallUint(STRING_COUNT_OFFSET); - stringStartOffset = readSmallUint(STRING_START_OFFSET); - typeCount = readSmallUint(TYPE_COUNT_OFFSET); - typeStartOffset = readSmallUint(TYPE_START_OFFSET); - protoCount = readSmallUint(PROTO_COUNT_OFFSET); - protoStartOffset = readSmallUint(PROTO_START_OFFSET); - fieldCount = readSmallUint(FIELD_COUNT_OFFSET); - fieldStartOffset = readSmallUint(FIELD_START_OFFSET); - methodCount = readSmallUint(METHOD_COUNT_OFFSET); - methodStartOffset = readSmallUint(METHOD_START_OFFSET); - classCount = readSmallUint(CLASS_COUNT_OFFSET); - classStartOffset = readSmallUint(CLASS_START_OFFSET); - - stringCache = new String[stringCount]; - } - - private void verifyMagic() { - outer: for (byte[] magic: MAGIC_VALUES) { - for (int i=0; i= stringCount) { - throw new ExceptionWithContext("String index out of bounds: %d", stringIndex); - } - return stringStartOffset + stringIndex*STRING_ID_ITEM_SIZE; - } - - public int getTypeIdItemOffset(int typeIndex) { - if (typeIndex < 0 || typeIndex >= typeCount) { - throw new ExceptionWithContext("Type index out of bounds: %d", typeIndex); - } - return typeStartOffset + typeIndex*TYPE_ID_ITEM_SIZE; - } - - public int getFieldIdItemOffset(int fieldIndex) { - if (fieldIndex < 0 || fieldIndex >= fieldCount) { - throw new ExceptionWithContext("Field index out of bounds: %d", fieldIndex); - } - return fieldStartOffset + fieldIndex*FIELD_ID_ITEM_SIZE; - } - - public int getMethodIdItemOffset(int methodIndex) { - if (methodIndex < 0 || methodIndex >= methodCount) { - throw new ExceptionWithContext("Method index out of bounds: %d", methodIndex); - } - return methodStartOffset + methodIndex*METHOD_ID_ITEM_SIZE; - } - - public int getProtoIdItemOffset(int protoIndex) { - if (protoIndex < 0 || protoIndex >= protoCount) { - throw new ExceptionWithContext("Proto index out of bounds: %d", protoIndex); - } - return protoStartOffset + protoIndex*PROTO_ID_ITEM_SIZE; - } - - public int getClassDefItemOffset(int classIndex) { - if (classIndex < 0 || classIndex >= classCount) { - throw new ExceptionWithContext("Class index out of bounds: %d", classIndex); - } - return classStartOffset + classIndex*CLASS_DEF_ITEM_SIZE; - } - - public int getClassCount() { - return classCount; - } - - @Nonnull - public String getString(int stringIndex) { - String ret = stringCache[stringIndex]; - if (ret == null) { - int stringOffset = getStringIdItemOffset(stringIndex); - int stringDataOffset = readSmallUint(stringOffset); - DexReader reader = readerAt(stringDataOffset); - int utf16Length = reader.readSmallUleb128(); - ret = Utf8Utils.utf8BytesWithUtf16LengthToString(buf, reader.getOffset(), utf16Length); - stringCache[stringIndex] = ret; - } - return ret; - } - - @Nullable - public String getOptionalType(int typeIndex) { - if (typeIndex == -1) { - return null; - } - return getType(typeIndex); - } - - @Nullable - public String getOptionalString(int stringIndex) { - if (stringIndex == -1) { - return null; - } - return getString(stringIndex); - } - - @Nonnull - public String getType(int typeIndex) { - int typeOffset = getTypeIdItemOffset(typeIndex); - int stringIndex = readSmallUint(typeOffset); - return getString(stringIndex); - } - - @Override - @Nonnull - public DexReader readerAt(int offset) { - return new DexReader(this, offset); - } -} diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexReader.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexReader.java index 9ecd2825..d4bdac5f 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexReader.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexReader.java @@ -33,8 +33,8 @@ package org.jf.dexlib2.dexbacked; import javax.annotation.Nonnull; -public class DexReader extends BaseDexReader { - public DexReader(@Nonnull DexBuffer dexBuf, int offset) { - super(dexBuf, offset); +public class DexReader extends BaseDexReader { + public DexReader(@Nonnull DexBackedDexFile dexFile, int offset) { + super(dexFile, offset); } } \ No newline at end of file diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedArrayPayload.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedArrayPayload.java index 27e35882..24a49600 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedArrayPayload.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedArrayPayload.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.util.FixedSizeList; import org.jf.dexlib2.iface.instruction.formats.ArrayPayload; import org.jf.util.ExceptionWithContext; @@ -50,12 +50,12 @@ public class DexBackedArrayPayload extends DexBackedInstruction implements Array private static final int ELEMENT_COUNT_OFFSET = 4; private static final int ELEMENTS_OFFSET = 8; - public DexBackedArrayPayload(@Nonnull DexBuffer dexBuf, + public DexBackedArrayPayload(@Nonnull DexBackedDexFile dexFile, int instructionStart) { - super(dexBuf, OPCODE, instructionStart); + super(dexFile, OPCODE, instructionStart); - elementWidth = dexBuf.readUshort(instructionStart + ELEMENT_WIDTH_OFFSET); - elementCount = dexBuf.readSmallUint(instructionStart + ELEMENT_COUNT_OFFSET); + elementWidth = dexFile.readUshort(instructionStart + ELEMENT_WIDTH_OFFSET); + elementCount = dexFile.readSmallUint(instructionStart + ELEMENT_COUNT_OFFSET); } @Override public int getElementWidth() { return elementWidth; } @@ -75,7 +75,7 @@ public class DexBackedArrayPayload extends DexBackedInstruction implements Array @Nonnull @Override public Number readItem(int index) { - return dexBuf.readByte(elementsStart + index); + return dexFile.readByte(elementsStart + index); } }; case 2: @@ -83,7 +83,7 @@ public class DexBackedArrayPayload extends DexBackedInstruction implements Array @Nonnull @Override public Number readItem(int index) { - return dexBuf.readShort(elementsStart + index*2); + return dexFile.readShort(elementsStart + index*2); } }; case 4: @@ -91,7 +91,7 @@ public class DexBackedArrayPayload extends DexBackedInstruction implements Array @Nonnull @Override public Number readItem(int index) { - return dexBuf.readInt(elementsStart + index*4); + return dexFile.readInt(elementsStart + index*4); } }; case 8: @@ -99,7 +99,7 @@ public class DexBackedArrayPayload extends DexBackedInstruction implements Array @Nonnull @Override public Number readItem(int index) { - return dexBuf.readLong(elementsStart + index*8); + return dexFile.readLong(elementsStart + index*8); } }; default: diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction.java index 42d58716..53bcd23f 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.iface.instruction.Instruction; import org.jf.util.ExceptionWithContext; @@ -40,14 +40,14 @@ import org.jf.util.ExceptionWithContext; import javax.annotation.Nonnull; public abstract class DexBackedInstruction implements Instruction { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; @Nonnull public final Opcode opcode; public final int instructionStart; - public DexBackedInstruction(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; this.opcode = opcode; this.instructionStart = instructionStart; } @@ -71,65 +71,65 @@ public abstract class DexBackedInstruction implements Instruction { return instruction; } - private static DexBackedInstruction buildInstruction(@Nonnull DexBuffer dexBuf, Opcode opcode, + private static DexBackedInstruction buildInstruction(@Nonnull DexBackedDexFile dexFile, Opcode opcode, int instructionStartOffset) { switch (opcode.format) { case Format10t: - return new DexBackedInstruction10t(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction10t(dexFile, opcode, instructionStartOffset); case Format10x: - return new DexBackedInstruction10x(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction10x(dexFile, opcode, instructionStartOffset); case Format11n: - return new DexBackedInstruction11n(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction11n(dexFile, opcode, instructionStartOffset); case Format11x: - return new DexBackedInstruction11x(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction11x(dexFile, opcode, instructionStartOffset); case Format12x: - return new DexBackedInstruction12x(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction12x(dexFile, opcode, instructionStartOffset); case Format20t: - return new DexBackedInstruction20t(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction20t(dexFile, opcode, instructionStartOffset); case Format21c: - return new DexBackedInstruction21c(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction21c(dexFile, opcode, instructionStartOffset); case Format21ih: - return new DexBackedInstruction21ih(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction21ih(dexFile, opcode, instructionStartOffset); case Format21lh: - return new DexBackedInstruction21lh(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction21lh(dexFile, opcode, instructionStartOffset); case Format21s: - return new DexBackedInstruction21s(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction21s(dexFile, opcode, instructionStartOffset); case Format21t: - return new DexBackedInstruction21t(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction21t(dexFile, opcode, instructionStartOffset); case Format22b: - return new DexBackedInstruction22b(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction22b(dexFile, opcode, instructionStartOffset); case Format22c: - return new DexBackedInstruction22c(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction22c(dexFile, opcode, instructionStartOffset); case Format22s: - return new DexBackedInstruction22s(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction22s(dexFile, opcode, instructionStartOffset); case Format22t: - return new DexBackedInstruction22t(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction22t(dexFile, opcode, instructionStartOffset); case Format22x: - return new DexBackedInstruction22x(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction22x(dexFile, opcode, instructionStartOffset); case Format23x: - return new DexBackedInstruction23x(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction23x(dexFile, opcode, instructionStartOffset); case Format30t: - return new DexBackedInstruction30t(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction30t(dexFile, opcode, instructionStartOffset); case Format31c: - return new DexBackedInstruction31c(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction31c(dexFile, opcode, instructionStartOffset); case Format31i: - return new DexBackedInstruction31i(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction31i(dexFile, opcode, instructionStartOffset); case Format31t: - return new DexBackedInstruction31t(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction31t(dexFile, opcode, instructionStartOffset); case Format32x: - return new DexBackedInstruction32x(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction32x(dexFile, opcode, instructionStartOffset); case Format35c: - return new DexBackedInstruction35c(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction35c(dexFile, opcode, instructionStartOffset); case Format3rc: - return new DexBackedInstruction3rc(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction3rc(dexFile, opcode, instructionStartOffset); case Format51l: - return new DexBackedInstruction51l(dexBuf, opcode, instructionStartOffset); + return new DexBackedInstruction51l(dexFile, opcode, instructionStartOffset); case PackedSwitchPayload: - return new DexBackedPackedSwitchPayload(dexBuf, instructionStartOffset); + return new DexBackedPackedSwitchPayload(dexFile, instructionStartOffset); case SparseSwitchPayload: - return new DexBackedSparseSwitchPayload(dexBuf, instructionStartOffset); + return new DexBackedSparseSwitchPayload(dexFile, instructionStartOffset); case ArrayPayload: - return new DexBackedArrayPayload(dexBuf, instructionStartOffset); + return new DexBackedArrayPayload(dexFile, instructionStartOffset); //TODO: temporary, until we get all instructions implemented default: throw new ExceptionWithContext("Unexpected opcode format: %s", opcode.format.toString()); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10t.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10t.java index ed36f8b6..e0c120f4 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10t.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10t.java @@ -32,17 +32,17 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction10t; import javax.annotation.Nonnull; public class DexBackedInstruction10t extends DexBackedInstruction implements Instruction10t { - public DexBackedInstruction10t(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction10t(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getCodeOffset() { return dexBuf.readByte(instructionStart + 1); } + @Override public int getCodeOffset() { return dexFile.readByte(instructionStart + 1); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10x.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10x.java index ded5fe69..a19f8588 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10x.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction10x.java @@ -32,15 +32,15 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction10x; import javax.annotation.Nonnull; public class DexBackedInstruction10x extends DexBackedInstruction implements Instruction10x { - public DexBackedInstruction10x(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction10x(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11n.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11n.java index 5be8e1b5..61e6ae56 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11n.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11n.java @@ -32,27 +32,27 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction11n; import org.jf.util.NibbleUtils; import javax.annotation.Nonnull; public class DexBackedInstruction11n extends DexBackedInstruction implements Instruction11n { - public DexBackedInstruction11n(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction11n(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } @Override public int getRegisterA() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readByte(instructionStart + 1)); } @Override public int getNarrowLiteral() { - return NibbleUtils.extractHighSignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractHighSignedNibble(dexFile.readByte(instructionStart + 1)); } @Override public long getWideLiteral() { return getNarrowLiteral(); } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11x.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11x.java index 6ab00395..d701964b 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11x.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction11x.java @@ -32,17 +32,17 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction11x; import javax.annotation.Nonnull; public class DexBackedInstruction11x extends DexBackedInstruction implements Instruction11x { - public DexBackedInstruction11x(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction11x(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction12x.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction12x.java index c6bbcb28..03635587 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction12x.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction12x.java @@ -32,26 +32,26 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction12x; import org.jf.util.NibbleUtils; import javax.annotation.Nonnull; public class DexBackedInstruction12x extends DexBackedInstruction implements Instruction12x { - public DexBackedInstruction12x(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction12x(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } @Override public int getRegisterA() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readByte(instructionStart + 1)); } @Override public int getRegisterB() { - return NibbleUtils.extractHighUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractHighUnsignedNibble(dexFile.readByte(instructionStart + 1)); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction20t.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction20t.java index a32a3b31..d9cd728c 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction20t.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction20t.java @@ -32,17 +32,17 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction20t; import javax.annotation.Nonnull; public class DexBackedInstruction20t extends DexBackedInstruction implements Instruction20t { - public DexBackedInstruction20t(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction20t(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getCodeOffset() { return dexBuf.readShort(instructionStart + 2); } + @Override public int getCodeOffset() { return dexFile.readShort(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21c.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21c.java index efabf032..94b93abc 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21c.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21c.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.reference.DexBackedReference; import org.jf.dexlib2.iface.instruction.formats.Instruction21c; import org.jf.dexlib2.iface.reference.Reference; @@ -40,17 +40,17 @@ import org.jf.dexlib2.iface.reference.Reference; import javax.annotation.Nonnull; public class DexBackedInstruction21c extends DexBackedInstruction implements Instruction21c { - public DexBackedInstruction21c(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction21c(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } @Nonnull @Override public Reference getReference() { - return DexBackedReference.makeReference(dexBuf, opcode.referenceType, dexBuf.readUshort(instructionStart + 2)); + return DexBackedReference.makeReference(dexFile, opcode.referenceType, dexFile.readUshort(instructionStart + 2)); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21ih.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21ih.java index db815c1f..84a5e4a6 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21ih.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21ih.java @@ -32,20 +32,20 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction21ih; import javax.annotation.Nonnull; public class DexBackedInstruction21ih extends DexBackedInstruction implements Instruction21ih { - public DexBackedInstruction21ih(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction21ih(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } @Override public int getNarrowLiteral() { return getHatLiteral() << 16; } @Override public long getWideLiteral() { return getNarrowLiteral(); } - @Override public short getHatLiteral() { return (short)dexBuf.readShort(instructionStart + 2); } + @Override public short getHatLiteral() { return (short)dexFile.readShort(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21lh.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21lh.java index d8198600..c8043e22 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21lh.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21lh.java @@ -32,19 +32,19 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction21lh; import javax.annotation.Nonnull; public class DexBackedInstruction21lh extends DexBackedInstruction implements Instruction21lh { - public DexBackedInstruction21lh(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction21lh(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } @Override public long getWideLiteral() { return ((long)getHatLiteral()) << 48; } - @Override public short getHatLiteral() { return (short)dexBuf.readShort(instructionStart + 2); } + @Override public short getHatLiteral() { return (short)dexFile.readShort(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21s.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21s.java index c4ded704..2d7e493d 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21s.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21s.java @@ -32,19 +32,19 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction21s; import javax.annotation.Nonnull; public class DexBackedInstruction21s extends DexBackedInstruction implements Instruction21s { - public DexBackedInstruction21s(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction21s(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public int getNarrowLiteral() { return dexBuf.readShort(instructionStart + 2); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public int getNarrowLiteral() { return dexFile.readShort(instructionStart + 2); } @Override public long getWideLiteral() { return getNarrowLiteral(); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21t.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21t.java index 400859cb..d5b31ab0 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21t.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction21t.java @@ -32,18 +32,18 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction21t; import javax.annotation.Nonnull; public class DexBackedInstruction21t extends DexBackedInstruction implements Instruction21t { - public DexBackedInstruction21t(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction21t(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public int getCodeOffset() { return dexBuf.readShort(instructionStart + 2); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public int getCodeOffset() { return dexFile.readShort(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22b.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22b.java index a54ff1f3..1d4def85 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22b.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22b.java @@ -32,20 +32,20 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction22b; import javax.annotation.Nonnull; public class DexBackedInstruction22b extends DexBackedInstruction implements Instruction22b { - public DexBackedInstruction22b(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction22b(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public int getRegisterB() { return dexBuf.readUbyte(instructionStart + 2); } - @Override public int getNarrowLiteral() { return dexBuf.readByte(instructionStart + 3); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public int getRegisterB() { return dexFile.readUbyte(instructionStart + 2); } + @Override public int getNarrowLiteral() { return dexFile.readByte(instructionStart + 3); } @Override public long getWideLiteral() { return getNarrowLiteral(); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22c.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22c.java index 27d0d09e..6704cb84 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22c.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22c.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.reference.DexBackedReference; import org.jf.dexlib2.iface.instruction.formats.Instruction22c; import org.jf.dexlib2.iface.reference.Reference; @@ -41,25 +41,25 @@ import org.jf.util.NibbleUtils; import javax.annotation.Nonnull; public class DexBackedInstruction22c extends DexBackedInstruction implements Instruction22c { - public DexBackedInstruction22c(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction22c(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } @Override public int getRegisterA() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readByte(instructionStart + 1)); } @Override public int getRegisterB() { - return NibbleUtils.extractHighUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractHighUnsignedNibble(dexFile.readByte(instructionStart + 1)); } @Nonnull @Override public Reference getReference() { - return DexBackedReference.makeReference(dexBuf, opcode.referenceType, dexBuf.readUshort(instructionStart + 2)); + return DexBackedReference.makeReference(dexFile, opcode.referenceType, dexFile.readUshort(instructionStart + 2)); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22s.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22s.java index 01c3db16..7cc6b2ab 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22s.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22s.java @@ -32,29 +32,29 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction22s; import org.jf.util.NibbleUtils; import javax.annotation.Nonnull; public class DexBackedInstruction22s extends DexBackedInstruction implements Instruction22s { - public DexBackedInstruction22s(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction22s(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } @Override public int getRegisterA() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readByte(instructionStart + 1)); } @Override public int getRegisterB() { - return NibbleUtils.extractHighUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractHighUnsignedNibble(dexFile.readByte(instructionStart + 1)); } - @Override public int getNarrowLiteral() { return dexBuf.readShort(instructionStart + 2); } + @Override public int getNarrowLiteral() { return dexFile.readShort(instructionStart + 2); } @Override public long getWideLiteral() { return getNarrowLiteral(); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22t.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22t.java index 6cf1be85..0ac4a130 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22t.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22t.java @@ -32,28 +32,28 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction22t; import org.jf.util.NibbleUtils; import javax.annotation.Nonnull; public class DexBackedInstruction22t extends DexBackedInstruction implements Instruction22t { - public DexBackedInstruction22t(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction22t(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } @Override public int getRegisterA() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readByte(instructionStart + 1)); } @Override public int getRegisterB() { - return NibbleUtils.extractHighUnsignedNibble(dexBuf.readByte(instructionStart + 1)); + return NibbleUtils.extractHighUnsignedNibble(dexFile.readByte(instructionStart + 1)); } - @Override public int getCodeOffset() { return dexBuf.readShort(instructionStart + 2); } + @Override public int getCodeOffset() { return dexFile.readShort(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22x.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22x.java index 09d9eeaf..d31ab933 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22x.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction22x.java @@ -32,18 +32,18 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction22x; import javax.annotation.Nonnull; public class DexBackedInstruction22x extends DexBackedInstruction implements Instruction22x { - public DexBackedInstruction22x(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction22x(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public int getRegisterB() { return dexBuf.readUshort(instructionStart + 2); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public int getRegisterB() { return dexFile.readUshort(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction23x.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction23x.java index a60b9acc..66c92ace 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction23x.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction23x.java @@ -32,19 +32,19 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction23x; import javax.annotation.Nonnull; public class DexBackedInstruction23x extends DexBackedInstruction implements Instruction23x { - public DexBackedInstruction23x(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction23x(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public int getRegisterB() { return dexBuf.readUbyte(instructionStart + 2); } - @Override public int getRegisterC() { return dexBuf.readUbyte(instructionStart + 3); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public int getRegisterB() { return dexFile.readUbyte(instructionStart + 2); } + @Override public int getRegisterC() { return dexFile.readUbyte(instructionStart + 3); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction30t.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction30t.java index 2935f92b..ae4315b9 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction30t.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction30t.java @@ -32,17 +32,17 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction30t; import javax.annotation.Nonnull; public class DexBackedInstruction30t extends DexBackedInstruction implements Instruction30t { - public DexBackedInstruction30t(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction30t(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getCodeOffset() { return dexBuf.readInt(instructionStart + 2); } + @Override public int getCodeOffset() { return dexFile.readInt(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31c.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31c.java index 05dbc05c..6e596a21 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31c.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31c.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.reference.DexBackedReference; import org.jf.dexlib2.iface.instruction.formats.Instruction31c; import org.jf.dexlib2.iface.reference.Reference; @@ -40,18 +40,18 @@ import org.jf.dexlib2.iface.reference.Reference; import javax.annotation.Nonnull; public class DexBackedInstruction31c extends DexBackedInstruction implements Instruction31c { - public DexBackedInstruction31c(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction31c(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } @Nonnull @Override public Reference getReference() { - return DexBackedReference.makeReference(dexBuf, opcode.referenceType, - dexBuf.readSmallUint(instructionStart + 2)); + return DexBackedReference.makeReference(dexFile, opcode.referenceType, + dexFile.readSmallUint(instructionStart + 2)); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31i.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31i.java index 6db9df02..cffe3a04 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31i.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31i.java @@ -32,19 +32,19 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction31i; import javax.annotation.Nonnull; public class DexBackedInstruction31i extends DexBackedInstruction implements Instruction31i { - public DexBackedInstruction31i(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction31i(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public int getNarrowLiteral() { return dexBuf.readInt(instructionStart + 2); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public int getNarrowLiteral() { return dexFile.readInt(instructionStart + 2); } @Override public long getWideLiteral() { return getNarrowLiteral(); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31t.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31t.java index 1f1d2305..582bc6a1 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31t.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction31t.java @@ -32,18 +32,18 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction31t; import javax.annotation.Nonnull; public class DexBackedInstruction31t extends DexBackedInstruction implements Instruction31t { - public DexBackedInstruction31t(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction31t(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public int getCodeOffset() { return dexBuf.readInt(instructionStart + 2); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public int getCodeOffset() { return dexFile.readInt(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction32x.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction32x.java index 36c47010..0958881a 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction32x.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction32x.java @@ -32,18 +32,18 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction32x; import javax.annotation.Nonnull; public class DexBackedInstruction32x extends DexBackedInstruction implements Instruction32x { - public DexBackedInstruction32x(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction32x(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUshort(instructionStart + 2); } - @Override public int getRegisterB() { return dexBuf.readUshort(instructionStart + 4); } + @Override public int getRegisterA() { return dexFile.readUshort(instructionStart + 2); } + @Override public int getRegisterB() { return dexFile.readUshort(instructionStart + 4); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction35c.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction35c.java index b0c9f78d..a6ee413a 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction35c.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction35c.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.reference.DexBackedReference; import org.jf.dexlib2.iface.instruction.formats.Instruction35c; import org.jf.dexlib2.iface.reference.Reference; @@ -41,46 +41,46 @@ import org.jf.util.NibbleUtils; import javax.annotation.Nonnull; public class DexBackedInstruction35c extends DexBackedInstruction implements Instruction35c { - public DexBackedInstruction35c(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction35c(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } @Override public int getRegisterCount() { //TODO: make sure dalvik verifies that this is in the correct range - return NibbleUtils.extractHighUnsignedNibble(dexBuf.readUbyte(instructionStart + 1)); + return NibbleUtils.extractHighUnsignedNibble(dexFile.readUbyte(instructionStart + 1)); } @Override public int getRegisterC() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readUbyte(instructionStart + 4)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readUbyte(instructionStart + 4)); } @Override public int getRegisterD() { - return NibbleUtils.extractHighUnsignedNibble(dexBuf.readUbyte(instructionStart + 4)); + return NibbleUtils.extractHighUnsignedNibble(dexFile.readUbyte(instructionStart + 4)); } @Override public int getRegisterE() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readUbyte(instructionStart + 5)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readUbyte(instructionStart + 5)); } @Override public int getRegisterF() { - return NibbleUtils.extractHighUnsignedNibble(dexBuf.readUbyte(instructionStart + 5)); + return NibbleUtils.extractHighUnsignedNibble(dexFile.readUbyte(instructionStart + 5)); } @Override public int getRegisterG() { - return NibbleUtils.extractLowUnsignedNibble(dexBuf.readUbyte(instructionStart + 1)); + return NibbleUtils.extractLowUnsignedNibble(dexFile.readUbyte(instructionStart + 1)); } @Nonnull @Override public Reference getReference() { - return DexBackedReference.makeReference(dexBuf, opcode.referenceType, - dexBuf.readUshort(instructionStart + 2)); + return DexBackedReference.makeReference(dexFile, opcode.referenceType, + dexFile.readUshort(instructionStart + 2)); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction3rc.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction3rc.java index 4924b09f..d7076ee8 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction3rc.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction3rc.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.reference.DexBackedReference; import org.jf.dexlib2.iface.instruction.formats.Instruction3rc; import org.jf.dexlib2.iface.reference.Reference; @@ -40,25 +40,25 @@ import org.jf.dexlib2.iface.reference.Reference; import javax.annotation.Nonnull; public class DexBackedInstruction3rc extends DexBackedInstruction implements Instruction3rc { - public DexBackedInstruction3rc(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction3rc(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } @Override public int getRegisterCount() { - return dexBuf.readUbyte(instructionStart + 1); + return dexFile.readUbyte(instructionStart + 1); } @Override public int getStartRegister() { - return dexBuf.readUshort(instructionStart + 4); + return dexFile.readUshort(instructionStart + 4); } @Nonnull @Override public Reference getReference() { - return DexBackedReference.makeReference(dexBuf, opcode.referenceType, - dexBuf.readUshort(instructionStart + 2)); + return DexBackedReference.makeReference(dexFile, opcode.referenceType, + dexFile.readUshort(instructionStart + 2)); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction51l.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction51l.java index 83905bf3..627907d4 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction51l.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedInstruction51l.java @@ -32,18 +32,18 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.instruction.formats.Instruction51l; import javax.annotation.Nonnull; public class DexBackedInstruction51l extends DexBackedInstruction implements Instruction51l { - public DexBackedInstruction51l(@Nonnull DexBuffer dexBuf, + public DexBackedInstruction51l(@Nonnull DexBackedDexFile dexFile, @Nonnull Opcode opcode, int instructionStart) { - super(dexBuf, opcode, instructionStart); + super(dexFile, opcode, instructionStart); } - @Override public int getRegisterA() { return dexBuf.readUbyte(instructionStart + 1); } - @Override public long getWideLiteral() { return dexBuf.readLong(instructionStart + 2); } + @Override public int getRegisterA() { return dexFile.readUbyte(instructionStart + 1); } + @Override public long getWideLiteral() { return dexFile.readLong(instructionStart + 2); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedPackedSwitchPayload.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedPackedSwitchPayload.java index 2545ed0f..f65d7d9a 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedPackedSwitchPayload.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedPackedSwitchPayload.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.util.FixedSizeList; import org.jf.dexlib2.iface.instruction.SwitchElement; import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; @@ -47,17 +47,17 @@ public class DexBackedPackedSwitchPayload extends DexBackedInstruction implement private static final int FIRST_KEY_OFFSET = 4; private static final int TARGETS_OFFSET = 8; - public DexBackedPackedSwitchPayload(@Nonnull DexBuffer dexBuf, + public DexBackedPackedSwitchPayload(@Nonnull DexBackedDexFile dexFile, int instructionStart) { - super(dexBuf, Opcode.PACKED_SWITCH_PAYLOAD, instructionStart); + super(dexFile, Opcode.PACKED_SWITCH_PAYLOAD, instructionStart); - elementCount = dexBuf.readUshort(instructionStart + ELEMENT_COUNT_OFFSET); + elementCount = dexFile.readUshort(instructionStart + ELEMENT_COUNT_OFFSET); } @Nonnull @Override public List getSwitchElements() { - final int firstKey = dexBuf.readInt(instructionStart + FIRST_KEY_OFFSET); + final int firstKey = dexFile.readInt(instructionStart + FIRST_KEY_OFFSET); return new FixedSizeList() { @Nonnull @Override @@ -70,7 +70,7 @@ public class DexBackedPackedSwitchPayload extends DexBackedInstruction implement @Override public int getOffset() { - return dexBuf.readInt(instructionStart + TARGETS_OFFSET + index*4); + return dexFile.readInt(instructionStart + TARGETS_OFFSET + index*4); } }; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedSparseSwitchPayload.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedSparseSwitchPayload.java index f4e97c40..668852f0 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedSparseSwitchPayload.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/instruction/DexBackedSparseSwitchPayload.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.instruction; import org.jf.dexlib2.Opcode; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.util.FixedSizeList; import org.jf.dexlib2.iface.instruction.SwitchElement; import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; @@ -46,11 +46,11 @@ public class DexBackedSparseSwitchPayload extends DexBackedInstruction implement private static final int ELEMENT_COUNT_OFFSET = 2; private static final int KEYS_OFFSET = 4; - public DexBackedSparseSwitchPayload(@Nonnull DexBuffer dexBuf, + public DexBackedSparseSwitchPayload(@Nonnull DexBackedDexFile dexFile, int instructionStart) { - super(dexBuf, Opcode.SPARSE_SWITCH_PAYLOAD, instructionStart); + super(dexFile, Opcode.SPARSE_SWITCH_PAYLOAD, instructionStart); - elementCount = dexBuf.readUshort(instructionStart + ELEMENT_COUNT_OFFSET); + elementCount = dexFile.readUshort(instructionStart + ELEMENT_COUNT_OFFSET); } @Nonnull @@ -63,12 +63,12 @@ public class DexBackedSparseSwitchPayload extends DexBackedInstruction implement return new SwitchElement() { @Override public int getKey() { - return dexBuf.readInt(instructionStart + KEYS_OFFSET + index*4); + return dexFile.readInt(instructionStart + KEYS_OFFSET + index*4); } @Override public int getOffset() { - return dexBuf.readInt(instructionStart + KEYS_OFFSET + elementCount*4 + index*4); + return dexFile.readInt(instructionStart + KEYS_OFFSET + elementCount*4 + index*4); } }; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java index 3b70ba20..ce26b785 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java @@ -32,34 +32,34 @@ package org.jf.dexlib2.dexbacked.reference; import org.jf.dexlib2.base.reference.BaseFieldReference; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import javax.annotation.Nonnull; public class DexBackedFieldReference extends BaseFieldReference { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; public final int fieldIdItemOffset; - public DexBackedFieldReference(@Nonnull DexBuffer dexBuf, int fieldIndex) { - this.dexBuf = dexBuf; - this.fieldIdItemOffset = dexBuf.getFieldIdItemOffset(fieldIndex); + public DexBackedFieldReference(@Nonnull DexBackedDexFile dexFile, int fieldIndex) { + this.dexFile = dexFile; + this.fieldIdItemOffset = dexFile.getFieldIdItemOffset(fieldIndex); } @Nonnull @Override public String getDefiningClass() { - return dexBuf.getType(dexBuf.readUshort(fieldIdItemOffset + DexBuffer.FIELD_CLASS_IDX_OFFSET)); + return dexFile.getType(dexFile.readUshort(fieldIdItemOffset + DexBackedDexFile.Impl.FIELD_CLASS_IDX_OFFSET)); } @Nonnull @Override public String getName() { - return dexBuf.getString(dexBuf.readSmallUint(fieldIdItemOffset + DexBuffer.FIELD_NAME_IDX_OFFSET)); + return dexFile.getString(dexFile.readSmallUint(fieldIdItemOffset + DexBackedDexFile.Impl.FIELD_NAME_IDX_OFFSET)); } @Nonnull @Override public String getType() { - return dexBuf.getType(dexBuf.readUshort(fieldIdItemOffset + DexBuffer.FIELD_TYPE_IDX_OFFSET)); + return dexFile.getType(dexFile.readUshort(fieldIdItemOffset + DexBackedDexFile.Impl.FIELD_TYPE_IDX_OFFSET)); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java index db8c9c86..8ef11513 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java @@ -33,47 +33,50 @@ package org.jf.dexlib2.dexbacked.reference; import com.google.common.collect.ImmutableList; import org.jf.dexlib2.base.reference.BaseMethodReference; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.util.FixedSizeList; import javax.annotation.Nonnull; import java.util.List; public class DexBackedMethodReference extends BaseMethodReference { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; public final int methodIdItemOffset; private int protoIdItemOffset; - public DexBackedMethodReference(@Nonnull DexBuffer dexBuf, int methodIndex) { - this.dexBuf = dexBuf; - this.methodIdItemOffset = dexBuf.getMethodIdItemOffset(methodIndex); + public DexBackedMethodReference(@Nonnull DexBackedDexFile dexFile, int methodIndex) { + this.dexFile = dexFile; + this.methodIdItemOffset = dexFile.getMethodIdItemOffset(methodIndex); } @Nonnull @Override public String getDefiningClass() { - return dexBuf.getType(dexBuf.readUshort(methodIdItemOffset + DexBuffer.METHOD_CLASS_IDX_OFFSET)); + return dexFile.getType(dexFile.readUshort(methodIdItemOffset + DexBackedDexFile.Impl.METHOD_CLASS_IDX_OFFSET)); } @Nonnull @Override public String getName() { - return dexBuf.getString(dexBuf.readSmallUint(methodIdItemOffset + DexBuffer.METHOD_NAME_IDX_OFFSET)); + return dexFile.getString(dexFile.readSmallUint(methodIdItemOffset + + DexBackedDexFile.Impl.METHOD_NAME_IDX_OFFSET)); } @Nonnull @Override public List getParameterTypes() { int protoIdItemOffset = getProtoIdItemOffset(); - final int parametersOffset = dexBuf.readSmallUint(protoIdItemOffset + DexBuffer.PROTO_PARAM_LIST_OFF_OFFSET); + final int parametersOffset = dexFile.readSmallUint(protoIdItemOffset + + DexBackedDexFile.Impl.PROTO_PARAM_LIST_OFF_OFFSET); if (parametersOffset > 0) { - final int parameterCount = dexBuf.readSmallUint(parametersOffset + DexBuffer.TYPE_LIST_SIZE_OFFSET); - final int paramListStart = parametersOffset + DexBuffer.TYPE_LIST_LIST_OFFSET; + final int parameterCount = dexFile.readSmallUint(parametersOffset + + DexBackedDexFile.Impl.TYPE_LIST_SIZE_OFFSET); + final int paramListStart = parametersOffset + DexBackedDexFile.Impl.TYPE_LIST_LIST_OFFSET; return new FixedSizeList() { @Nonnull @Override public String readItem(final int index) { - return dexBuf.getType(dexBuf.readUshort(paramListStart + 2*index)); + return dexFile.getType(dexFile.readUshort(paramListStart + 2*index)); } @Override public int size() { return parameterCount; } }; @@ -85,13 +88,14 @@ public class DexBackedMethodReference extends BaseMethodReference { @Override public String getReturnType() { int protoIdItemOffset = getProtoIdItemOffset(); - return dexBuf.getType(dexBuf.readSmallUint(protoIdItemOffset + DexBuffer.PROTO_RETURN_TYPE_IDX_OFFSET)); + return dexFile.getType(dexFile.readSmallUint(protoIdItemOffset + + DexBackedDexFile.Impl.PROTO_RETURN_TYPE_IDX_OFFSET)); } private int getProtoIdItemOffset() { if (protoIdItemOffset == 0) { - protoIdItemOffset = dexBuf.getProtoIdItemOffset( - dexBuf.readUshort(methodIdItemOffset + DexBuffer.METHOD_PROTO_IDX_OFFSET)); + protoIdItemOffset = dexFile.getProtoIdItemOffset( + dexFile.readUshort(methodIdItemOffset + DexBackedDexFile.Impl.METHOD_PROTO_IDX_OFFSET)); } return protoIdItemOffset; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedReference.java index a8912903..b63c37c2 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedReference.java @@ -32,23 +32,23 @@ package org.jf.dexlib2.dexbacked.reference; import org.jf.dexlib2.ReferenceType; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.iface.reference.Reference; import org.jf.util.ExceptionWithContext; import javax.annotation.Nonnull; public abstract class DexBackedReference { - public static Reference makeReference(@Nonnull DexBuffer dexBuf, int referenceType, int referenceIndex) { + public static Reference makeReference(@Nonnull DexBackedDexFile dexFile, int referenceType, int referenceIndex) { switch (referenceType) { case ReferenceType.STRING: - return new DexBackedStringReference(dexBuf, referenceIndex); + return new DexBackedStringReference(dexFile, referenceIndex); case ReferenceType.TYPE: - return new DexBackedTypeReference(dexBuf, referenceIndex); + return new DexBackedTypeReference(dexFile, referenceIndex); case ReferenceType.METHOD: - return new DexBackedMethodReference(dexBuf, referenceIndex); + return new DexBackedMethodReference(dexFile, referenceIndex); case ReferenceType.FIELD: - return new DexBackedFieldReference(dexBuf, referenceIndex); + return new DexBackedFieldReference(dexFile, referenceIndex); default: throw new ExceptionWithContext("Invalid reference type: %d", referenceType); } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java index 55a43095..61d0c818 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java @@ -32,22 +32,22 @@ package org.jf.dexlib2.dexbacked.reference; import org.jf.dexlib2.base.reference.BaseStringReference; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import javax.annotation.Nonnull; public class DexBackedStringReference extends BaseStringReference { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; public final int stringIndex; - public DexBackedStringReference(@Nonnull DexBuffer dexBuf, + public DexBackedStringReference(@Nonnull DexBackedDexFile dexBuf, int stringIndex) { - this.dexBuf = dexBuf; + this.dexFile = dexBuf; this.stringIndex = stringIndex; } @Nonnull public String getString() { - return dexBuf.getString(stringIndex); + return dexFile.getString(stringIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java index a6463394..2fcff0a2 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java @@ -32,21 +32,21 @@ package org.jf.dexlib2.dexbacked.reference; import org.jf.dexlib2.base.reference.BaseTypeReference; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import javax.annotation.Nonnull; public class DexBackedTypeReference extends BaseTypeReference { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; public final int typeIndex; - public DexBackedTypeReference(@Nonnull DexBuffer dexBuf, + public DexBackedTypeReference(@Nonnull DexBackedDexFile dexFile, int typeIndex) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; this.typeIndex = typeIndex; } @Nonnull public String getType() { - return dexBuf.getType(typeIndex); + return dexFile.getType(typeIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/AnnotationsDirectory.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/AnnotationsDirectory.java index 21ee5c4f..dd13b06b 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/AnnotationsDirectory.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/AnnotationsDirectory.java @@ -34,7 +34,7 @@ package org.jf.dexlib2.dexbacked.util; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import org.jf.dexlib2.dexbacked.DexBackedAnnotation; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import javax.annotation.Nonnull; import java.util.List; @@ -56,12 +56,12 @@ public abstract class AnnotationsDirectory { @Nonnull public abstract AnnotationIterator getParameterAnnotationIterator(); @Nonnull - public static AnnotationsDirectory newOrEmpty(@Nonnull DexBuffer dexBuf, + public static AnnotationsDirectory newOrEmpty(@Nonnull DexBackedDexFile dexFile, int directoryAnnotationsOffset) { if (directoryAnnotationsOffset == 0) { return EMPTY; } - return new AnnotationsDirectoryImpl(dexBuf, directoryAnnotationsOffset); + return new AnnotationsDirectoryImpl(dexFile, directoryAnnotationsOffset); } @@ -76,16 +76,16 @@ public abstract class AnnotationsDirectory { } @Nonnull - public static Set getAnnotations(@Nonnull final DexBuffer dexBuf, + public static Set getAnnotations(@Nonnull final DexBackedDexFile dexFile, final int annotationSetOffset) { if (annotationSetOffset != 0) { - final int size = dexBuf.readSmallUint(annotationSetOffset); + final int size = dexFile.readSmallUint(annotationSetOffset); return new FixedSizeSet() { @Nonnull @Override public DexBackedAnnotation readItem(int index) { - int annotationOffset = dexBuf.readSmallUint(annotationSetOffset + 4 + (4*index)); - return new DexBackedAnnotation(dexBuf, annotationOffset); + int annotationOffset = dexFile.readSmallUint(annotationSetOffset + 4 + (4*index)); + return new DexBackedAnnotation(dexFile, annotationOffset); } @Override public int size() { return size; } @@ -96,17 +96,17 @@ public abstract class AnnotationsDirectory { } @Nonnull - public static List> getParameterAnnotations(@Nonnull final DexBuffer dexBuf, - final int annotationSetListOffset) { + public static List> getParameterAnnotations( + @Nonnull final DexBackedDexFile dexFile, final int annotationSetListOffset) { if (annotationSetListOffset > 0) { - final int size = dexBuf.readSmallUint(annotationSetListOffset); + final int size = dexFile.readSmallUint(annotationSetListOffset); return new FixedSizeList>() { @Nonnull @Override public Set readItem(int index) { - int annotationSetOffset = dexBuf.readSmallUint(annotationSetListOffset + 4 + index * 4); - return getAnnotations(dexBuf, annotationSetOffset); + int annotationSetOffset = dexFile.readSmallUint(annotationSetListOffset + 4 + index * 4); + return getAnnotations(dexFile, annotationSetOffset); } @Override public int size() { return size; } @@ -116,7 +116,7 @@ public abstract class AnnotationsDirectory { } private static class AnnotationsDirectoryImpl extends AnnotationsDirectory { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int directoryOffset; private static final int FIELD_COUNT_OFFSET = 4; @@ -129,27 +129,27 @@ public abstract class AnnotationsDirectory { /** The size of a method_annotation structure */ private static final int METHOD_ANNOTATION_SIZE = 8; - public AnnotationsDirectoryImpl(@Nonnull DexBuffer dexBuf, + public AnnotationsDirectoryImpl(@Nonnull DexBackedDexFile dexFile, int directoryOffset) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; this.directoryOffset = directoryOffset; } public int getFieldAnnotationCount() { - return dexBuf.readSmallUint(directoryOffset + FIELD_COUNT_OFFSET); + return dexFile.readSmallUint(directoryOffset + FIELD_COUNT_OFFSET); } public int getMethodAnnotationCount() { - return dexBuf.readSmallUint(directoryOffset + METHOD_COUNT_OFFSET); + return dexFile.readSmallUint(directoryOffset + METHOD_COUNT_OFFSET); } public int getParameterAnnotationCount() { - return dexBuf.readSmallUint(directoryOffset + PARAMETER_COUNT_OFFSET); + return dexFile.readSmallUint(directoryOffset + PARAMETER_COUNT_OFFSET); } @Nonnull public Set getClassAnnotations() { - return getAnnotations(dexBuf, dexBuf.readSmallUint(directoryOffset)); + return getAnnotations(dexFile, dexFile.readSmallUint(directoryOffset)); } @Nonnull @@ -196,24 +196,24 @@ public abstract class AnnotationsDirectory { public AnnotationIteratorImpl(int startOffset, int size) { this.startOffset = startOffset; this.size = size; - this.currentItemIndex = dexBuf.readSmallUint(startOffset); + this.currentItemIndex = dexFile.readSmallUint(startOffset); this.currentIndex = 0; } public int seekTo(int itemIndex) { while (currentItemIndex < itemIndex && (currentIndex+1) < size) { currentIndex++; - currentItemIndex = dexBuf.readSmallUint(startOffset + (currentIndex*8)); + currentItemIndex = dexFile.readSmallUint(startOffset + (currentIndex*8)); } if (currentItemIndex == itemIndex) { - return dexBuf.readSmallUint(startOffset + (currentIndex*8)+4); + return dexFile.readSmallUint(startOffset + (currentIndex*8)+4); } return 0; } public void reset() { - this.currentItemIndex = dexBuf.readSmallUint(startOffset); + this.currentItemIndex = dexFile.readSmallUint(startOffset); this.currentIndex = 0; } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java index 2d3919c7..d74addf6 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java @@ -36,7 +36,7 @@ import org.jf.dexlib2.AccessFlags; import org.jf.dexlib2.DebugItemType; import org.jf.dexlib2.dexbacked.DexBackedMethod; import org.jf.dexlib2.dexbacked.DexBackedMethodImplementation; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.iface.MethodParameter; import org.jf.dexlib2.iface.debug.DebugItem; @@ -59,12 +59,12 @@ public abstract class DebugInfo implements Iterable { */ @Nonnull public abstract Iterator getParameterNames(@Nullable DexReader reader); - public static DebugInfo newOrEmpty(@Nonnull DexBuffer dexBuf, int debugInfoOffset, + public static DebugInfo newOrEmpty(@Nonnull DexBackedDexFile dexFile, int debugInfoOffset, @Nonnull DexBackedMethodImplementation methodImpl) { if (debugInfoOffset == 0) { return EmptyDebugInfo.INSTANCE; } - return new DebugInfoImpl(dexBuf, debugInfoOffset, methodImpl); + return new DebugInfoImpl(dexFile, debugInfoOffset, methodImpl); } private static class EmptyDebugInfo extends DebugInfo { @@ -77,14 +77,14 @@ public abstract class DebugInfo implements Iterable { } private static class DebugInfoImpl extends DebugInfo { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int debugInfoOffset; @Nonnull private final DexBackedMethodImplementation methodImpl; - public DebugInfoImpl(@Nonnull DexBuffer dexBuf, + public DebugInfoImpl(@Nonnull DexBackedDexFile dexFile, int debugInfoOffset, @Nonnull DexBackedMethodImplementation methodImpl) { - this.dexBuf = dexBuf; + this.dexFile = dexFile; this.debugInfoOffset = debugInfoOffset; this.methodImpl = methodImpl; } @@ -98,7 +98,7 @@ public abstract class DebugInfo implements Iterable { @Nonnull @Override public Iterator iterator() { - DexReader reader = dexBuf.readerAt(debugInfoOffset); + DexReader reader = dexFile.readerAt(debugInfoOffset); // TODO: this unsigned value could legitimally be > MAX_INT final int lineNumberStart = reader.readSmallUleb128(); int registerCount = methodImpl.getRegisterCount(); @@ -151,7 +151,7 @@ public abstract class DebugInfo implements Iterable { } } - return new VariableSizeLookaheadIterator(dexBuf, reader.getOffset()) { + return new VariableSizeLookaheadIterator(dexFile, reader.getOffset()) { private int codeAddress = 0; private int lineNumber = lineNumberStart; @@ -175,8 +175,8 @@ public abstract class DebugInfo implements Iterable { } case DebugItemType.START_LOCAL: { int register = reader.readSmallUleb128(); - String name = dexBuf.getOptionalString(reader.readSmallUleb128() - 1); - String type = dexBuf.getOptionalType(reader.readSmallUleb128() - 1); + String name = dexFile.getOptionalString(reader.readSmallUleb128() - 1); + String type = dexFile.getOptionalType(reader.readSmallUleb128() - 1); ImmutableStartLocal startLocal = new ImmutableStartLocal(codeAddress, register, name, type, null); locals[register] = startLocal; @@ -184,9 +184,9 @@ public abstract class DebugInfo implements Iterable { } case DebugItemType.START_LOCAL_EXTENDED: { int register = reader.readSmallUleb128(); - String name = dexBuf.getOptionalString(reader.readSmallUleb128() - 1); - String type = dexBuf.getOptionalType(reader.readSmallUleb128() - 1); - String signature = dexBuf.getOptionalString(reader.readSmallUleb128() - 1); + String name = dexFile.getOptionalString(reader.readSmallUleb128() - 1); + String type = dexFile.getOptionalType(reader.readSmallUleb128() - 1); + String signature = dexFile.getOptionalString(reader.readSmallUleb128() - 1); ImmutableStartLocal startLocal = new ImmutableStartLocal(codeAddress, register, name, type, signature); locals[register] = startLocal; @@ -227,7 +227,7 @@ public abstract class DebugInfo implements Iterable { return new ImmutableEpilogueBegin(codeAddress); } case DebugItemType.SET_SOURCE_FILE: { - String sourceFile = dexBuf.getOptionalString(reader.readSmallUleb128() - 1); + String sourceFile = dexFile.getOptionalString(reader.readSmallUleb128() - 1); return new ImmutableSetSourceFile(codeAddress, sourceFile); } default: { @@ -246,14 +246,14 @@ public abstract class DebugInfo implements Iterable { @Override public VariableSizeIterator getParameterNames(@Nullable DexReader reader) { if (reader == null) { - reader = dexBuf.readerAt(debugInfoOffset); + reader = dexFile.readerAt(debugInfoOffset); reader.skipUleb128(); } //TODO: make sure dalvik doesn't allow more parameter names than we have parameters final int parameterNameCount = reader.readSmallUleb128(); return new VariableSizeIterator(reader, parameterNameCount) { @Override protected String readNextItem(@Nonnull DexReader reader, int index) { - return dexBuf.getOptionalString(reader.readSmallUleb128() - 1); + return dexFile.getOptionalString(reader.readSmallUleb128() - 1); } }; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/StaticInitialValueIterator.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/StaticInitialValueIterator.java index dff9b907..1c452ae3 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/StaticInitialValueIterator.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/StaticInitialValueIterator.java @@ -31,7 +31,7 @@ package org.jf.dexlib2.dexbacked.util; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.dexbacked.value.DexBackedEncodedValue; import org.jf.dexlib2.iface.value.EncodedValue; @@ -49,11 +49,11 @@ public abstract class StaticInitialValueIterator { public abstract void skipNext(); @Nonnull - public static StaticInitialValueIterator newOrEmpty(@Nonnull DexBuffer dexBuf, int offset) { + public static StaticInitialValueIterator newOrEmpty(@Nonnull DexBackedDexFile dexFile, int offset) { if (offset == 0) { return EMPTY; } - return new StaticInitialValueIteratorImpl(dexBuf, offset); + return new StaticInitialValueIteratorImpl(dexFile, offset); } private static class StaticInitialValueIteratorImpl extends StaticInitialValueIterator { @@ -61,8 +61,8 @@ public abstract class StaticInitialValueIterator { private final int size; private int index = 0; - public StaticInitialValueIteratorImpl(@Nonnull DexBuffer dexBuf, int offset) { - this.reader = dexBuf.readerAt(offset); + public StaticInitialValueIteratorImpl(@Nonnull DexBackedDexFile dexFile, int offset) { + this.reader = dexFile.readerAt(offset); this.size = reader.readSmallUleb128(); } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeCollection.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeCollection.java index 7d8c8ed8..a784917c 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeCollection.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeCollection.java @@ -31,19 +31,19 @@ package org.jf.dexlib2.dexbacked.util; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; import java.util.AbstractCollection; public abstract class VariableSizeCollection extends AbstractCollection { - @Nonnull private final DexBuffer dexBuf; + @Nonnull private final DexBackedDexFile dexFile; private final int offset; private final int size; - public VariableSizeCollection(@Nonnull DexBuffer dexBuf, int offset, int size) { - this.dexBuf = dexBuf; + public VariableSizeCollection(@Nonnull DexBackedDexFile dexFile, int offset, int size) { + this.dexFile = dexFile; this.offset = offset; this.size = size; } @@ -51,8 +51,9 @@ public abstract class VariableSizeCollection extends AbstractCollection { protected abstract T readNextItem(@Nonnull DexReader reader, int index); @Override + @Nonnull public VariableSizeIterator iterator() { - return new VariableSizeIterator(dexBuf, offset, size) { + return new VariableSizeIterator(dexFile, offset, size) { @Override protected T readNextItem(@Nonnull DexReader reader, int index) { return VariableSizeCollection.this.readNextItem(reader, index); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeIterator.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeIterator.java index 960d1e86..5048af73 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeIterator.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeIterator.java @@ -31,7 +31,7 @@ package org.jf.dexlib2.dexbacked.util; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; @@ -44,8 +44,8 @@ public abstract class VariableSizeIterator implements Iterator { private int index; - protected VariableSizeIterator(@Nonnull DexBuffer dexBuf, int offset, int size) { - this.reader = dexBuf.readerAt(offset); + protected VariableSizeIterator(@Nonnull DexBackedDexFile dexFile, int offset, int size) { + this.reader = dexFile.readerAt(offset); this.size = size; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeList.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeList.java index 07ec7698..ec219ad5 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeList.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeList.java @@ -31,19 +31,19 @@ package org.jf.dexlib2.dexbacked.util; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; import java.util.AbstractSequentialList; public abstract class VariableSizeList extends AbstractSequentialList { - @Nonnull private final DexBuffer dexBuf; + @Nonnull private final DexBackedDexFile dexFile; private final int offset; private final int size; - public VariableSizeList(@Nonnull DexBuffer dexBuf, int offset, int size) { - this.dexBuf = dexBuf; + public VariableSizeList(@Nonnull DexBackedDexFile dexFile, int offset, int size) { + this.dexFile = dexFile; this.offset = offset; this.size = size; } @@ -61,7 +61,7 @@ public abstract class VariableSizeList extends AbstractSequentialList { @Nonnull @Override public VariableSizeListIterator listIterator(int index) { - VariableSizeListIterator iterator = new VariableSizeListIterator(dexBuf, offset, size) { + VariableSizeListIterator iterator = new VariableSizeListIterator(dexFile, offset, size) { @Override protected T readNextItem(@Nonnull DexReader reader, int index) { return VariableSizeList.this.readNextItem(reader, index); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeListIterator.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeListIterator.java index 19d6a166..6c0e48dd 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeListIterator.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeListIterator.java @@ -31,7 +31,7 @@ package org.jf.dexlib2.dexbacked.util; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; @@ -45,8 +45,8 @@ public abstract class VariableSizeListIterator implements ListIterator { private int index; - protected VariableSizeListIterator(@Nonnull DexBuffer dexBuf, int offset, int size) { - this.reader = dexBuf.readerAt(offset); + protected VariableSizeListIterator(@Nonnull DexBackedDexFile dexFile, int offset, int size) { + this.reader = dexFile.readerAt(offset); this.startOffset = offset; this.size = size; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeLookaheadIterator.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeLookaheadIterator.java index 07f48522..d330094f 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeLookaheadIterator.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeLookaheadIterator.java @@ -31,7 +31,7 @@ package org.jf.dexlib2.dexbacked.util; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; @@ -44,8 +44,8 @@ public abstract class VariableSizeLookaheadIterator implements Iterator { private T cachedItem = null; - protected VariableSizeLookaheadIterator(@Nonnull DexBuffer dexBuf, int offset) { - this.reader = dexBuf.readerAt(offset); + protected VariableSizeLookaheadIterator(@Nonnull DexBackedDexFile dexFile, int offset) { + this.reader = dexFile.readerAt(offset); cachedItem = readNextItem(reader); } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeSet.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeSet.java index 50397908..9ea726a8 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeSet.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/VariableSizeSet.java @@ -31,19 +31,19 @@ package org.jf.dexlib2.dexbacked.util; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; import java.util.AbstractSet; public abstract class VariableSizeSet extends AbstractSet { - @Nonnull private final DexBuffer dexBuf; + @Nonnull private final DexBackedDexFile dexFile; private final int offset; private final int size; - public VariableSizeSet(@Nonnull DexBuffer dexBuf, int offset, int size) { - this.dexBuf = dexBuf; + public VariableSizeSet(@Nonnull DexBackedDexFile dexFile, int offset, int size) { + this.dexFile = dexFile; this.offset = offset; this.size = size; } @@ -51,8 +51,9 @@ public abstract class VariableSizeSet extends AbstractSet { protected abstract T readNextItem(@Nonnull DexReader reader, int index); @Override + @Nonnull public VariableSizeIterator iterator() { - return new VariableSizeIterator(dexBuf, offset, size) { + return new VariableSizeIterator(dexFile, offset, size) { @Override protected T readNextItem(@Nonnull DexReader reader, int index) { return VariableSizeSet.this.readNextItem(reader, index); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java index 7d41b35d..c6854c70 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java @@ -33,7 +33,7 @@ package org.jf.dexlib2.dexbacked.value; import org.jf.dexlib2.base.value.BaseAnnotationEncodedValue; import org.jf.dexlib2.dexbacked.DexBackedAnnotationElement; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.dexbacked.util.VariableSizeSet; import org.jf.dexlib2.iface.value.AnnotationEncodedValue; @@ -42,14 +42,14 @@ import javax.annotation.Nonnull; import java.util.Set; public class DexBackedAnnotationEncodedValue extends BaseAnnotationEncodedValue implements AnnotationEncodedValue { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; @Nonnull public final String type; private final int elementCount; private final int elementsOffset; public DexBackedAnnotationEncodedValue(@Nonnull DexReader reader) { - this.dexBuf = reader.dexBuf; - this.type = dexBuf.getType(reader.readSmallUleb128()); + this.dexFile = reader.dexBuf; + this.type = dexFile.getType(reader.readSmallUleb128()); this.elementCount = reader.readSmallUleb128(); this.elementsOffset = reader.getOffset(); skipElements(reader, elementCount); @@ -73,7 +73,7 @@ public class DexBackedAnnotationEncodedValue extends BaseAnnotationEncodedValue @Nonnull @Override public Set getElements() { - return new VariableSizeSet(dexBuf, elementsOffset, elementCount) { + return new VariableSizeSet(dexFile, elementsOffset, elementCount) { @Nonnull @Override protected DexBackedAnnotationElement readNextItem(@Nonnull DexReader dexReader, int index) { diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedArrayEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedArrayEncodedValue.java index c55272cd..2eff4514 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedArrayEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedArrayEncodedValue.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.value; import org.jf.dexlib2.base.value.BaseArrayEncodedValue; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.dexbacked.util.VariableSizeList; import org.jf.dexlib2.iface.value.ArrayEncodedValue; @@ -42,12 +42,12 @@ import javax.annotation.Nonnull; import java.util.List; public class DexBackedArrayEncodedValue extends BaseArrayEncodedValue implements ArrayEncodedValue { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int elementCount; private final int encodedArrayOffset; public DexBackedArrayEncodedValue(@Nonnull DexReader reader) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; this.elementCount = reader.readSmallUleb128(); this.encodedArrayOffset = reader.getOffset(); skipElementsFrom(reader, elementCount); @@ -67,7 +67,7 @@ public class DexBackedArrayEncodedValue extends BaseArrayEncodedValue implements @Nonnull @Override public List getValue() { - return new VariableSizeList(dexBuf, encodedArrayOffset, elementCount) { + return new VariableSizeList(dexFile, encodedArrayOffset, elementCount) { @Nonnull @Override protected EncodedValue readNextItem(@Nonnull DexReader dexReader, int index) { diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedEnumEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedEnumEncodedValue.java index 1793b6a2..c3c70cce 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedEnumEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedEnumEncodedValue.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.value; import org.jf.dexlib2.base.value.BaseEnumEncodedValue; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.dexbacked.reference.DexBackedFieldReference; import org.jf.dexlib2.iface.reference.FieldReference; @@ -40,15 +40,15 @@ import org.jf.dexlib2.iface.reference.FieldReference; import javax.annotation.Nonnull; public class DexBackedEnumEncodedValue extends BaseEnumEncodedValue { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int fieldIndex; public DexBackedEnumEncodedValue(@Nonnull DexReader reader, int valueArg) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; fieldIndex = reader.readSizedSmallUint(valueArg + 1); } @Override public FieldReference getValue() { - return new DexBackedFieldReference(dexBuf, fieldIndex); + return new DexBackedFieldReference(dexFile, fieldIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedFieldEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedFieldEncodedValue.java index 2f931954..c28d2a01 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedFieldEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedFieldEncodedValue.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.value; import org.jf.dexlib2.base.value.BaseFieldEncodedValue; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.dexbacked.reference.DexBackedFieldReference; import org.jf.dexlib2.iface.reference.FieldReference; @@ -40,15 +40,15 @@ import org.jf.dexlib2.iface.reference.FieldReference; import javax.annotation.Nonnull; public class DexBackedFieldEncodedValue extends BaseFieldEncodedValue { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int fieldIndex; public DexBackedFieldEncodedValue(@Nonnull DexReader reader, int valueArg) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; fieldIndex = reader.readSizedSmallUint(valueArg + 1); } @Override public FieldReference getValue() { - return new DexBackedFieldReference(dexBuf, fieldIndex); + return new DexBackedFieldReference(dexFile, fieldIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedMethodEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedMethodEncodedValue.java index b1c8e288..856ddf08 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedMethodEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedMethodEncodedValue.java @@ -32,7 +32,7 @@ package org.jf.dexlib2.dexbacked.value; import org.jf.dexlib2.base.value.BaseMethodEncodedValue; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import org.jf.dexlib2.dexbacked.reference.DexBackedMethodReference; import org.jf.dexlib2.iface.reference.MethodReference; @@ -40,15 +40,15 @@ import org.jf.dexlib2.iface.reference.MethodReference; import javax.annotation.Nonnull; public class DexBackedMethodEncodedValue extends BaseMethodEncodedValue { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int MethodIndex; public DexBackedMethodEncodedValue(@Nonnull DexReader reader, int valueArg) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; MethodIndex = reader.readSizedSmallUint(valueArg + 1); } @Override public MethodReference getValue() { - return new DexBackedMethodReference(dexBuf, MethodIndex); + return new DexBackedMethodReference(dexFile, MethodIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java index aa5801dc..3103c00d 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java @@ -32,21 +32,21 @@ package org.jf.dexlib2.dexbacked.value; import org.jf.dexlib2.base.value.BaseStringEncodedValue; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; public class DexBackedStringEncodedValue extends BaseStringEncodedValue { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int stringIndex; public DexBackedStringEncodedValue(@Nonnull DexReader reader, int valueArg) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; stringIndex = reader.readSizedSmallUint(valueArg + 1); } @Override public String getValue() { - return dexBuf.getString(stringIndex); + return dexFile.getString(stringIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java index 3134bb81..f5f39599 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java @@ -32,21 +32,21 @@ package org.jf.dexlib2.dexbacked.value; import org.jf.dexlib2.base.value.BaseTypeEncodedValue; -import org.jf.dexlib2.dexbacked.DexBuffer; +import org.jf.dexlib2.dexbacked.DexBackedDexFile; import org.jf.dexlib2.dexbacked.DexReader; import javax.annotation.Nonnull; public class DexBackedTypeEncodedValue extends BaseTypeEncodedValue { - @Nonnull public final DexBuffer dexBuf; + @Nonnull public final DexBackedDexFile dexFile; private final int typeIndex; public DexBackedTypeEncodedValue(@Nonnull DexReader reader, int valueArg) { - this.dexBuf = reader.dexBuf; + this.dexFile = reader.dexBuf; typeIndex = reader.readSizedSmallUint(valueArg + 1); } @Override public String getValue() { - return dexBuf.getType(typeIndex); + return dexFile.getType(typeIndex); } }