| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.dex; |
| |
| import com.android.dex.Code.CatchHandler; |
| import com.android.dex.Code.Try; |
| import com.android.dex.MethodHandle.MethodHandleType; |
| import com.android.dex.util.ByteInput; |
| import com.android.dex.util.ByteOutput; |
| import com.android.dex.util.FileUtils; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.UTFDataFormatException; |
| import java.nio.ByteBuffer; |
| import java.nio.ByteOrder; |
| import java.security.MessageDigest; |
| import java.security.NoSuchAlgorithmException; |
| import java.util.AbstractList; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.NoSuchElementException; |
| import java.util.RandomAccess; |
| import java.util.zip.Adler32; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipFile; |
| |
| /** |
| * The bytes of a dex file in memory for reading and writing. All int offsets |
| * are unsigned. |
| */ |
| public final class Dex { |
| private static final int CHECKSUM_OFFSET = 8; |
| private static final int CHECKSUM_SIZE = 4; |
| private static final int SIGNATURE_OFFSET = CHECKSUM_OFFSET + CHECKSUM_SIZE; |
| private static final int SIGNATURE_SIZE = 20; |
| // Provided as a convenience to avoid a memory allocation to benefit Dalvik. |
| // Note: libcore.util.EmptyArray cannot be accessed when this code isn't run on Dalvik. |
| static final short[] EMPTY_SHORT_ARRAY = new short[0]; |
| |
| private ByteBuffer data; |
| private final TableOfContents tableOfContents = new TableOfContents(); |
| private int nextSectionStart = 0; |
| private final StringTable strings = new StringTable(); |
| private final TypeIndexToDescriptorIndexTable typeIds = new TypeIndexToDescriptorIndexTable(); |
| private final TypeIndexToDescriptorTable typeNames = new TypeIndexToDescriptorTable(); |
| private final ProtoIdTable protoIds = new ProtoIdTable(); |
| private final FieldIdTable fieldIds = new FieldIdTable(); |
| private final MethodIdTable methodIds = new MethodIdTable(); |
| |
| /** |
| * Creates a new dex that reads from {@code data}. It is an error to modify |
| * {@code data} after using it to create a dex buffer. |
| */ |
| public Dex(byte[] data) throws IOException { |
| this(ByteBuffer.wrap(data)); |
| } |
| |
| private Dex(ByteBuffer data) throws IOException { |
| this.data = data; |
| this.data.order(ByteOrder.LITTLE_ENDIAN); |
| this.tableOfContents.readFrom(this); |
| } |
| |
| /** |
| * Creates a new empty dex of the specified size. |
| */ |
| public Dex(int byteCount) throws IOException { |
| this.data = ByteBuffer.wrap(new byte[byteCount]); |
| this.data.order(ByteOrder.LITTLE_ENDIAN); |
| } |
| |
| /** |
| * Creates a new dex buffer of the dex in {@code in}, and closes {@code in}. |
| */ |
| public Dex(InputStream in) throws IOException { |
| try { |
| loadFrom(in); |
| } finally { |
| in.close(); |
| } |
| } |
| |
| /** |
| * Creates a new dex buffer from the dex file {@code file}. |
| */ |
| public Dex(File file) throws IOException { |
| if (FileUtils.hasArchiveSuffix(file.getName())) { |
| ZipFile zipFile = new ZipFile(file); |
| ZipEntry entry = zipFile.getEntry(DexFormat.DEX_IN_JAR_NAME); |
| if (entry != null) { |
| try (InputStream inputStream = zipFile.getInputStream(entry)) { |
| loadFrom(inputStream); |
| } |
| zipFile.close(); |
| } else { |
| throw new DexException("Expected " + DexFormat.DEX_IN_JAR_NAME + " in " + file); |
| } |
| } else if (file.getName().endsWith(".dex")) { |
| try (InputStream inputStream = new FileInputStream(file)) { |
| loadFrom(inputStream); |
| } |
| } else { |
| throw new DexException("unknown output extension: " + file); |
| } |
| } |
| |
| /** |
| * It is the caller's responsibility to close {@code in}. |
| */ |
| private void loadFrom(InputStream in) throws IOException { |
| ByteArrayOutputStream bytesOut = new ByteArrayOutputStream(); |
| byte[] buffer = new byte[8192]; |
| |
| int count; |
| while ((count = in.read(buffer)) != -1) { |
| bytesOut.write(buffer, 0, count); |
| } |
| |
| this.data = ByteBuffer.wrap(bytesOut.toByteArray()); |
| this.data.order(ByteOrder.LITTLE_ENDIAN); |
| this.tableOfContents.readFrom(this); |
| } |
| |
| private static void checkBounds(int index, int length) { |
| if (index < 0 || index >= length) { |
| throw new IndexOutOfBoundsException("index:" + index + ", length=" + length); |
| } |
| } |
| |
| public void writeTo(OutputStream out) throws IOException { |
| byte[] buffer = new byte[8192]; |
| ByteBuffer data = this.data.duplicate(); // positioned ByteBuffers aren't thread safe |
| data.clear(); |
| while (data.hasRemaining()) { |
| int count = Math.min(buffer.length, data.remaining()); |
| data.get(buffer, 0, count); |
| out.write(buffer, 0, count); |
| } |
| } |
| |
| public void writeTo(File dexOut) throws IOException { |
| try (OutputStream out = new FileOutputStream(dexOut)) { |
| writeTo(out); |
| } |
| } |
| |
| public TableOfContents getTableOfContents() { |
| return tableOfContents; |
| } |
| |
| public Section open(int position) { |
| if (position < 0 || position >= data.capacity()) { |
| throw new IllegalArgumentException("position=" + position |
| + " length=" + data.capacity()); |
| } |
| ByteBuffer sectionData = data.duplicate(); |
| sectionData.order(ByteOrder.LITTLE_ENDIAN); // necessary? |
| sectionData.position(position); |
| sectionData.limit(data.capacity()); |
| return new Section("section", sectionData); |
| } |
| |
| public Section appendSection(int maxByteCount, String name) { |
| if ((maxByteCount & 3) != 0) { |
| throw new IllegalStateException("Not four byte aligned!"); |
| } |
| int limit = nextSectionStart + maxByteCount; |
| ByteBuffer sectionData = data.duplicate(); |
| sectionData.order(ByteOrder.LITTLE_ENDIAN); // necessary? |
| sectionData.position(nextSectionStart); |
| sectionData.limit(limit); |
| Section result = new Section(name, sectionData); |
| nextSectionStart = limit; |
| return result; |
| } |
| |
| public int getLength() { |
| return data.capacity(); |
| } |
| |
| public int getNextSectionStart() { |
| return nextSectionStart; |
| } |
| |
| /** |
| * Returns a copy of the the bytes of this dex. |
| */ |
| public byte[] getBytes() { |
| ByteBuffer data = this.data.duplicate(); // positioned ByteBuffers aren't thread safe |
| byte[] result = new byte[data.capacity()]; |
| data.position(0); |
| data.get(result); |
| return result; |
| } |
| |
| public List<String> strings() { |
| return strings; |
| } |
| |
| public List<Integer> typeIds() { |
| return typeIds; |
| } |
| |
| public List<String> typeNames() { |
| return typeNames; |
| } |
| |
| public List<ProtoId> protoIds() { |
| return protoIds; |
| } |
| |
| public List<FieldId> fieldIds() { |
| return fieldIds; |
| } |
| |
| public List<MethodId> methodIds() { |
| return methodIds; |
| } |
| |
| public Iterable<ClassDef> classDefs() { |
| return new ClassDefIterable(); |
| } |
| |
| public TypeList readTypeList(int offset) { |
| if (offset == 0) { |
| return TypeList.EMPTY; |
| } |
| return open(offset).readTypeList(); |
| } |
| |
| public ClassData readClassData(ClassDef classDef) { |
| int offset = classDef.getClassDataOffset(); |
| if (offset == 0) { |
| throw new IllegalArgumentException("offset == 0"); |
| } |
| return open(offset).readClassData(); |
| } |
| |
| public Code readCode(ClassData.Method method) { |
| int offset = method.getCodeOffset(); |
| if (offset == 0) { |
| throw new IllegalArgumentException("offset == 0"); |
| } |
| return open(offset).readCode(); |
| } |
| |
| /** |
| * Returns the signature of all but the first 32 bytes of this dex. The |
| * first 32 bytes of dex files are not specified to be included in the |
| * signature. |
| */ |
| public byte[] computeSignature() throws IOException { |
| MessageDigest digest; |
| try { |
| digest = MessageDigest.getInstance("SHA-1"); |
| } catch (NoSuchAlgorithmException e) { |
| throw new AssertionError(); |
| } |
| byte[] buffer = new byte[8192]; |
| ByteBuffer data = this.data.duplicate(); // positioned ByteBuffers aren't thread safe |
| data.limit(data.capacity()); |
| data.position(SIGNATURE_OFFSET + SIGNATURE_SIZE); |
| while (data.hasRemaining()) { |
| int count = Math.min(buffer.length, data.remaining()); |
| data.get(buffer, 0, count); |
| digest.update(buffer, 0, count); |
| } |
| return digest.digest(); |
| } |
| |
| /** |
| * Returns the checksum of all but the first 12 bytes of {@code dex}. |
| */ |
| public int computeChecksum() throws IOException { |
| Adler32 adler32 = new Adler32(); |
| byte[] buffer = new byte[8192]; |
| ByteBuffer data = this.data.duplicate(); // positioned ByteBuffers aren't thread safe |
| data.limit(data.capacity()); |
| data.position(CHECKSUM_OFFSET + CHECKSUM_SIZE); |
| while (data.hasRemaining()) { |
| int count = Math.min(buffer.length, data.remaining()); |
| data.get(buffer, 0, count); |
| adler32.update(buffer, 0, count); |
| } |
| return (int) adler32.getValue(); |
| } |
| |
| /** |
| * Generates the signature and checksum of the dex file {@code out} and |
| * writes them to the file. |
| */ |
| public void writeHashes() throws IOException { |
| open(SIGNATURE_OFFSET).write(computeSignature()); |
| open(CHECKSUM_OFFSET).writeInt(computeChecksum()); |
| } |
| |
| /** |
| * Look up a descriptor index from a type index. Cheaper than: |
| * {@code open(tableOfContents.typeIds.off + (index * SizeOf.TYPE_ID_ITEM)).readInt();} |
| */ |
| public int descriptorIndexFromTypeIndex(int typeIndex) { |
| checkBounds(typeIndex, tableOfContents.typeIds.size); |
| int position = tableOfContents.typeIds.off + (SizeOf.TYPE_ID_ITEM * typeIndex); |
| return data.getInt(position); |
| } |
| |
| |
| public final class Section implements ByteInput, ByteOutput { |
| private final String name; |
| private final ByteBuffer data; |
| private final int initialPosition; |
| |
| private Section(String name, ByteBuffer data) { |
| this.name = name; |
| this.data = data; |
| this.initialPosition = data.position(); |
| } |
| |
| public int getPosition() { |
| return data.position(); |
| } |
| |
| public int readInt() { |
| return data.getInt(); |
| } |
| |
| public short readShort() { |
| return data.getShort(); |
| } |
| |
| public int readUnsignedShort() { |
| return readShort() & 0xffff; |
| } |
| |
| @Override |
| public byte readByte() { |
| return data.get(); |
| } |
| |
| public byte[] readByteArray(int length) { |
| byte[] result = new byte[length]; |
| data.get(result); |
| return result; |
| } |
| |
| public short[] readShortArray(int length) { |
| if (length == 0) { |
| return EMPTY_SHORT_ARRAY; |
| } |
| short[] result = new short[length]; |
| for (int i = 0; i < length; i++) { |
| result[i] = readShort(); |
| } |
| return result; |
| } |
| |
| public int readUleb128() { |
| return Leb128.readUnsignedLeb128(this); |
| } |
| |
| public int readUleb128p1() { |
| return Leb128.readUnsignedLeb128(this) - 1; |
| } |
| |
| public int readSleb128() { |
| return Leb128.readSignedLeb128(this); |
| } |
| |
| public void writeUleb128p1(int i) { |
| writeUleb128(i + 1); |
| } |
| |
| public TypeList readTypeList() { |
| int size = readInt(); |
| short[] types = readShortArray(size); |
| alignToFourBytes(); |
| return new TypeList(Dex.this, types); |
| } |
| |
| public String readString() { |
| int offset = readInt(); |
| int savedPosition = data.position(); |
| int savedLimit = data.limit(); |
| data.position(offset); |
| data.limit(data.capacity()); |
| try { |
| int expectedLength = readUleb128(); |
| String result = Mutf8.decode(this, new char[expectedLength]); |
| if (result.length() != expectedLength) { |
| throw new DexException("Declared length " + expectedLength |
| + " doesn't match decoded length of " + result.length()); |
| } |
| return result; |
| } catch (UTFDataFormatException e) { |
| throw new DexException(e); |
| } finally { |
| data.position(savedPosition); |
| data.limit(savedLimit); |
| } |
| } |
| |
| public FieldId readFieldId() { |
| int declaringClassIndex = readUnsignedShort(); |
| int typeIndex = readUnsignedShort(); |
| int nameIndex = readInt(); |
| return new FieldId(Dex.this, declaringClassIndex, typeIndex, nameIndex); |
| } |
| |
| public MethodId readMethodId() { |
| int declaringClassIndex = readUnsignedShort(); |
| int protoIndex = readUnsignedShort(); |
| int nameIndex = readInt(); |
| return new MethodId(Dex.this, declaringClassIndex, protoIndex, nameIndex); |
| } |
| |
| public ProtoId readProtoId() { |
| int shortyIndex = readInt(); |
| int returnTypeIndex = readInt(); |
| int parametersOffset = readInt(); |
| return new ProtoId(Dex.this, shortyIndex, returnTypeIndex, parametersOffset); |
| } |
| |
| public CallSiteId readCallSiteId() { |
| int offset = readInt(); |
| return new CallSiteId(Dex.this, offset); |
| } |
| |
| public MethodHandle readMethodHandle() { |
| MethodHandleType methodHandleType = MethodHandleType.fromValue(readUnsignedShort()); |
| int unused1 = readUnsignedShort(); |
| int fieldOrMethodId = readUnsignedShort(); |
| int unused2 = readUnsignedShort(); |
| return new MethodHandle(Dex.this, methodHandleType, unused1, fieldOrMethodId, unused2); |
| } |
| |
| public ClassDef readClassDef() { |
| int offset = getPosition(); |
| int type = readInt(); |
| int accessFlags = readInt(); |
| int supertype = readInt(); |
| int interfacesOffset = readInt(); |
| int sourceFileIndex = readInt(); |
| int annotationsOffset = readInt(); |
| int classDataOffset = readInt(); |
| int staticValuesOffset = readInt(); |
| return new ClassDef(Dex.this, offset, type, accessFlags, supertype, |
| interfacesOffset, sourceFileIndex, annotationsOffset, classDataOffset, |
| staticValuesOffset); |
| } |
| |
| private Code readCode() { |
| int registersSize = readUnsignedShort(); |
| int insSize = readUnsignedShort(); |
| int outsSize = readUnsignedShort(); |
| int triesSize = readUnsignedShort(); |
| int debugInfoOffset = readInt(); |
| int instructionsSize = readInt(); |
| short[] instructions = readShortArray(instructionsSize); |
| Try[] tries; |
| CatchHandler[] catchHandlers; |
| if (triesSize > 0) { |
| if (instructions.length % 2 == 1) { |
| readShort(); // padding |
| } |
| |
| /* |
| * We can't read the tries until we've read the catch handlers. |
| * Unfortunately they're in the opposite order in the dex file |
| * so we need to read them out-of-order. |
| */ |
| Section triesSection = open(data.position()); |
| skip(triesSize * SizeOf.TRY_ITEM); |
| catchHandlers = readCatchHandlers(); |
| tries = triesSection.readTries(triesSize, catchHandlers); |
| } else { |
| tries = new Try[0]; |
| catchHandlers = new CatchHandler[0]; |
| } |
| return new Code(registersSize, insSize, outsSize, debugInfoOffset, instructions, |
| tries, catchHandlers); |
| } |
| |
| private CatchHandler[] readCatchHandlers() { |
| int baseOffset = data.position(); |
| int catchHandlersSize = readUleb128(); |
| CatchHandler[] result = new CatchHandler[catchHandlersSize]; |
| for (int i = 0; i < catchHandlersSize; i++) { |
| int offset = data.position() - baseOffset; |
| result[i] = readCatchHandler(offset); |
| } |
| return result; |
| } |
| |
| private Try[] readTries(int triesSize, CatchHandler[] catchHandlers) { |
| Try[] result = new Try[triesSize]; |
| for (int i = 0; i < triesSize; i++) { |
| int startAddress = readInt(); |
| int instructionCount = readUnsignedShort(); |
| int handlerOffset = readUnsignedShort(); |
| int catchHandlerIndex = findCatchHandlerIndex(catchHandlers, handlerOffset); |
| result[i] = new Try(startAddress, instructionCount, catchHandlerIndex); |
| } |
| return result; |
| } |
| |
| private int findCatchHandlerIndex(CatchHandler[] catchHandlers, int offset) { |
| for (int i = 0; i < catchHandlers.length; i++) { |
| CatchHandler catchHandler = catchHandlers[i]; |
| if (catchHandler.getOffset() == offset) { |
| return i; |
| } |
| } |
| throw new IllegalArgumentException(); |
| } |
| |
| private CatchHandler readCatchHandler(int offset) { |
| int size = readSleb128(); |
| int handlersCount = Math.abs(size); |
| int[] typeIndexes = new int[handlersCount]; |
| int[] addresses = new int[handlersCount]; |
| for (int i = 0; i < handlersCount; i++) { |
| typeIndexes[i] = readUleb128(); |
| addresses[i] = readUleb128(); |
| } |
| int catchAllAddress = size <= 0 ? readUleb128() : -1; |
| return new CatchHandler(typeIndexes, addresses, catchAllAddress, offset); |
| } |
| |
| private ClassData readClassData() { |
| int staticFieldsSize = readUleb128(); |
| int instanceFieldsSize = readUleb128(); |
| int directMethodsSize = readUleb128(); |
| int virtualMethodsSize = readUleb128(); |
| ClassData.Field[] staticFields = readFields(staticFieldsSize); |
| ClassData.Field[] instanceFields = readFields(instanceFieldsSize); |
| ClassData.Method[] directMethods = readMethods(directMethodsSize); |
| ClassData.Method[] virtualMethods = readMethods(virtualMethodsSize); |
| return new ClassData(staticFields, instanceFields, directMethods, virtualMethods); |
| } |
| |
| private ClassData.Field[] readFields(int count) { |
| ClassData.Field[] result = new ClassData.Field[count]; |
| int fieldIndex = 0; |
| for (int i = 0; i < count; i++) { |
| fieldIndex += readUleb128(); // field index diff |
| int accessFlags = readUleb128(); |
| result[i] = new ClassData.Field(fieldIndex, accessFlags); |
| } |
| return result; |
| } |
| |
| private ClassData.Method[] readMethods(int count) { |
| ClassData.Method[] result = new ClassData.Method[count]; |
| int methodIndex = 0; |
| for (int i = 0; i < count; i++) { |
| methodIndex += readUleb128(); // method index diff |
| int accessFlags = readUleb128(); |
| int codeOff = readUleb128(); |
| result[i] = new ClassData.Method(methodIndex, accessFlags, codeOff); |
| } |
| return result; |
| } |
| |
| /** |
| * Returns a byte array containing the bytes from {@code start} to this |
| * section's current position. |
| */ |
| private byte[] getBytesFrom(int start) { |
| int end = data.position(); |
| byte[] result = new byte[end - start]; |
| data.position(start); |
| data.get(result); |
| return result; |
| } |
| |
| public Annotation readAnnotation() { |
| byte visibility = readByte(); |
| int start = data.position(); |
| new EncodedValueReader(this, EncodedValueReader.ENCODED_ANNOTATION).skipValue(); |
| return new Annotation(Dex.this, visibility, new EncodedValue(getBytesFrom(start))); |
| } |
| |
| public EncodedValue readEncodedArray() { |
| int start = data.position(); |
| new EncodedValueReader(this, EncodedValueReader.ENCODED_ARRAY).skipValue(); |
| return new EncodedValue(getBytesFrom(start)); |
| } |
| |
| public void skip(int count) { |
| if (count < 0) { |
| throw new IllegalArgumentException(); |
| } |
| data.position(data.position() + count); |
| } |
| |
| /** |
| * Skips bytes until the position is aligned to a multiple of 4. |
| */ |
| public void alignToFourBytes() { |
| data.position((data.position() + 3) & ~3); |
| } |
| |
| /** |
| * Writes 0x00 until the position is aligned to a multiple of 4. |
| */ |
| public void alignToFourBytesWithZeroFill() { |
| while ((data.position() & 3) != 0) { |
| data.put((byte) 0); |
| } |
| } |
| |
| public void assertFourByteAligned() { |
| if ((data.position() & 3) != 0) { |
| throw new IllegalStateException("Not four byte aligned!"); |
| } |
| } |
| |
| public void write(byte[] bytes) { |
| this.data.put(bytes); |
| } |
| |
| @Override |
| public void writeByte(int b) { |
| data.put((byte) b); |
| } |
| |
| public void writeShort(short i) { |
| data.putShort(i); |
| } |
| |
| public void writeUnsignedShort(int i) { |
| short s = (short) i; |
| if (i != (s & 0xffff)) { |
| throw new IllegalArgumentException("Expected an unsigned short: " + i); |
| } |
| writeShort(s); |
| } |
| |
| public void write(short[] shorts) { |
| for (short s : shorts) { |
| writeShort(s); |
| } |
| } |
| |
| public void writeInt(int i) { |
| data.putInt(i); |
| } |
| |
| public void writeUleb128(int i) { |
| try { |
| Leb128.writeUnsignedLeb128(this, i); |
| } catch (ArrayIndexOutOfBoundsException e) { |
| throw new DexException("Section limit " + data.limit() + " exceeded by " + name); |
| } |
| } |
| |
| public void writeSleb128(int i) { |
| try { |
| Leb128.writeSignedLeb128(this, i); |
| } catch (ArrayIndexOutOfBoundsException e) { |
| throw new DexException("Section limit " + data.limit() + " exceeded by " + name); |
| } |
| } |
| |
| public void writeStringData(String value) { |
| try { |
| int length = value.length(); |
| writeUleb128(length); |
| write(Mutf8.encode(value)); |
| writeByte(0); |
| } catch (UTFDataFormatException e) { |
| throw new AssertionError(); |
| } |
| } |
| |
| public void writeTypeList(TypeList typeList) { |
| short[] types = typeList.getTypes(); |
| writeInt(types.length); |
| for (short type : types) { |
| writeShort(type); |
| } |
| alignToFourBytesWithZeroFill(); |
| } |
| |
| /** |
| * Returns the number of bytes used by this section. |
| */ |
| public int used() { |
| return data.position() - initialPosition; |
| } |
| } |
| |
| private final class StringTable extends AbstractList<String> implements RandomAccess { |
| @Override |
| public String get(int index) { |
| checkBounds(index, tableOfContents.stringIds.size); |
| return open(tableOfContents.stringIds.off + (index * SizeOf.STRING_ID_ITEM)) |
| .readString(); |
| } |
| @Override |
| public int size() { |
| return tableOfContents.stringIds.size; |
| } |
| } |
| |
| private final class TypeIndexToDescriptorIndexTable extends AbstractList<Integer> |
| implements RandomAccess { |
| @Override |
| public Integer get(int index) { |
| return descriptorIndexFromTypeIndex(index); |
| } |
| @Override |
| public int size() { |
| return tableOfContents.typeIds.size; |
| } |
| } |
| |
| private final class TypeIndexToDescriptorTable extends AbstractList<String> |
| implements RandomAccess { |
| @Override |
| public String get(int index) { |
| return strings.get(descriptorIndexFromTypeIndex(index)); |
| } |
| @Override |
| public int size() { |
| return tableOfContents.typeIds.size; |
| } |
| } |
| |
| private final class ProtoIdTable extends AbstractList<ProtoId> implements RandomAccess { |
| @Override |
| public ProtoId get(int index) { |
| checkBounds(index, tableOfContents.protoIds.size); |
| return open(tableOfContents.protoIds.off + (SizeOf.PROTO_ID_ITEM * index)) |
| .readProtoId(); |
| } |
| @Override |
| public int size() { |
| return tableOfContents.protoIds.size; |
| } |
| } |
| |
| private final class FieldIdTable extends AbstractList<FieldId> implements RandomAccess { |
| @Override |
| public FieldId get(int index) { |
| checkBounds(index, tableOfContents.fieldIds.size); |
| return open(tableOfContents.fieldIds.off + (SizeOf.MEMBER_ID_ITEM * index)) |
| .readFieldId(); |
| } |
| @Override |
| public int size() { |
| return tableOfContents.fieldIds.size; |
| } |
| } |
| |
| private final class MethodIdTable extends AbstractList<MethodId> implements RandomAccess { |
| @Override |
| public MethodId get(int index) { |
| checkBounds(index, tableOfContents.methodIds.size); |
| return open(tableOfContents.methodIds.off + (SizeOf.MEMBER_ID_ITEM * index)) |
| .readMethodId(); |
| } |
| @Override |
| public int size() { |
| return tableOfContents.methodIds.size; |
| } |
| } |
| |
| private final class ClassDefIterator implements Iterator<ClassDef> { |
| private final Dex.Section in = open(tableOfContents.classDefs.off); |
| private int count = 0; |
| |
| @Override |
| public boolean hasNext() { |
| return count < tableOfContents.classDefs.size; |
| } |
| @Override |
| public ClassDef next() { |
| if (!hasNext()) { |
| throw new NoSuchElementException(); |
| } |
| count++; |
| return in.readClassDef(); |
| } |
| @Override |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| private final class ClassDefIterable implements Iterable<ClassDef> { |
| @Override |
| public Iterator<ClassDef> iterator() { |
| return !tableOfContents.classDefs.exists() |
| ? Collections.<ClassDef>emptySet().iterator() |
| : new ClassDefIterator(); |
| } |
| } |
| } |
