code
stringlengths 1
2.01M
| repo_name
stringlengths 3
62
| path
stringlengths 1
267
| language
stringclasses 231
values | license
stringclasses 13
values | size
int64 1
2.01M
|
|---|---|---|---|---|---|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Code;
public interface ThreeRegisterInstruction extends TwoRegisterInstruction {
int getRegisterC();
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Code/ThreeRegisterInstruction.java
|
Java
|
asf20
| 1,632
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Code;
public interface MultiOffsetInstruction {
public int[] getTargets();
public void updateTarget(int targetIndex, int targetAddressOffset);
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Code/MultiOffsetInstruction.java
|
Java
|
asf20
| 1,678
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.ExceptionWithContext;
import org.jf.dexlib.Util.Input;
public class IndexedSection<T extends Item> extends Section<T> {
/**
* Create a new indexed section
* @param dexFile The <code>DexFile</code> that this section belongs to
* @param itemType The itemType that this section will hold
*/
public IndexedSection(DexFile dexFile, ItemType itemType) {
super(dexFile, itemType);
}
/** {@inheritDoc} */
protected void readItems(Input in, ReadContext readContext) {
for (int i = 0; i < items.size(); i++) {
T item = (T)ItemFactory.makeItem(ItemType, DexFile);
items.set(i, item);
item.readFrom(in, i, readContext);
}
}
/**
* Gets the item at the specified index in this section, or null if the index is -1
* @param index the index of the item to get
* @return the item at the specified index in this section, or null if the index is -1
*/
public T getOptionalItemByIndex(int index) {
if (index == -1) {
return null;
}
return getItemByIndex(index);
}
/**
* Gets the item at the specified index in this section
* @param index the index of the item to get
* @return the item at the specified index in this section
*/
public T getItemByIndex(int index) {
try {
//if index is out of bounds, just let it throw an exception
return items.get(index);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error occured while retrieving the " + this.ItemType.TypeName +
" item at index " + index);
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/IndexedSection.java
|
Java
|
asf20
| 3,243
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import java.util.TreeMap;
/**
* Enumeration of all the top-level item types.
*/
public enum ItemType {
TYPE_HEADER_ITEM( 0x0000, 17, 4, "header_item"),
TYPE_STRING_ID_ITEM( 0x0001, 0, 4, "string_id_item"),
TYPE_TYPE_ID_ITEM( 0x0002, 1, 4, "type_id_item"),
TYPE_PROTO_ID_ITEM( 0x0003, 2, 4, "proto_id_item"),
TYPE_FIELD_ID_ITEM( 0x0004, 3, 4, "field_id_item"),
TYPE_METHOD_ID_ITEM( 0x0005, 4, 4, "method_id_item"),
TYPE_CLASS_DEF_ITEM( 0x0006, 5, 4, "class_def_item"),
TYPE_MAP_LIST( 0x1000, 16, 4, "map_list"),
TYPE_TYPE_LIST( 0x1001, 6, 4, "type_list"),
TYPE_ANNOTATION_SET_REF_LIST( 0x1002, 7, 4, "annotation_set_ref_list"),
TYPE_ANNOTATION_SET_ITEM( 0x1003, 8, 4, "annotation_set_item"),
TYPE_CLASS_DATA_ITEM( 0x2000, 9, 1, "class_data_item"),
TYPE_CODE_ITEM( 0x2001, 10, 4, "code_item"),
TYPE_STRING_DATA_ITEM( 0x2002, 11, 1, "string_data_item"),
TYPE_DEBUG_INFO_ITEM( 0x2003, 12, 1, "debug_info_item"),
TYPE_ANNOTATION_ITEM( 0x2004, 13, 1, "annotation_item"),
TYPE_ENCODED_ARRAY_ITEM( 0x2005, 14, 1, "encoded_array_item"),
TYPE_ANNOTATIONS_DIRECTORY_ITEM(0x2006, 15, 4, "annotations_directory_item");
/** A map to facilitate looking up an <code>ItemType</code> by ordinal */
private final static TreeMap<Integer, ItemType> itemTypeIntegerMap;
/** builds the <code>itemTypeIntegerMap</code> object */
static {
itemTypeIntegerMap = new TreeMap<Integer, ItemType>();
for (ItemType itemType: ItemType.values()) {
itemTypeIntegerMap.put(itemType.MapValue, itemType);
}
}
/**
* value when represented in a MapItem
*/
public final int MapValue;
/**
* name of the type
*/
public final String TypeName;
/**
* index for this item's section
*/
public final int SectionIndex;
/**
* the alignment for this item type
*/
public final int ItemAlignment;
/**
* Constructs an instance.
*
* @param mapValue value when represented in a MapItem
* @param sectionIndex index for this item's section
* @param itemAlignment the byte alignment required by this item
* @param typeName non-null; name of the type
*/
private ItemType(int mapValue, int sectionIndex, int itemAlignment, String typeName) {
this.MapValue = mapValue;
this.SectionIndex = sectionIndex;
this.ItemAlignment = itemAlignment;
this.TypeName = typeName;
}
/**
* Converts an int value to the corresponding ItemType enum value,
* or null if the value isn't a valid ItemType value
*
* @param itemType the int value to convert to an ItemType
* @return the ItemType enum value corresponding to itemType, or null
* if not a valid ItemType value
*/
public static ItemType fromInt(int itemType) {
return itemTypeIntegerMap.get(itemType);
}
/**
* Returns true if this is an indexed item, or false if its an offsetted item
* @return true if this is an indexed item, or false if its an offsetted item
*/
public boolean isIndexedItem() {
return MapValue <= 0x1000;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/ItemType.java
|
Java
|
asf20
| 4,912
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
/**
* This item represents a map_list item from the dex specification. It contains a
* SectionInfo instance for every section in the DexFile, with the number of items
* in and offset of that section.
*/
public class MapItem extends Item<MapItem> {
/**
* This item is read in immediately after the HeaderItem, and the section info contained
* by this item is added to the ReadContext object, which is used when reading in the other
* sections in the dex file.
*
* This item should be placed last. It depends on the fact that the other sections
* in the file have been placed.
*/
/**
* Create a new uninitialized <code>MapItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected MapItem(final DexFile dexFile) {
super(dexFile);
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
Section[] sections = dexFile.getOrderedSections();
//the list returned by getOrderedSections doesn't contain the header
//or map section, so add 2 to the length
return offset + 4 + (sections.length + 2) * 12;
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
int size = in.readInt();
for (int i=0; i<size; i++) {
ItemType itemType = ItemType.fromInt(in.readShort());
//unused
in.readShort();
int sectionSize = in.readInt();
int sectionOffset = in.readInt();
readContext.addSection(itemType, sectionSize, sectionOffset);
}
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
assert getOffset() > 0;
Section[] sections = dexFile.getOrderedSections();
out.annotate("map_size: 0x" + Integer.toHexString(sections.length + 2) + " (" +
Integer.toString(sections.length + 2) + ")");
out.writeInt(sections.length + 2);
int index = 0;
out.annotate(0, "[" + index++ + "]");
out.indent();
writeSectionInfo(out, ItemType.TYPE_HEADER_ITEM, 1, 0);
out.deindent();
for (Section section: dexFile.getOrderedSections()) {
out.annotate(0, "[" + index++ + "]");
out.indent();
writeSectionInfo(out, section.ItemType, section.getItems().size(), section.getOffset());
out.deindent();
}
out.annotate(0, "[" + index++ + "]");
out.indent();
writeSectionInfo(out, ItemType.TYPE_MAP_LIST, 1, dexFile.MapItem.getOffset());
out.deindent();
}
private void writeSectionInfo(AnnotatedOutput out, ItemType itemType, int sectionSize, int sectionOffset) {
if (out.annotates()) {
out.annotate(2, "item_type: " + itemType);
out.annotate(2, "unused");
out.annotate(4, "section_size: 0x" + Integer.toHexString(sectionSize) + " (" + sectionSize + ")");
out.annotate(4, "section_off: 0x" + Integer.toHexString(sectionOffset));
}
out.writeShort(itemType.MapValue);
out.writeShort(0);
out.writeInt(sectionSize);
out.writeInt(sectionOffset);
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_MAP_LIST;
}
/** {@inheritDoc} */
public int compareTo(MapItem o) {
return 0;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "map_item";
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/MapItem.java
|
Java
|
asf20
| 5,118
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import java.util.List;
public class AnnotationSetRefList extends Item<AnnotationSetRefList> {
private int hashCode = 0;
private AnnotationSetItem[] annotationSets;
/**
* Creates a new uninitialized <code>AnnotationSetRefList</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected AnnotationSetRefList(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>AnnotationSetRefList</code> for the given annotation sets
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param annotationSets The annotationSets for this <code>AnnotationSetRefList</code>
*/
private AnnotationSetRefList(DexFile dexFile, AnnotationSetItem[] annotationSets) {
super(dexFile);
this.annotationSets = annotationSets;
}
/**
* Returns an <code>AnnotationSetRefList</code> for the given annotation sets, and that has been interned into the
* given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param annotationSets The annotation sets for this <code>AnnotationSetRefList</code>
* @return an <code>AnnotationSetItem</code> for the given annotations
*/
public static AnnotationSetRefList internAnnotationSetRefList(DexFile dexFile,
List<AnnotationSetItem> annotationSets) {
AnnotationSetItem[] annotationSetsArray = new AnnotationSetItem[annotationSets.size()];
annotationSets.toArray(annotationSetsArray);
AnnotationSetRefList annotationSetRefList = new AnnotationSetRefList(dexFile, annotationSetsArray);
return dexFile.AnnotationSetRefListsSection.intern(annotationSetRefList);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
annotationSets = new AnnotationSetItem[in.readInt()];
for (int i=0; i<annotationSets.length; i++) {
annotationSets[i] = (AnnotationSetItem)readContext.getOptionalOffsettedItemByOffset(
ItemType.TYPE_ANNOTATION_SET_ITEM, in.readInt());
}
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 4 + annotationSets.length * 4;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(4, "size: 0x" + Integer.toHexString(annotationSets.length) + " (" + annotationSets.length +
")");
for (AnnotationSetItem annotationSetItem: annotationSets) {
out.annotate(4, "annotation_set_off: 0x" + Integer.toHexString(annotationSetItem.getOffset()));
}
}
out.writeInt(annotationSets.length);
for (AnnotationSetItem annotationSetItem: annotationSets) {
out.writeInt(annotationSetItem.getOffset());
}
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_ANNOTATION_SET_REF_LIST;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "annotation_set_item @0x" + Integer.toHexString(getOffset());
}
/** {@inheritDoc} */
public int compareTo(AnnotationSetRefList o) {
int comp = annotationSets.length - o.annotationSets.length;
if (comp != 0) {
return comp;
}
for (int i=0; i<annotationSets.length; i++) {
comp = annotationSets[i].compareTo(o.annotationSets[i]);
if (comp != 0) {
return comp;
}
}
return comp;
}
/**
* @return An array of the <code>AnnotationSetItem</code> objects that make up this
* <code>AnnotationSetRefList</code>
*/
public AnnotationSetItem[] getAnnotationSets() {
return annotationSets;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = 0;
for (AnnotationSetItem annotationSetItem: annotationSets) {
hashCode = hashCode * 31 + annotationSetItem.hashCode();
}
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
AnnotationSetRefList other = (AnnotationSetRefList)o;
return (this.compareTo(other) == 0);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/AnnotationSetRefList.java
|
Java
|
asf20
| 6,374
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.Leb128Utils;
import org.jf.dexlib.Util.Utf8Utils;
public class StringDataItem extends Item<StringDataItem> {
private int hashCode = 0;
private String stringValue;
/**
* Creates a new uninitialized <code>StringDataItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected StringDataItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>StringDataItem</code> for the given string
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param stringValue The string value that this item represents
*/
private StringDataItem(DexFile dexFile, String stringValue) {
super(dexFile);
this.stringValue = stringValue;
}
/**
* Returns a <code>StringDataItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param value The string value that this item represents
* @return a <code>StringDataItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static StringDataItem internStringDataItem(DexFile dexFile, String value) {
StringDataItem StringDataItem = new StringDataItem(dexFile, value);
return dexFile.StringDataSection.intern(StringDataItem);
}
/**
* Looks up the <code>StringDataItem</code> from the given <code>DexFile</code> for the given
* string value
* @param dexFile the <code>Dexfile</code> to find the string value in
* @param value The string value to look up
* @return a <code>StringDataItem</code> from the given <code>DexFile</code> for the given
* string value, or null if it doesn't exist
**/
public static StringDataItem lookupStringDataItem(DexFile dexFile, String value) {
StringDataItem StringDataItem = new StringDataItem(dexFile, value);
return dexFile.StringDataSection.getInternedItem(StringDataItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
in.readUnsignedLeb128(); //string length
stringValue = in.realNullTerminatedUtf8String();
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + Leb128Utils.unsignedLeb128Size(stringValue.length()) +
Utf8Utils.stringToUtf8Bytes(stringValue).length + 1;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
byte[] encodedValue = Utf8Utils.stringToUtf8Bytes(stringValue);
if (out.annotates()) {
out.annotate("string_size: 0x" + Integer.toHexString(stringValue.length()) + " (" + stringValue.length() +
")");
out.writeUnsignedLeb128(stringValue.length());
out.annotate(encodedValue.length + 1, "string_data: \"" + Utf8Utils.escapeString(stringValue) + "\"");
} else {
out.writeUnsignedLeb128(stringValue.length());
}
out.write(encodedValue);
out.writeByte(0);
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_STRING_DATA_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "string_data_item: \"" + Utf8Utils.escapeString(getStringValue()) + "\"";
}
/** {@inheritDoc} */
public int compareTo(StringDataItem o) {
return getStringValue().compareTo(o.getStringValue());
}
/**
* Get the string value of this item as a <code>String</code>
* @return the string value of this item as a String
*/
public String getStringValue() {
return stringValue;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = getStringValue().hashCode();
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
//This assumes that the referenced items have been interned in both objects.
//This is a valid assumption because all outside code must use the static
//"getInterned..." style methods to make new items, and any item created
//internally is guaranteed to be interned
StringDataItem other = (StringDataItem)o;
return getStringValue().equals(other.getStringValue());
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/StringDataItem.java
|
Java
|
asf20
| 6,454
|
/*
* Copyright 2012, 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.dexlib;
/**
* Describes an object that can be converted to a different type
*/
public interface Convertible<T> {
T convert();
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Convertible.java
|
Java
|
asf20
| 1,714
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
class ItemFactory {
protected static Item makeItem(ItemType itemType, DexFile dexFile) {
switch (itemType) {
case TYPE_STRING_ID_ITEM:
return new StringIdItem(dexFile);
case TYPE_TYPE_ID_ITEM:
return new TypeIdItem(dexFile);
case TYPE_PROTO_ID_ITEM:
return new ProtoIdItem(dexFile);
case TYPE_FIELD_ID_ITEM:
return new FieldIdItem(dexFile);
case TYPE_METHOD_ID_ITEM:
return new MethodIdItem(dexFile);
case TYPE_CLASS_DEF_ITEM:
return new ClassDefItem(dexFile);
case TYPE_TYPE_LIST:
return new TypeListItem(dexFile);
case TYPE_ANNOTATION_SET_REF_LIST:
return new AnnotationSetRefList(dexFile);
case TYPE_ANNOTATION_SET_ITEM:
return new AnnotationSetItem(dexFile);
case TYPE_CLASS_DATA_ITEM:
return new ClassDataItem(dexFile);
case TYPE_CODE_ITEM:
return new CodeItem(dexFile);
case TYPE_STRING_DATA_ITEM:
return new StringDataItem(dexFile);
case TYPE_DEBUG_INFO_ITEM:
return new DebugInfoItem(dexFile);
case TYPE_ANNOTATION_ITEM:
return new AnnotationItem(dexFile);
case TYPE_ENCODED_ARRAY_ITEM:
return new EncodedArrayItem(dexFile);
case TYPE_ANNOTATIONS_DIRECTORY_ITEM:
return new AnnotationDirectoryItem(dexFile);
default:
assert false;
}
return null;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/ItemFactory.java
|
Java
|
asf20
| 3,192
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AlignmentUtils;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
public abstract class Section<T extends Item> {
/**
* A list of the items that this section contains.
* If the section has been placed, this list should be in the order that the items
* will written to the dex file
*/
protected final ArrayList<T> items;
/**
* A HashMap of the items in this section. This is used when interning items, to determine
* if this section already has an item equivalent to the one that is being interned.
* Both the key and the value should be the same object
*/
protected HashMap<T,T> uniqueItems = null;
/**
* The offset of this section within the <code>DexFile</code>
*/
protected int offset = 0;
/**
* The type of item that this section holds
*/
public final ItemType ItemType;
/**
* The <code>DexFile</code> that this section belongs to
*/
public final DexFile DexFile;
/**
* Create a new section
* @param dexFile The <code>DexFile</code> that this section belongs to
* @param itemType The itemType that this section will hold
*/
protected Section(DexFile dexFile, ItemType itemType) {
this.DexFile = dexFile;
items = new ArrayList<T>();
this.ItemType = itemType;
}
/**
* Finalize the location of all items, and place them starting at the given offset
* @param offset The offset where this section should be placed
* @return the offset of the byte immediate after the last item in this section
*/
protected int placeAt(int offset) {
if (items.size() > 0) {
offset = AlignmentUtils.alignOffset(offset, ItemType.ItemAlignment);
assert !DexFile.getInplace() || offset == this.offset;
this.offset = offset;
for (int i=0; i < items.size(); i++) {
T item = items.get(i);
assert item != null;
offset = AlignmentUtils.alignOffset(offset, ItemType.ItemAlignment);
offset = item.placeAt(offset, i);
}
} else {
this.offset = 0;
}
return offset;
}
/**
* Write the items to the given <code>AnnotatedOutput</code>
* @param out the <code>AnnotatedOutput</code> object to write to
*/
protected void writeTo(AnnotatedOutput out) {
out.annotate(0, " ");
out.annotate(0, "-----------------------------");
out.annotate(0, this.ItemType.TypeName + " section");
out.annotate(0, "-----------------------------");
out.annotate(0, " ");
for (Item item: items) {
assert item!=null;
out.alignTo(ItemType.ItemAlignment);
item.writeTo(out);
out.annotate(0, " ");
}
}
/**
* Read the specified number of items from the given <code>Input</code> object
* @param size The number of items to read
* @param in The <code>Input</code> object to read from
* @param readContext a <code>ReadContext</code> object to hold information that is
* only needed while reading in a file
*/
protected void readFrom(int size, Input in, ReadContext readContext) {
//readItems() expects that the list will already be the correct size, so add null items
//until we reach the specified size
items.ensureCapacity(size);
for (int i = items.size(); i < size; i++) {
items.add(null);
}
in.alignTo(ItemType.ItemAlignment);
offset = in.getCursor();
//call the subclass's method that actually reads in the items
readItems(in, readContext);
}
/**
* This method in the concrete item subclass should read in all the items from the given <code>Input</code>
* object, using any pre-created items as applicable (i.e. items that were created prior to reading in the
* section, by other items requesting items from this section that they reference by index/offset)
* @param in the <code>Input</code>
* @param readContext a <code>ReadContext</code> object to hold information that is
* only needed while reading in a file
*/
protected abstract void readItems(Input in, ReadContext readContext);
/**
* Gets the offset where the first item in this section is placed
* @return the ofset where the first item in this section is placed
*/
public int getOffset() {
return offset;
}
/**
* Gets a the items contained in this section as a read-only list
* @return A read-only <code>List</code> object containing the items in this section
*/
public List<T> getItems() {
return Collections.unmodifiableList(items);
}
/**
* This method checks if an item that is equivalent to the given item has already been added. If found,
* it returns that item. If not found, it adds the given item to this section and returns it.
* @param item the item to intern
* @return An item from this section that is equivalent to the given item. It may or may not be the same
* as the item passed to this method.
*/
protected T intern(T item) {
if (item == null) {
return null;
}
T internedItem = getInternedItem(item);
if (internedItem == null) {
uniqueItems.put(item, item);
items.add(item);
return item;
}
return internedItem;
}
/**
* Returns the interned item that is equivalent to the given item, or null
* @param item the item to check
* @return the interned item that is equivalent to the given item, or null
*/
protected T getInternedItem(T item) {
if (uniqueItems == null) {
buildInternedItemMap();
}
return uniqueItems.get(item);
}
/**
* Builds the interned item map from the items that are in this section
*/
private void buildInternedItemMap() {
uniqueItems = new HashMap<T,T>();
for (T item: items) {
assert item != null;
uniqueItems.put(item, item);
}
}
/**
* Sorts the items in the section
*/
protected void sortSection() {
Collections.sort(items);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Section.java
|
Java
|
asf20
| 8,010
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public class FieldIdItem extends Item<FieldIdItem> implements Convertible<FieldIdItem> {
private int hashCode = 0;
private TypeIdItem classType;
private TypeIdItem fieldType;
private StringIdItem fieldName;
/**
* Creates a new uninitialized <code>FieldIdItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected FieldIdItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>FieldIdItem</code> for the given class, type and name
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType the class that the field is a member of
* @param fieldType the type of the field
* @param fieldName the name of the field
*/
private FieldIdItem(DexFile dexFile, TypeIdItem classType, TypeIdItem fieldType, StringIdItem fieldName) {
this(dexFile);
assert classType.dexFile == dexFile;
assert fieldType.dexFile == dexFile;
assert fieldName.dexFile == dexFile;
this.classType = classType;
this.fieldType = fieldType;
this.fieldName = fieldName;
}
/**
* Returns a <code>FieldIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType the class that the field is a member of
* @param fieldType the type of the field
* @param fieldName the name of the field
* @return a <code>FieldIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static FieldIdItem internFieldIdItem(DexFile dexFile, TypeIdItem classType, TypeIdItem fieldType,
StringIdItem fieldName) {
FieldIdItem fieldIdItem = new FieldIdItem(dexFile, classType, fieldType, fieldName);
return dexFile.FieldIdsSection.intern(fieldIdItem);
}
/**
* Looks up a <code>FieldIdItem</code> from the given <code>DexFile</code> for the given
* values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType the class that the field is a member of
* @param fieldType the type of the field
* @param fieldName the name of the field
* @return a <code>FieldIdItem</code> from the given <code>DexFile</code> for the given
* values, or null if it doesn't exist
*/
public static FieldIdItem lookupFieldIdItem(DexFile dexFile, TypeIdItem classType, TypeIdItem fieldType,
StringIdItem fieldName) {
FieldIdItem fieldIdItem = new FieldIdItem(dexFile, classType, fieldType, fieldName);
return dexFile.FieldIdsSection.getInternedItem(fieldIdItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
classType = dexFile.TypeIdsSection.getItemByIndex(in.readShort());
fieldType = dexFile.TypeIdsSection.getItemByIndex(in.readShort());
fieldName = dexFile.StringIdsSection.getItemByIndex(in.readInt());
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 8;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(2, "class_type: " + classType.getTypeDescriptor());
out.annotate(2, "field_type: " + fieldType.getTypeDescriptor());
out.annotate(4, "field_name: " + fieldName.getStringValue());
}
int classIndex = classType.getIndex();
if (classIndex > 0xffff) {
throw new RuntimeException(String.format("Error writing field_id_item for %s. The type index of " +
"defining class %s is too large", getFieldString(), classType.getTypeDescriptor()));
}
out.writeShort(classIndex);
int typeIndex = fieldType.getIndex();
if (typeIndex > 0xffff) {
throw new RuntimeException(String.format("Error writing field_id_item for %s. The type index of field " +
"type %s is too large", getFieldString(), fieldType.getTypeDescriptor()));
}
out.writeShort(typeIndex);
out.writeInt(fieldName.getIndex());
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_FIELD_ID_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return getFieldString();
}
/** {@inheritDoc} */
public int compareTo(FieldIdItem o) {
int result = classType.compareTo(o.classType);
if (result != 0) {
return result;
}
result = fieldName.compareTo(o.fieldName);
if (result != 0) {
return result;
}
return fieldType.compareTo(o.fieldType);
}
/**
* @return the class that this field is a member of
*/
public TypeIdItem getContainingClass() {
return classType;
}
/**
* @return the type of this field
*/
public TypeIdItem getFieldType() {
return fieldType;
}
/**
* @return the field name
*/
public StringIdItem getFieldName() {
return fieldName;
}
String cachedFieldString = null;
/**
* @return a string formatted like LclassName;->fieldName:fieldType
*/
public String getFieldString() {
if (cachedFieldString == null) {
String typeDescriptor = classType.getTypeDescriptor();
String fieldName = this.fieldName.getStringValue();
String fieldType = this.fieldType.getTypeDescriptor();
StringBuffer sb = new StringBuffer(typeDescriptor.length() + fieldName.length() + fieldType.length() + 3);
sb.append(typeDescriptor);
sb.append("->");
sb.append(fieldName);
sb.append(":");
sb.append(fieldType);
cachedFieldString = sb.toString();
}
return cachedFieldString;
}
String cachedShortFieldString = null;
/**
* @return a "short" string containing just the field name and type, formatted like fieldName:fieldType
*/
public String getShortFieldString() {
if (cachedShortFieldString == null) {
String fieldName = this.fieldName.getStringValue();
String fieldType = this.fieldType.getTypeDescriptor();
StringBuffer sb = new StringBuffer(fieldName.length() + fieldType.length() + 1);
sb.append(fieldName);
sb.append(":");
sb.append(fieldType);
cachedShortFieldString = sb.toString();
}
return cachedShortFieldString;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = classType.hashCode();
hashCode = 31 * hashCode + fieldType.hashCode();
hashCode = 31 * hashCode + fieldName.hashCode();
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
//This assumes that the referenced items have been interned in both objects.
//This is a valid assumption because all outside code must use the static
//"getInterned..." style methods to make new items, and any item created
//internally is guaranteed to be interned
FieldIdItem other = (FieldIdItem)o;
return (classType == other.classType &&
fieldType == other.fieldType &&
fieldName == other.fieldName);
}
public FieldIdItem convert() {
return this;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/FieldIdItem.java
|
Java
|
asf20
| 9,686
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import com.google.common.base.Preconditions;
import org.jf.dexlib.Util.AlignmentUtils;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.ExceptionWithContext;
import org.jf.dexlib.Util.Input;
public abstract class Item<T extends Item> implements Comparable<T> {
/**
* The offset of this item in the dex file, or -1 if not known
*/
protected int offset = -1;
/**
* The index of this item in the containing section, or -1 if not known
*/
protected int index = -1;
/**
* The DexFile that this item is associatedr with
*/
protected final DexFile dexFile;
/**
* The constructor that is used when reading in a <code>DexFile</code>
* @param dexFile the <code>DexFile</code> that this item is associated with
*/
protected Item(DexFile dexFile) {
assert dexFile != null;
this.dexFile = dexFile;
}
/**
* Read in the item from the given input stream, and initialize the index
* @param in the <code>Input</code> object to read from
* @param index the index within the containing section of the item being read in
* @param readContext a <code>ReadContext</code> object to hold information that is
* only needed while reading in a file
*/
protected void readFrom(Input in, int index, ReadContext readContext) {
try {
assert AlignmentUtils.isAligned(in.getCursor(), getItemType().ItemAlignment);
this.offset = in.getCursor();
this.index = index;
this.readItem(in, readContext);
} catch (Exception ex) {
throw addExceptionContext(ex);
}
}
/**
* Place the item at the given offset and index, and return the offset of the byte following this item
* @param offset The offset to place the item at
* @param index The index of the item within the containing section
* @return The offset of the byte following this item
*/
protected int placeAt(int offset, int index) {
try {
assert AlignmentUtils.isAligned(offset, getItemType().ItemAlignment);
assert !dexFile.getInplace() || (offset == this.offset && this.index == index);
this.offset = offset;
this.index = index;
return this.placeItem(offset);
} catch (Exception ex) {
throw addExceptionContext(ex);
}
}
/**
* Write and annotate this item to the output stream
* @param out The output stream to write and annotate to
*/
protected void writeTo(AnnotatedOutput out) {
try {
assert AlignmentUtils.isAligned(offset, getItemType().ItemAlignment);
//ensure that it is being written to the same offset where it was previously placed
assert out.getCursor() == offset;
if (out.annotates()) {
out.annotate(0, "[" + index + "] " + this.getItemType().TypeName);
}
out.indent();
writeItem(out);
out.deindent();
} catch (Exception ex) {
throw addExceptionContext(ex);
}
}
/**
* Returns a human readable form of this item
* @return a human readable form of this item
*/
public String toString() {
return getConciseIdentity();
}
/**
* The method in the concrete item subclass that actually reads in the data for the item
*
* The logic in this method can assume that the given Input object is valid and is
* aligned as neccessary.
*
* This method is for internal use only
* @param in the <code>Input</code> object to read from
* @param readContext a <code>ReadContext</code> object to hold information that is
* only needed while reading in a file
*/
protected abstract void readItem(Input in, ReadContext readContext);
/**
* The method should finalize the layout of the item and return the offset of the byte
* immediately following the item.
*
* The implementation of this method can assume that the offset argument has already been
* aligned based on the item's alignment requirements
*
* This method is for internal use only
* @param offset the (pre-aligned) offset to place the item at
* @return the size of the item, in bytes
*/
protected abstract int placeItem(int offset);
/**
* The method in the concrete item subclass that actually writes and annotates the data
* for the item.
*
* The logic in this method can assume that the given Output object is valid and is
* aligned as neccessary
*
* @param out The <code>AnnotatedOutput</code> object to write/annotate to
*/
protected abstract void writeItem(AnnotatedOutput out);
/**
* This method is called to add item specific context information to an exception, to identify the "current item"
* when the exception occured. It adds the value returned by <code>getConciseIdentity</code> as context for the
* exception
* @param ex The exception that occured
* @return A RuntimeException with additional details about the item added
*/
protected final RuntimeException addExceptionContext(Exception ex) {
return ExceptionWithContext.withContext(ex, getConciseIdentity());
}
/**
* @return An ItemType enum that represents the item type of this item
*/
public abstract ItemType getItemType();
/**
* @return A concise (human-readable) string value that conveys the identity of this item
*/
public abstract String getConciseIdentity();
/**
* Note that the item must have been placed before calling this method (See <code>DexFile.place()</code>)
* @return the offset in the dex file where this item is located
*/
public int getOffset() {
Preconditions.checkState(offset != -1,
"The offset is not set until the DexFile containing this item is placed.");
return offset;
}
/**
* Note that the item must have been placed before calling this method (See <code>DexFile.place()</code>)
* @return the index of this item within the item's containing section.
*/
public int getIndex() {
Preconditions.checkState(index != -1,
"The index is not set until the DexFile containing this item is placed.");
return index;
}
/**
* @return True if this item has been placed, otherwise False
*/
public boolean isPlaced() {
return offset != -1;
}
/**
* @return the <code>DexFile</code> that contains this item
*/
public DexFile getDexFile() {
return dexFile;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Item.java
|
Java
|
asf20
| 8,267
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.EncodedValue.AnnotationEncodedSubValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public class AnnotationItem extends Item<AnnotationItem> {
private int hashCode = 0;
private AnnotationVisibility visibility;
private AnnotationEncodedSubValue annotationValue;
/**
* Creates a new uninitialized <code>AnnotationItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected AnnotationItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>AnnotationItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param visibility The visibility of this annotation
* @param annotationValue The value of this annotation
*/
private AnnotationItem(DexFile dexFile, AnnotationVisibility visibility,
AnnotationEncodedSubValue annotationValue) {
super(dexFile);
this.visibility = visibility;
this.annotationValue = annotationValue;
}
/**
* Returns an <code>AnnotationItem</code> for the given values, and that has been interned into the given
* <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param visibility The visibility of this annotation
* @param annotationValue The value of this annotation
* @return an <code>AnnotationItem</code> for the given values, and that has been interned into the given
* <code>DexFile</code>
*/
public static AnnotationItem internAnnotationItem(DexFile dexFile, AnnotationVisibility visibility,
AnnotationEncodedSubValue annotationValue) {
AnnotationItem annotationItem = new AnnotationItem(dexFile, visibility, annotationValue);
return dexFile.AnnotationsSection.intern(annotationItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
visibility = AnnotationVisibility.fromByte(in.readByte());
annotationValue = new AnnotationEncodedSubValue(dexFile, in);
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return annotationValue.placeValue(offset + 1);
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate("visibility: " + visibility.name());
out.writeByte(visibility.value);
annotationValue.writeValue(out);
}else {
out.writeByte(visibility.value);
annotationValue.writeValue(out);
}
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_ANNOTATION_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "annotation_item @0x" + Integer.toHexString(getOffset());
}
/** {@inheritDoc} */
public int compareTo(AnnotationItem o) {
int comp = visibility.value - o.visibility.value;
if (comp == 0) {
comp = annotationValue.compareTo(o.annotationValue);
}
return comp;
}
/**
* @return The visibility of this annotation
*/
public AnnotationVisibility getVisibility() {
return visibility;
}
/**
* @return The encoded annotation value of this annotation
*/
public AnnotationEncodedSubValue getEncodedAnnotation() {
return annotationValue;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = visibility.value;
hashCode = hashCode * 31 + annotationValue.hashCode();
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
AnnotationItem other = (AnnotationItem)o;
return visibility == other.visibility && annotationValue.equals(other.annotationValue);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/AnnotationItem.java
|
Java
|
asf20
| 5,879
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class AnnotationSetItem extends Item<AnnotationSetItem> {
private int hashCode = 0;
private AnnotationItem[] annotations;
/**
* Creates a new uninitialized <code>AnnotationSetItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected AnnotationSetItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>AnnotationSetItem</code> for the given annotations
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param annotations The annotations for this <code>AnnotationSetItem</code>
*/
private AnnotationSetItem(DexFile dexFile, AnnotationItem[] annotations) {
super(dexFile);
this.annotations = annotations;
}
/**
* Returns an <code>AnnotationSetItem</code> for the given annotations, and that has been interned into the given
* <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param annotations The annotations for this <code>AnnotationSetItem</code>
* @return an <code>AnnotationSetItem</code> for the given annotations
*/
public static AnnotationSetItem internAnnotationSetItem(DexFile dexFile, List<AnnotationItem> annotations) {
AnnotationSetItem annotationSetItem;
if (annotations == null) {
annotationSetItem = new AnnotationSetItem(dexFile, new AnnotationItem[0]);
} else {
AnnotationItem[] annotationsArray = new AnnotationItem[annotations.size()];
annotations.toArray(annotationsArray);
annotationSetItem = new AnnotationSetItem(dexFile, annotationsArray);
}
return dexFile.AnnotationSetsSection.intern(annotationSetItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
annotations = new AnnotationItem[in.readInt()];
for (int i=0; i<annotations.length; i++) {
annotations[i] = (AnnotationItem)readContext.getOffsettedItemByOffset(ItemType.TYPE_ANNOTATION_ITEM,
in.readInt());
}
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 4 + annotations.length * 4;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
Arrays.sort(annotations, new Comparator<AnnotationItem>() {
public int compare(AnnotationItem annotationItem, AnnotationItem annotationItem2) {
int annotationItemIndex = annotationItem.getEncodedAnnotation().annotationType.getIndex();
int annotationItemIndex2 = annotationItem2.getEncodedAnnotation().annotationType.getIndex();
if (annotationItemIndex < annotationItemIndex2) {
return -1;
} else if (annotationItemIndex == annotationItemIndex2) {
return 0;
}
return 1;
}
});
if (out.annotates()) {
out.annotate(4, "size: 0x" + Integer.toHexString(annotations.length) + " (" + annotations.length + ")");
for (AnnotationItem annotationItem: annotations) {
out.annotate(4, "annotation_off: 0x" + Integer.toHexString(annotationItem.getOffset()) + " - " +
annotationItem.getEncodedAnnotation().annotationType.getTypeDescriptor());
}
}
out.writeInt(annotations.length);
for (AnnotationItem annotationItem: annotations) {
out.writeInt(annotationItem.getOffset());
}
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_ANNOTATION_SET_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "annotation_set_item @0x" + Integer.toHexString(getOffset());
}
/** {@inheritDoc} */
public int compareTo(AnnotationSetItem o) {
if (o == null) {
return 1;
}
int comp = annotations.length - o.annotations.length;
if (comp == 0) {
for (int i=0; i<annotations.length; i++) {
comp = annotations[i].compareTo(o.annotations[i]);
if (comp != 0) {
return comp;
}
}
}
return comp;
}
/**
* @return An array of the <code>AnnotationItem</code> objects in this <code>AnnotationSetItem</code>
*/
public AnnotationItem[] getAnnotations() {
return annotations;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = 0;
for (AnnotationItem annotationItem: annotations) {
hashCode = hashCode * 31 + annotationItem.hashCode();
}
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
AnnotationSetItem other = (AnnotationSetItem)o;
return (this.compareTo(other) == 0);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/AnnotationSetItem.java
|
Java
|
asf20
| 7,077
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Debug.DebugInstructionIterator;
import org.jf.dexlib.Debug.DebugOpcode;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.ByteArrayInput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.Leb128Utils;
import java.util.ArrayList;
import java.util.List;
public class DebugInfoItem extends Item<DebugInfoItem> {
private int lineStart;
private StringIdItem[] parameterNames;
private byte[] encodedDebugInfo;
private Item[] referencedItems;
private CodeItem parent = null;
/**
* Creates a new uninitialized <code>DebugInfoInfo</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
public DebugInfoItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>DebugInfoItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param lineStart the initial value for the line number register for the debug info machine
* @param parameterNames an array of the names of the associated method's parameters. The entire parameter
* can be null if no parameter info is available, or any element can be null to indicate no info for that parameter
* @param encodedDebugInfo the debug info, encoded as a byte array
* @param referencedItems an array of the items referenced by instructions, in order of occurance in the encoded
* debug info
*/
private DebugInfoItem(DexFile dexFile,
int lineStart,
StringIdItem[] parameterNames,
byte[] encodedDebugInfo,
Item[] referencedItems) {
super(dexFile);
this.lineStart = lineStart;
this.parameterNames = parameterNames;
this.encodedDebugInfo = encodedDebugInfo;
this.referencedItems = referencedItems;
}
/**
* Returns a new <code>DebugInfoItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param lineStart the initial value for the line number register for the debug info machine
* @param parameterNames an array of the names of the associated method's parameters. The entire parameter
* can be null if no parameter info is available, or any element can be null to indicate no info for that parameter
* @param encodedDebugInfo the debug info, encoded as a byte array
* @param referencedItems an array of the items referenced by instructions, in order of occurance in the encoded
* debug info
* @return a new <code>DebugInfoItem</code> with the given values
*/
public static DebugInfoItem internDebugInfoItem(DexFile dexFile,
int lineStart,
StringIdItem[] parameterNames,
byte[] encodedDebugInfo,
Item[] referencedItems) {
DebugInfoItem debugInfoItem = new DebugInfoItem(dexFile, lineStart, parameterNames, encodedDebugInfo,
referencedItems);
return dexFile.DebugInfoItemsSection.intern(debugInfoItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
lineStart = in.readUnsignedLeb128();
parameterNames = new StringIdItem[in.readUnsignedLeb128()];
IndexedSection<StringIdItem> stringIdSection = dexFile.StringIdsSection;
for (int i=0; i<parameterNames.length; i++) {
parameterNames[i] = stringIdSection.getOptionalItemByIndex(in.readUnsignedLeb128() - 1);
}
int start = in.getCursor();
final List<Item> referencedItemsList = new ArrayList<Item>(50);
DebugInstructionIterator.IterateInstructions(in,
new DebugInstructionIterator.ProcessRawDebugInstructionDelegate() {
@Override
public void ProcessStartLocal(int startDebugOffset, int length, int registerNum, int nameIndex,
int typeIndex, boolean registerIsSigned) {
if (nameIndex != -1) {
referencedItemsList.add(dexFile.StringIdsSection.getItemByIndex(nameIndex));
}
if (typeIndex != -1) {
referencedItemsList.add(dexFile.TypeIdsSection.getItemByIndex(typeIndex));
}
}
@Override
public void ProcessStartLocalExtended(int startDebugOffset, int length, int registerNume,
int nameIndex, int typeIndex, int signatureIndex,
boolean registerIsSigned) {
if (nameIndex != -1) {
referencedItemsList.add(dexFile.StringIdsSection.getItemByIndex(nameIndex));
}
if (typeIndex != -1) {
referencedItemsList.add(dexFile.TypeIdsSection.getItemByIndex(typeIndex));
}
if (signatureIndex != -1) {
referencedItemsList.add(dexFile.StringIdsSection.getItemByIndex(signatureIndex));
}
}
@Override
public void ProcessSetFile(int startDebugOffset, int length, int nameIndex) {
if (nameIndex != -1) {
referencedItemsList.add(dexFile.StringIdsSection.getItemByIndex(nameIndex));
}
}
});
referencedItems = new Item[referencedItemsList.size()];
referencedItemsList.toArray(referencedItems);
int length = in.getCursor() - start;
in.setCursor(start);
encodedDebugInfo = in.readBytes(length);
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
offset += Leb128Utils.unsignedLeb128Size(lineStart);
offset += Leb128Utils.unsignedLeb128Size(parameterNames.length);
for (StringIdItem parameterName: parameterNames) {
int indexp1;
if (parameterName == null) {
indexp1 = 0;
} else {
indexp1 = parameterName.getIndex() + 1;
}
offset += Leb128Utils.unsignedLeb128Size(indexp1);
}
//make a subclass so we can keep track of and access the computed length
class ProcessDebugInstructionDelegateWithLength extends
DebugInstructionIterator.ProcessRawDebugInstructionDelegate {
public int length = 0;
}
ProcessDebugInstructionDelegateWithLength pdidwl;
//final referencedItems = this.referencedItems;
DebugInstructionIterator.IterateInstructions(new ByteArrayInput(encodedDebugInfo),
pdidwl = new ProcessDebugInstructionDelegateWithLength() {
private int referencedItemsPosition = 0;
@Override
public void ProcessStaticOpcode(DebugOpcode opcode, int startDebugOffset, int length) {
this.length+=length;
}
@Override
public void ProcessStartLocal(int startDebugOffset, int length, int registerNum, int nameIndex,
int typeIndex, boolean registerIsSigned) {
this.length++;
if (dexFile.getPreserveSignedRegisters() && registerIsSigned) {
this.length += Leb128Utils.signedLeb128Size(registerNum);
} else {
this.length+=Leb128Utils.unsignedLeb128Size(registerNum);
}
if (nameIndex != -1) {
this.length+=
Leb128Utils.unsignedLeb128Size(referencedItems[referencedItemsPosition++].getIndex()+1);
} else {
this.length++;
}
if (typeIndex != -1) {
this.length+=
Leb128Utils.unsignedLeb128Size(referencedItems[referencedItemsPosition++].getIndex()+1);
} else {
this.length++;
}
}
@Override
public void ProcessStartLocalExtended(int startDebugOffset, int length, int registerNum, int nameIndex,
int typeIndex, int signatureIndex,
boolean registerIsSigned) {
this.length++;
if (dexFile.getPreserveSignedRegisters() && registerIsSigned) {
this.length += Leb128Utils.signedLeb128Size(registerNum);
} else {
this.length+=Leb128Utils.unsignedLeb128Size(registerNum);
}
if (nameIndex != -1) {
this.length+=
Leb128Utils.unsignedLeb128Size(referencedItems[referencedItemsPosition++].getIndex()+1);
} else {
this.length++;
}
if (typeIndex != -1) {
this.length+=
Leb128Utils.unsignedLeb128Size(referencedItems[referencedItemsPosition++].getIndex()+1);
} else {
this.length++;
}
if (signatureIndex != -1) {
this.length+=
Leb128Utils.unsignedLeb128Size(referencedItems[referencedItemsPosition++].getIndex()+1);
} else {
this.length++;
}
}
@Override
public void ProcessSetFile(int startDebugOffset, int length, int nameIndex) {
this.length++;
if (nameIndex != -1) {
this.length+=
Leb128Utils.unsignedLeb128Size(referencedItems[referencedItemsPosition++].getIndex()+1);
} else {
this.length++;
}
}
});
return offset + pdidwl.length;
}
/** {@inheritDoc} */
protected void writeItem(final AnnotatedOutput out) {
if (out.annotates()) {
writeItemWithAnnotations(out);
} else {
writeItemWithNoAnnotations(out);
}
}
/**
* Replaces the encoded debug info for this DebugInfoItem. It is expected that the new debug info is compatible
* with the existing information, i.e. lineStart, referencedItems, parameterNames
* @param encodedDebugInfo the new encoded debug info
*/
protected void setEncodedDebugInfo(byte[] encodedDebugInfo) {
//TODO: I would rather replace this method with some way of saying "The (code) instruction at address changed from A bytes to B bytes. Fixup the debug info accordingly"
this.encodedDebugInfo = encodedDebugInfo;
}
/**
* Helper method that writes the item, without writing annotations
* @param out the AnnotatedOutput object
*/
private void writeItemWithNoAnnotations(final AnnotatedOutput out) {
out.writeUnsignedLeb128(lineStart);
out.writeUnsignedLeb128(parameterNames.length);
for (StringIdItem parameterName: parameterNames) {
int indexp1;
if (parameterName == null) {
indexp1 = 0;
} else {
indexp1 = parameterName.getIndex() + 1;
}
out.writeUnsignedLeb128(indexp1);
}
DebugInstructionIterator.IterateInstructions(new ByteArrayInput(encodedDebugInfo),
new DebugInstructionIterator.ProcessRawDebugInstructionDelegate() {
private int referencedItemsPosition = 0;
@Override
public void ProcessStaticOpcode(DebugOpcode opcode, int startDebugOffset, int length) {
out.write(encodedDebugInfo, startDebugOffset, length);
}
@Override
public void ProcessStartLocal(int startDebugOffset, int length, int registerNum, int nameIndex,
int typeIndex, boolean registerIsSigned) {
out.writeByte(DebugOpcode.DBG_START_LOCAL.value);
if (dexFile.getPreserveSignedRegisters() && registerIsSigned) {
out.writeSignedLeb128(registerNum);
} else {
out.writeUnsignedLeb128(registerNum);
}
if (nameIndex != -1) {
out.writeUnsignedLeb128(referencedItems[referencedItemsPosition++].getIndex() + 1);
} else {
out.writeByte(0);
}
if (typeIndex != -1) {
out.writeUnsignedLeb128(referencedItems[referencedItemsPosition++].getIndex() + 1);
} else {
out.writeByte(0);
}
}
@Override
public void ProcessStartLocalExtended(int startDebugOffset, int length, int registerNum, int nameIndex,
int typeIndex, int signatureIndex,
boolean registerIsSigned) {
out.writeByte(DebugOpcode.DBG_START_LOCAL_EXTENDED.value);
if (dexFile.getPreserveSignedRegisters() && registerIsSigned) {
out.writeSignedLeb128(registerNum);
} else {
out.writeUnsignedLeb128(registerNum);
}
if (nameIndex != -1) {
out.writeUnsignedLeb128(referencedItems[referencedItemsPosition++].getIndex() + 1);
} else {
out.writeByte(0);
}
if (typeIndex != -1) {
out.writeUnsignedLeb128(referencedItems[referencedItemsPosition++].getIndex() + 1);
} else {
out.writeByte(0);
}
if (signatureIndex != -1) {
out.writeUnsignedLeb128(referencedItems[referencedItemsPosition++].getIndex() + 1);
} else {
out.writeByte(0);
}
}
@Override
public void ProcessSetFile(int startDebugOffset, int length, int nameIndex) {
out.writeByte(DebugOpcode.DBG_SET_FILE.value);
if (nameIndex != -1) {
out.writeUnsignedLeb128(referencedItems[referencedItemsPosition++].getIndex() + 1);
} else {
out.writeByte(0);
}
}
});
}
/**
* Helper method that writes and annotates the item
* @param out the AnnotatedOutput object
*/
private void writeItemWithAnnotations(final AnnotatedOutput out) {
out.annotate(0, parent.getParent().method.getMethodString());
out.annotate("line_start: 0x" + Integer.toHexString(lineStart) + " (" + lineStart + ")");
out.writeUnsignedLeb128(lineStart);
out.annotate("parameters_size: 0x" + Integer.toHexString(parameterNames.length) + " (" + parameterNames.length
+ ")");
out.writeUnsignedLeb128(parameterNames.length);
int index = 0;
for (StringIdItem parameterName: parameterNames) {
int indexp1;
if (parameterName == null) {
out.annotate("[" + index++ +"] parameterName: ");
indexp1 = 0;
} else {
out.annotate("[" + index++ +"] parameterName: " + parameterName.getStringValue());
indexp1 = parameterName.getIndex() + 1;
}
out.writeUnsignedLeb128(indexp1);
}
DebugInstructionIterator.IterateInstructions(new ByteArrayInput(encodedDebugInfo),
new DebugInstructionIterator.ProcessRawDebugInstructionDelegate() {
private int referencedItemsPosition = 0;
@Override
public void ProcessEndSequence(int startDebugOffset) {
out.annotate("DBG_END_SEQUENCE");
out.writeByte(DebugOpcode.DBG_END_SEQUENCE.value);
}
@Override
public void ProcessAdvancePC(int startDebugOffset, int length, int addressDiff) {
out.annotate("DBG_ADVANCE_PC");
out.writeByte(DebugOpcode.DBG_ADVANCE_PC.value);
out.indent();
out.annotate("addr_diff: 0x" + Integer.toHexString(addressDiff) + " (" + addressDiff + ")");
out.writeUnsignedLeb128(addressDiff);
out.deindent();
}
@Override
public void ProcessAdvanceLine(int startDebugOffset, int length, int lineDiff) {
out.annotate("DBG_ADVANCE_LINE");
out.writeByte(DebugOpcode.DBG_ADVANCE_LINE.value);
out.indent();
out.annotate("line_diff: 0x" + Integer.toHexString(lineDiff) + " (" + lineDiff + ")");
out.writeSignedLeb128(lineDiff);
out.deindent();
}
@Override
public void ProcessStartLocal(int startDebugOffset, int length, int registerNum, int nameIndex,
int typeIndex, boolean registerIsSigned) {
out.annotate("DBG_START_LOCAL");
out.writeByte(DebugOpcode.DBG_START_LOCAL.value);
out.indent();
out.annotate("register_num: 0x" + Integer.toHexString(registerNum) + " (" + registerNum + ")");
if (dexFile.getPreserveSignedRegisters() && registerIsSigned) {
out.writeSignedLeb128(registerNum);
} else {
out.writeUnsignedLeb128(registerNum);
}
if (nameIndex != -1) {
Item nameItem = referencedItems[referencedItemsPosition++];
assert nameItem instanceof StringIdItem;
out.annotate("name: " + ((StringIdItem)nameItem).getStringValue());
out.writeUnsignedLeb128(nameItem.getIndex() + 1);
} else {
out.annotate("name: ");
out.writeByte(0);
}
if (typeIndex != -1) {
Item typeItem = referencedItems[referencedItemsPosition++];
assert typeItem instanceof TypeIdItem;
out.annotate("type: " + ((TypeIdItem)typeItem).getTypeDescriptor());
out.writeUnsignedLeb128(typeItem.getIndex() + 1);
} else {
out.annotate("type: ");
out.writeByte(0);
}
out.deindent();
}
@Override
public void ProcessStartLocalExtended(int startDebugOffset, int length, int registerNum,
int nameIndex, int typeIndex, int signatureIndex,
boolean registerIsSigned) {
out.annotate("DBG_START_LOCAL_EXTENDED");
out.writeByte(DebugOpcode.DBG_START_LOCAL_EXTENDED.value);
out.indent();
out.annotate("register_num: 0x" + Integer.toHexString(registerNum) + " (" + registerNum + ")");
if (dexFile.getPreserveSignedRegisters() && registerIsSigned) {
out.writeSignedLeb128(registerNum);
} else {
out.writeUnsignedLeb128(registerNum);
}
if (nameIndex != -1) {
Item nameItem = referencedItems[referencedItemsPosition++];
assert nameItem instanceof StringIdItem;
out.annotate("name: " + ((StringIdItem)nameItem).getStringValue());
out.writeUnsignedLeb128(nameItem.getIndex() + 1);
} else {
out.annotate("name: ");
out.writeByte(0);
}
if (typeIndex != -1) {
Item typeItem = referencedItems[referencedItemsPosition++];
assert typeItem instanceof TypeIdItem;
out.annotate("type: " + ((TypeIdItem)typeItem).getTypeDescriptor());
out.writeUnsignedLeb128(typeItem.getIndex() + 1);
} else {
out.annotate("type: ");
out.writeByte(0);
}
if (signatureIndex != -1) {
Item signatureItem = referencedItems[referencedItemsPosition++];
assert signatureItem instanceof StringIdItem;
out.annotate("signature: " + ((StringIdItem)signatureItem).getStringValue());
out.writeUnsignedLeb128(signatureItem.getIndex() + 1);
} else {
out.annotate("signature: ");
out.writeByte(0);
}
out.deindent();
}
@Override
public void ProcessEndLocal(int startDebugOffset, int length, int registerNum,
boolean registerIsSigned) {
out.annotate("DBG_END_LOCAL");
out.writeByte(DebugOpcode.DBG_END_LOCAL.value);
out.annotate("register_num: 0x" + Integer.toHexString(registerNum) + " (" + registerNum + ")");
if (registerIsSigned) {
out.writeSignedLeb128(registerNum);
} else {
out.writeUnsignedLeb128(registerNum);
}
}
@Override
public void ProcessRestartLocal(int startDebugOffset, int length, int registerNum,
boolean registerIsSigned) {
out.annotate("DBG_RESTART_LOCAL");
out.writeByte(DebugOpcode.DBG_RESTART_LOCAL.value);
out.annotate("register_num: 0x" + Integer.toHexString(registerNum) + " (" + registerNum + ")");
if (registerIsSigned) {
out.writeSignedLeb128(registerNum);
} else {
out.writeUnsignedLeb128(registerNum);
}
}
@Override
public void ProcessSetPrologueEnd(int startDebugOffset) {
out.annotate("DBG_SET_PROLOGUE_END");
out.writeByte(DebugOpcode.DBG_SET_PROLOGUE_END.value);
}
@Override
public void ProcessSetEpilogueBegin(int startDebugOffset) {
out.annotate("DBG_SET_EPILOGUE_BEGIN");
out.writeByte(DebugOpcode.DBG_SET_EPILOGUE_BEGIN.value);
}
@Override
public void ProcessSetFile(int startDebugOffset, int length, int nameIndex) {
out.annotate("DBG_SET_FILE");
out.writeByte(DebugOpcode.DBG_SET_FILE.value);
if (nameIndex != -1) {
Item sourceItem = referencedItems[referencedItemsPosition++];
assert sourceItem instanceof StringIdItem;
out.annotate("source_file: \"" + ((StringIdItem)sourceItem).getStringValue() + "\"");
out.writeUnsignedLeb128(sourceItem.getIndex() + 1);
} else {
out.annotate("source_file: ");
out.writeByte(0);
}
}
@Override
public void ProcessSpecialOpcode(int startDebugOffset, int debugOpcode, int lineDiff,
int addressDiff) {
out.annotate("DBG_SPECIAL_OPCODE: line_diff=0x" + Integer.toHexString(lineDiff) + "(" +
lineDiff +"),addressDiff=0x" + Integer.toHexString(addressDiff) + "(" + addressDiff +
")");
out.writeByte(debugOpcode);
}
});
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_DEBUG_INFO_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "debug_info_item @0x" + Integer.toHexString(getOffset());
}
/** {@inheritDoc} */
public int compareTo(DebugInfoItem other) {
if (parent == null) {
if (other.parent == null) {
return 0;
}
return -1;
}
if (other.parent == null) {
return 1;
}
return parent.compareTo(other.parent);
}
/**
* Set the <code>CodeItem</code> that this <code>DebugInfoItem</code> is associated with
* @param codeItem the <code>CodeItem</code> that this <code>DebugInfoItem</code> is associated with
*/
protected void setParent(CodeItem codeItem) {
this.parent = codeItem;
}
/**
* @return the initial value for the line number register for the debug info machine
*/
public int getLineStart() {
return lineStart;
}
/**
* @return the debug info, encoded as a byte array
*/
public byte[] getEncodedDebugInfo() {
return encodedDebugInfo;
}
/**
* @return an array of the items referenced by instructions, in order of occurance in the encoded debug info
*/
public Item[] getReferencedItems() {
return referencedItems;
}
/**
* @return an array of the names of the associated method's parameters. The array can be null if no parameter info
* is available, or any element can be null to indicate no info for that parameter
*/
public StringIdItem[] getParameterNames() {
return parameterNames;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/DebugInfoItem.java
|
Java
|
asf20
| 29,735
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import com.google.common.base.Preconditions;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.ExceptionWithContext;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.ReadOnlyArrayList;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.*;
public class AnnotationDirectoryItem extends Item<AnnotationDirectoryItem> {
@Nullable
private AnnotationSetItem classAnnotations;
@Nullable
private FieldAnnotation[] fieldAnnotations;
@Nullable
private MethodAnnotation[] methodAnnotations;
@Nullable
private ParameterAnnotation[] parameterAnnotations;
/**
* Creates a new uninitialized <code>AnnotationDirectoryItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected AnnotationDirectoryItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>AnnotationDirectoryItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classAnnotations The annotations associated with the overall class
* @param fieldAnnotations A list of <code>FieldAnnotation</code> objects that contain the field annotations for
* this class
* @param methodAnnotations A list of <code>MethodAnnotation</code> objects that contain the method annotations for
* this class
* @param parameterAnnotations A list of <code>ParameterAnnotation</code> objects that contain the parameter
* annotations for the methods in this class
*/
private AnnotationDirectoryItem(DexFile dexFile, @Nullable AnnotationSetItem classAnnotations,
@Nullable List<FieldAnnotation> fieldAnnotations,
@Nullable List<MethodAnnotation> methodAnnotations,
@Nullable List<ParameterAnnotation> parameterAnnotations) {
super(dexFile);
this.classAnnotations = classAnnotations;
if (fieldAnnotations == null || fieldAnnotations.size() == 0) {
this.fieldAnnotations = null;
} else {
this.fieldAnnotations = new FieldAnnotation[fieldAnnotations.size()];
this.fieldAnnotations = fieldAnnotations.toArray(this.fieldAnnotations);
Arrays.sort(this.fieldAnnotations);
}
if (methodAnnotations == null || methodAnnotations.size() == 0) {
this.methodAnnotations = null;
} else {
this.methodAnnotations = new MethodAnnotation[methodAnnotations.size()];
this.methodAnnotations = methodAnnotations.toArray(this.methodAnnotations);
Arrays.sort(this.methodAnnotations);
}
if (parameterAnnotations == null || parameterAnnotations.size() == 0) {
this.parameterAnnotations = null;
} else {
this.parameterAnnotations = new ParameterAnnotation[parameterAnnotations.size()];
this.parameterAnnotations = parameterAnnotations.toArray(this.parameterAnnotations);
Arrays.sort(this.parameterAnnotations);
}
}
/**
* Returns an <code>AnnotationDirectoryItem</code> for the given values, and that has been interned into the given
* <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classAnnotations The annotations associated with the class
* @param fieldAnnotations A list of <code>FieldAnnotation</code> objects containing the field annotations
* @param methodAnnotations A list of <code>MethodAnnotation</code> objects containing the method annotations
* @param parameterAnnotations A list of <code>ParameterAnnotation</code> objects containin the parameter
* annotations
* @return an <code>AnnotationItem</code> for the given values, and that has been interned into the given
* <code>DexFile</code>
*/
public static AnnotationDirectoryItem internAnnotationDirectoryItem(DexFile dexFile,
AnnotationSetItem classAnnotations,
List<FieldAnnotation> fieldAnnotations,
List<MethodAnnotation> methodAnnotations,
List<ParameterAnnotation> parameterAnnotations) {
AnnotationDirectoryItem annotationDirectoryItem = new AnnotationDirectoryItem(dexFile, classAnnotations,
fieldAnnotations, methodAnnotations, parameterAnnotations);
return dexFile.AnnotationDirectoriesSection.intern(annotationDirectoryItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
classAnnotations = (AnnotationSetItem)readContext.getOptionalOffsettedItemByOffset(
ItemType.TYPE_ANNOTATION_SET_ITEM, in.readInt());
int fieldAnnotationCount = in.readInt();
if (fieldAnnotationCount > 0) {
fieldAnnotations = new FieldAnnotation[fieldAnnotationCount];
} else {
fieldAnnotations = null;
}
int methodAnnotationCount = in.readInt();
if (methodAnnotationCount > 0) {
methodAnnotations = new MethodAnnotation[methodAnnotationCount];
} else {
methodAnnotations = null;
}
int parameterAnnotationCount = in.readInt();
if (parameterAnnotationCount > 0) {
parameterAnnotations = new ParameterAnnotation[parameterAnnotationCount];
} else {
parameterAnnotations = null;
}
if (fieldAnnotations != null) {
for (int i=0; i<fieldAnnotations.length; i++) {
try {
FieldIdItem fieldIdItem = dexFile.FieldIdsSection.getItemByIndex(in.readInt());
AnnotationSetItem fieldAnnotationSet = (AnnotationSetItem)readContext.getOffsettedItemByOffset(
ItemType.TYPE_ANNOTATION_SET_ITEM, in.readInt());
fieldAnnotations[i] = new FieldAnnotation(fieldIdItem, fieldAnnotationSet);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex,
"Error occured while reading FieldAnnotation at index " + i);
}
}
}
if (methodAnnotations != null) {
for (int i=0; i<methodAnnotations.length; i++) {
try {
MethodIdItem methodIdItem = dexFile.MethodIdsSection.getItemByIndex(in.readInt());
AnnotationSetItem methodAnnotationSet = (AnnotationSetItem)readContext.getOffsettedItemByOffset(
ItemType.TYPE_ANNOTATION_SET_ITEM, in.readInt());
methodAnnotations[i] = new MethodAnnotation(methodIdItem, methodAnnotationSet);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex,
"Error occured while reading MethodAnnotation at index " + i);
}
}
}
if (parameterAnnotations != null) {
for (int i=0; i<parameterAnnotations.length; i++) {
try {
MethodIdItem methodIdItem = dexFile.MethodIdsSection.getItemByIndex(in.readInt());
AnnotationSetRefList paramaterAnnotationSet = (AnnotationSetRefList)readContext.getOffsettedItemByOffset(
ItemType.TYPE_ANNOTATION_SET_REF_LIST, in.readInt());
parameterAnnotations[i] = new ParameterAnnotation(methodIdItem, paramaterAnnotationSet);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex,
"Error occured while reading ParameterAnnotation at index " + i);
}
}
}
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 16 + (
(fieldAnnotations==null?0:fieldAnnotations.length) +
(methodAnnotations==null?0:methodAnnotations.length) +
(parameterAnnotations==null?0:parameterAnnotations.length)) * 8;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
TypeIdItem parentType = getParentType();
if (parentType != null) {
out.annotate(0, parentType.getTypeDescriptor());
}
if (classAnnotations != null) {
out.annotate(4, "class_annotations_off: 0x" + Integer.toHexString(classAnnotations.getOffset()));
} else {
out.annotate(4, "class_annotations_off:");
}
int length = fieldAnnotations==null?0:fieldAnnotations.length;
out.annotate(4, "annotated_fields_size: 0x" + Integer.toHexString(length) + " (" +
length + ")");
length = methodAnnotations==null?0:methodAnnotations.length;
out.annotate(4, "annotated_methods_size: 0x" + Integer.toHexString(length) + " (" +
length + ")");
length = parameterAnnotations==null?0:parameterAnnotations.length;
out.annotate(4, "annotated_parameters_size: 0x" + Integer.toHexString(length) + " (" +
length + ")");
int index;
if (fieldAnnotations != null) {
index = 0;
for (FieldAnnotation fieldAnnotation: fieldAnnotations) {
out.annotate(0, "[" + index++ + "] field_annotation");
out.indent();
out.annotate(4, "field: " + fieldAnnotation.field.getFieldName().getStringValue() + ":" +
fieldAnnotation.field.getFieldType().getTypeDescriptor());
out.annotate(4, "annotations_off: 0x" +
Integer.toHexString(fieldAnnotation.annotationSet.getOffset()));
out.deindent();
}
}
if (methodAnnotations != null) {
index = 0;
for (MethodAnnotation methodAnnotation: methodAnnotations) {
out.annotate(0, "[" + index++ + "] method_annotation");
out.indent();
out.annotate(4, "method: " + methodAnnotation.method.getMethodString());
out.annotate(4, "annotations_off: 0x" +
Integer.toHexString(methodAnnotation.annotationSet.getOffset()));
out.deindent();
}
}
if (parameterAnnotations != null) {
index = 0;
for (ParameterAnnotation parameterAnnotation: parameterAnnotations) {
out.annotate(0, "[" + index++ + "] parameter_annotation");
out.indent();
out.annotate(4, "method: " + parameterAnnotation.method.getMethodString());
out.annotate(4, "annotations_off: 0x" +
Integer.toHexString(parameterAnnotation.annotationSet.getOffset()));
}
}
}
out.writeInt(classAnnotations==null?0:classAnnotations.getOffset());
out.writeInt(fieldAnnotations==null?0:fieldAnnotations.length);
out.writeInt(methodAnnotations==null?0:methodAnnotations.length);
out.writeInt(parameterAnnotations==null?0:parameterAnnotations.length);
if (fieldAnnotations != null) {
for (FieldAnnotation fieldAnnotation: fieldAnnotations) {
out.writeInt(fieldAnnotation.field.getIndex());
out.writeInt(fieldAnnotation.annotationSet.getOffset());
}
}
if (methodAnnotations != null) {
for (MethodAnnotation methodAnnotation: methodAnnotations) {
out.writeInt(methodAnnotation.method.getIndex());
out.writeInt(methodAnnotation.annotationSet.getOffset());
}
}
if (parameterAnnotations != null) {
for (ParameterAnnotation parameterAnnotation: parameterAnnotations) {
out.writeInt(parameterAnnotation.method.getIndex());
out.writeInt(parameterAnnotation.annotationSet.getOffset());
}
}
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_ANNOTATIONS_DIRECTORY_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
TypeIdItem parentType = getParentType();
if (parentType == null) {
return "annotation_directory_item @0x" + Integer.toHexString(getOffset());
}
return "annotation_directory_item @0x" + Integer.toHexString(getOffset()) +
" (" + parentType.getTypeDescriptor() + ")";
}
/** {@inheritDoc} */
public int compareTo(AnnotationDirectoryItem o) {
Preconditions.checkNotNull(o);
TypeIdItem parentType = getParentType();
TypeIdItem otherParentType = o.getParentType();
if (parentType != null) {
if (otherParentType != null) {
return parentType.compareTo(otherParentType);
}
return 1;
}
if (otherParentType != null) {
return -1;
}
if (classAnnotations != null) {
if (o.classAnnotations != null) {
return classAnnotations.compareTo(o.classAnnotations);
}
return 1;
}
return -1;
}
/**
* Returns the parent type for an AnnotationDirectoryItem that is guaranteed to have a single parent, or null
* for one that may be referenced by multiple classes.
*
* Specifically, the AnnotationDirectoryItem may be referenced by multiple classes if it has only class annotations,
* but not field/method/parameter annotations.
*
* @return The parent type for this AnnotationDirectoryItem, or null if it may have multiple parents
*/
@Nullable
public TypeIdItem getParentType() {
if (fieldAnnotations != null && fieldAnnotations.length > 0) {
return fieldAnnotations[0].field.getContainingClass();
}
if (methodAnnotations != null && methodAnnotations.length > 0) {
return methodAnnotations[0].method.getContainingClass();
}
if (parameterAnnotations != null && parameterAnnotations.length > 0) {
return parameterAnnotations[0].method.getContainingClass();
}
return null;
}
/**
* @return An <code>AnnotationSetItem</code> containing the annotations associated with this class, or null
* if there are no class annotations
*/
@Nullable
public AnnotationSetItem getClassAnnotations() {
return classAnnotations;
}
/**
* Get a list of the field annotations in this <code>AnnotationDirectoryItem</code>
* @return A list of FieldAnnotation objects, or null if there are no field annotations
*/
@Nonnull
public List<FieldAnnotation> getFieldAnnotations() {
if (fieldAnnotations == null) {
return Collections.emptyList();
}
return ReadOnlyArrayList.of(fieldAnnotations);
}
/**
* Get a list of the method annotations in this <code>AnnotationDirectoryItem</code>
* @return A list of MethodAnnotation objects, or null if there are no method annotations
*/
@Nonnull
public List<MethodAnnotation> getMethodAnnotations() {
if (methodAnnotations == null) {
return Collections.emptyList();
}
return ReadOnlyArrayList.of(methodAnnotations);
}
/**
* Get a list of the parameter annotations in this <code>AnnotationDirectoryItem</code>
* @return A list of ParameterAnnotation objects, or null if there are no parameter annotations
*/
@Nonnull
public List<ParameterAnnotation> getParameterAnnotations() {
if (parameterAnnotations == null) {
return Collections.emptyList();
}
return ReadOnlyArrayList.of(parameterAnnotations);
}
/**
* Gets the field annotations for the given field, or null if no annotations are defined for that field
* @param fieldIdItem The field to get the annotations for
* @return An <code>AnnotationSetItem</code> containing the field annotations, or null if none are found
*/
@Nullable
public AnnotationSetItem getFieldAnnotations(FieldIdItem fieldIdItem) {
if (fieldAnnotations == null) {
return null;
}
int index = Arrays.binarySearch(fieldAnnotations, fieldIdItem);
if (index < 0) {
return null;
}
return fieldAnnotations[index].annotationSet;
}
/**
* Gets the method annotations for the given method, or null if no annotations are defined for that method
* @param methodIdItem The method to get the annotations for
* @return An <code>AnnotationSetItem</code> containing the method annotations, or null if none are found
*/
@Nullable
public AnnotationSetItem getMethodAnnotations(MethodIdItem methodIdItem) {
if (methodAnnotations == null) {
return null;
}
int index = Arrays.binarySearch(methodAnnotations, methodIdItem);
if (index < 0) {
return null;
}
return methodAnnotations[index].annotationSet;
}
/**
* Gets the parameter annotations for the given method, or null if no parameter annotations are defined for that
* method
* @param methodIdItem The method to get the parameter annotations for
* @return An <code>AnnotationSetRefList</code> containing the parameter annotations, or null if none are found
*/
@Nullable
public AnnotationSetRefList getParameterAnnotations(MethodIdItem methodIdItem) {
if (parameterAnnotations == null) {
return null;
}
int index = Arrays.binarySearch(parameterAnnotations, methodIdItem);
if (index < 0) {
return null;
}
return parameterAnnotations[index].annotationSet;
}
/**
*
*/
public int getClassAnnotationCount() {
if (classAnnotations == null) {
return 0;
}
AnnotationItem[] annotations = classAnnotations.getAnnotations();
return annotations.length;
}
/**
* @return The number of field annotations in this <code>AnnotationDirectoryItem</code>
*/
public int getFieldAnnotationCount() {
if (fieldAnnotations == null) {
return 0;
}
return fieldAnnotations.length;
}
/**
* @return The number of method annotations in this <code>AnnotationDirectoryItem</code>
*/
public int getMethodAnnotationCount() {
if (methodAnnotations == null) {
return 0;
}
return methodAnnotations.length;
}
/**
* @return The number of parameter annotations in this <code>AnnotationDirectoryItem</code>
*/
public int getParameterAnnotationCount() {
if (parameterAnnotations == null) {
return 0;
}
return parameterAnnotations.length;
}
@Override
public int hashCode() {
// If the item has a single parent, we can use the re-use the identity (hash) of that parent
TypeIdItem parentType = getParentType();
if (parentType != null) {
return parentType.hashCode();
}
if (classAnnotations != null) {
return classAnnotations.hashCode();
}
return 0;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
AnnotationDirectoryItem other = (AnnotationDirectoryItem)o;
return (this.compareTo(other) == 0);
}
public static class FieldAnnotation implements Comparable<Convertible<FieldIdItem>>, Convertible<FieldIdItem> {
public final FieldIdItem field;
public final AnnotationSetItem annotationSet;
public FieldAnnotation(FieldIdItem field, AnnotationSetItem annotationSet) {
this.field = field;
this.annotationSet = annotationSet;
}
public int compareTo(Convertible<FieldIdItem> other) {
return field.compareTo(other.convert());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return compareTo((FieldAnnotation)o) == 0;
}
@Override
public int hashCode() {
return field.hashCode() + 31 * annotationSet.hashCode();
}
public FieldIdItem convert() {
return field;
}
}
public static class MethodAnnotation implements Comparable<Convertible<MethodIdItem>>, Convertible<MethodIdItem> {
public final MethodIdItem method;
public final AnnotationSetItem annotationSet;
public MethodAnnotation(MethodIdItem method, AnnotationSetItem annotationSet) {
this.method = method;
this.annotationSet = annotationSet;
}
public int compareTo(Convertible<MethodIdItem> other) {
return method.compareTo(other.convert());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return compareTo((MethodAnnotation)o) == 0;
}
@Override
public int hashCode() {
return method.hashCode() + 31 * annotationSet.hashCode();
}
public MethodIdItem convert() {
return method;
}
}
public static class ParameterAnnotation implements Comparable<Convertible<MethodIdItem>>,
Convertible<MethodIdItem> {
public final MethodIdItem method;
public final AnnotationSetRefList annotationSet;
public ParameterAnnotation(MethodIdItem method, AnnotationSetRefList annotationSet) {
this.method = method;
this.annotationSet = annotationSet;
}
public int compareTo(Convertible<MethodIdItem> other) {
return method.compareTo(other.convert());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return compareTo((ParameterAnnotation)o) == 0;
}
@Override
public int hashCode() {
return method.hashCode() + 31 * annotationSet.hashCode();
}
public MethodIdItem convert() {
return method;
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/AnnotationDirectoryItem.java
|
Java
|
asf20
| 24,541
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
public enum AnnotationVisibility {
BUILD((byte)0, "build"),
RUNTIME((byte)1, "runtime"),
SYSTEM((byte)2, "system");
public final byte value;
public final String visibility;
private AnnotationVisibility(byte value, String visibility) {
this.value = value;
this.visibility = visibility;
}
public static AnnotationVisibility fromByte(byte value) {
switch (value) {
case (byte)0:
return BUILD;
case (byte)1:
return RUNTIME;
case (byte)2:
return SYSTEM;
default:
throw new RuntimeException("Invalid annotation visibility value: " + value);
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/AnnotationVisibility.java
|
Java
|
asf20
| 2,249
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.Input;
import java.util.Arrays;
public class OdexHeader {
/**
* the possible file format magic numbers, represented as the low-order bytes of a string.
*/
public static final byte[] MAGIC_35 = new byte[] {0x64, 0x65, 0x79, 0x0A, 0x30, 0x33, 0x35, 0x00}; //"dey\n035" + '\0';
public static final byte[] MAGIC_36 = new byte[] {0x64, 0x65, 0x79, 0x0A, 0x30, 0x33, 0x36, 0x00}; //"dey\n036" + '\0';
public final byte[] magic;
public final int dexOffset;
public final int dexLength;
public final int depsOffset;
public final int depsLength;
public final int auxOffset;
public final int auxLength;
public final int flags;
public final int version;
public OdexHeader(Input in) {
magic = in.readBytes(8);
if (Arrays.equals(MAGIC_35, magic)) {
version = 35;
} else if (Arrays.equals(MAGIC_36, magic)) {
version = 36;
} else {
throw new RuntimeException("The magic value is not one of the expected values");
}
dexOffset = in.readInt();
dexLength = in.readInt();
depsOffset = in.readInt();
depsLength = in.readInt();
auxOffset = in.readInt();
auxLength = in.readInt();
flags = in.readInt();
in.readInt(); //padding
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/OdexHeader.java
|
Java
|
asf20
| 2,874
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.io.IOException;
import java.io.Writer;
/**
* Constants of type <code>CONSTANT_Utf8_info</code>.
*/
public final class Utf8Utils {
/**
* Converts a string into its Java-style UTF-8 form. Java-style UTF-8
* differs from normal UTF-8 in the handling of character '\0' and
* surrogate pairs.
*
* @param string non-null; the string to convert
* @return non-null; the UTF-8 bytes for it
*/
public static byte[] stringToUtf8Bytes(String string) {
int len = string.length();
byte[] bytes = new byte[len * 3]; // Avoid having to reallocate.
int outAt = 0;
for (int i = 0; i < len; i++) {
char c = string.charAt(i);
if ((c != 0) && (c < 0x80)) {
bytes[outAt] = (byte) c;
outAt++;
} else if (c < 0x800) {
bytes[outAt] = (byte) (((c >> 6) & 0x1f) | 0xc0);
bytes[outAt + 1] = (byte) ((c & 0x3f) | 0x80);
outAt += 2;
} else {
bytes[outAt] = (byte) (((c >> 12) & 0x0f) | 0xe0);
bytes[outAt + 1] = (byte) (((c >> 6) & 0x3f) | 0x80);
bytes[outAt + 2] = (byte) ((c & 0x3f) | 0x80);
outAt += 3;
}
}
byte[] result = new byte[outAt];
System.arraycopy(bytes, 0, result, 0, outAt);
return result;
}
/**
* Converts an array of UTF-8 bytes into a string.
*
* @param buffer a buffer to hold the chars as they are read. Make sure the length of the array is at least 'length'
* @param bytes non-null; the bytes to convert
* @param start the start index of the utf8 string to convert
* @param length the length of the utf8 string to convert, not including any null-terminator that might be present
* @return non-null; the converted string
*/
public static String utf8BytesToString(char[] buffer, byte[] bytes, int start, int length) {
int outAt = 0;
for (int at = start; length > 0; /*at*/) {
int v0 = bytes[at] & 0xFF;
char out;
switch (v0 >> 4) {
case 0x00: case 0x01: case 0x02: case 0x03:
case 0x04: case 0x05: case 0x06: case 0x07: {
// 0XXXXXXX -- single-byte encoding
length--;
if (v0 == 0) {
// A single zero byte is illegal.
return throwBadUtf8(v0, at);
}
out = (char) v0;
at++;
break;
}
case 0x0c: case 0x0d: {
// 110XXXXX -- two-byte encoding
length -= 2;
if (length < 0) {
return throwBadUtf8(v0, at);
}
int v1 = bytes[at + 1] & 0xFF;
if ((v1 & 0xc0) != 0x80) {
return throwBadUtf8(v1, at + 1);
}
int value = ((v0 & 0x1f) << 6) | (v1 & 0x3f);
if ((value != 0) && (value < 0x80)) {
/*
* This should have been represented with
* one-byte encoding.
*/
return throwBadUtf8(v1, at + 1);
}
out = (char) value;
at += 2;
break;
}
case 0x0e: {
// 1110XXXX -- three-byte encoding
length -= 3;
if (length < 0) {
return throwBadUtf8(v0, at);
}
int v1 = bytes[at + 1] & 0xFF;
if ((v1 & 0xc0) != 0x80) {
return throwBadUtf8(v1, at + 1);
}
int v2 = bytes[at + 2] & 0xFF;
if ((v2 & 0xc0) != 0x80) {
return throwBadUtf8(v2, at + 2);
}
int value = ((v0 & 0x0f) << 12) | ((v1 & 0x3f) << 6) |
(v2 & 0x3f);
if (value < 0x800) {
/*
* This should have been represented with one- or
* two-byte encoding.
*/
return throwBadUtf8(v2, at + 2);
}
out = (char) value;
at += 3;
break;
}
default: {
// 10XXXXXX, 1111XXXX -- illegal
return throwBadUtf8(v0, at);
}
}
buffer[outAt] = out;
outAt++;
}
return new String(buffer, 0, outAt);
}
/**
* Helper for {@link #utf8BytesToString}, which throws the right
* exception for a bogus utf-8 byte.
*
* @param value the byte value
* @param offset the file offset
* @return never
* @throws IllegalArgumentException always thrown
*/
private static String throwBadUtf8(int value, int offset) {
throw new IllegalArgumentException("bad utf-8 byte " + Hex.u1(value) +
" at offset " + Hex.u4(offset));
}
public static void writeEscapedChar(Writer writer, char c) throws IOException {
if ((c >= ' ') && (c < 0x7f)) {
if ((c == '\'') || (c == '\"') || (c == '\\')) {
writer.write('\\');
}
writer.write(c);
return;
} else if (c <= 0x7f) {
switch (c) {
case '\n': writer.write("\\n"); return;
case '\r': writer.write("\\r"); return;
case '\t': writer.write("\\t"); return;
}
}
writer.write("\\u");
writer.write(Character.forDigit(c >> 12, 16));
writer.write(Character.forDigit((c >> 8) & 0x0f, 16));
writer.write(Character.forDigit((c >> 4) & 0x0f, 16));
writer.write(Character.forDigit(c & 0x0f, 16));
}
public static void writeEscapedString(Writer writer, String value) throws IOException {
for (int i = 0; i < value.length(); i++) {
char c = value.charAt(i);
if ((c >= ' ') && (c < 0x7f)) {
if ((c == '\'') || (c == '\"') || (c == '\\')) {
writer.write('\\');
}
writer.write(c);
continue;
} else if (c <= 0x7f) {
switch (c) {
case '\n': writer.write("\\n"); continue;
case '\r': writer.write("\\r"); continue;
case '\t': writer.write("\\t"); continue;
}
}
writer.write("\\u");
writer.write(Character.forDigit(c >> 12, 16));
writer.write(Character.forDigit((c >> 8) & 0x0f, 16));
writer.write(Character.forDigit((c >> 4) & 0x0f, 16));
writer.write(Character.forDigit(c & 0x0f, 16));
}
}
public static String escapeString(String value) {
int len = value.length();
StringBuilder sb = new StringBuilder(len * 3 / 2);
for (int i = 0; i < len; i++) {
char c = value.charAt(i);
if ((c >= ' ') && (c < 0x7f)) {
if ((c == '\'') || (c == '\"') || (c == '\\')) {
sb.append('\\');
}
sb.append(c);
continue;
} else if (c <= 0x7f) {
switch (c) {
case '\n': sb.append("\\n"); continue;
case '\r': sb.append("\\r"); continue;
case '\t': sb.append("\\t"); continue;
}
}
sb.append("\\u");
sb.append(Character.forDigit(c >> 12, 16));
sb.append(Character.forDigit((c >> 8) & 0x0f, 16));
sb.append(Character.forDigit((c >> 4) & 0x0f, 16));
sb.append(Character.forDigit(c & 0x0f, 16));
}
return sb.toString();
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/Utf8Utils.java
|
Java
|
asf20
| 9,139
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.util.ArrayList;
/**
* Implementation of {@link AnnotatedOutput} which stores the written data
* into a <code>byte[]</code>.
*
* <p><b>Note:</b> As per the {@link Output} interface, multi-byte
* writes all use little-endian order.</p>
*/
public final class ByteArrayOutput implements Output
{
/** default size for stretchy instances */
private static final int DEFAULT_SIZE = 1000;
/**
* whether the instance is stretchy, that is, whether its array
* may be resized to increase capacity
*/
private final boolean stretchy;
/** non-null; the data itself */
private byte[] data;
/** >= 0; current output cursor */
private int cursor;
/** whether annotations are to be verbose */
private boolean verbose;
/**
* null-ok; list of annotations, or <code>null</code> if this instance
* isn't keeping them
*/
private ArrayList<Annotation> annotations;
/** >= 40 (if used); the desired maximum annotation width */
private int annotationWidth;
/**
* >= 8 (if used); the number of bytes of hex output to use
* in annotations
*/
private int hexCols;
/**
* Constructs an instance with a fixed maximum size. Note that the
* given array is the only one that will be used to store data. In
* particular, no reallocation will occur in order to expand the
* capacity of the resulting instance. Also, the constructed
* instance does not keep annotations by default.
*
* @param data non-null; data array to use for output
*/
public ByteArrayOutput(byte[] data) {
this(data, false);
}
/**
* Constructs a "stretchy" instance. The underlying array may be
* reallocated. The constructed instance does not keep annotations
* by default.
*/
public ByteArrayOutput() {
this(new byte[DEFAULT_SIZE], true);
}
/**
* Internal constructor.
*
* @param data non-null; data array to use for output
* @param stretchy whether the instance is to be stretchy
*/
private ByteArrayOutput(byte[] data, boolean stretchy) {
if (data == null) {
throw new NullPointerException("data == null");
}
this.stretchy = stretchy;
this.data = data;
this.cursor = 0;
this.verbose = false;
this.annotations = null;
this.annotationWidth = 0;
this.hexCols = 0;
}
/**
* Gets the underlying <code>byte[]</code> of this instance, which
* may be larger than the number of bytes written
*
* @see #toByteArray
*
* @return non-null; the <code>byte[]</code>
*/
public byte[] getArray() {
return data;
}
/**
* Constructs and returns a new <code>byte[]</code> that contains
* the written contents exactly (that is, with no extra unwritten
* bytes at the end).
*
* @see #getArray
*
* @return non-null; an appropriately-constructed array
*/
public byte[] toByteArray() {
byte[] result = new byte[cursor];
System.arraycopy(data, 0, result, 0, cursor);
return result;
}
/** {@inheritDoc} */
public int getCursor() {
return cursor;
}
/** {@inheritDoc} */
public void assertCursor(int expectedCursor) {
if (cursor != expectedCursor) {
throw new ExceptionWithContext("expected cursor " +
expectedCursor + "; actual value: " + cursor);
}
}
/** {@inheritDoc} */
public void writeByte(int value) {
int writeAt = cursor;
int end = writeAt + 1;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
data[writeAt] = (byte) value;
cursor = end;
}
/** {@inheritDoc} */
public void writeShort(int value) {
int writeAt = cursor;
int end = writeAt + 2;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
data[writeAt] = (byte) value;
data[writeAt + 1] = (byte) (value >> 8);
cursor = end;
}
/** {@inheritDoc} */
public void writeInt(int value) {
int writeAt = cursor;
int end = writeAt + 4;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
data[writeAt] = (byte) value;
data[writeAt + 1] = (byte) (value >> 8);
data[writeAt + 2] = (byte) (value >> 16);
data[writeAt + 3] = (byte) (value >> 24);
cursor = end;
}
/** {@inheritDoc} */
public void writeLong(long value) {
int writeAt = cursor;
int end = writeAt + 8;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
int half = (int) value;
data[writeAt] = (byte) half;
data[writeAt + 1] = (byte) (half >> 8);
data[writeAt + 2] = (byte) (half >> 16);
data[writeAt + 3] = (byte) (half >> 24);
half = (int) (value >> 32);
data[writeAt + 4] = (byte) half;
data[writeAt + 5] = (byte) (half >> 8);
data[writeAt + 6] = (byte) (half >> 16);
data[writeAt + 7] = (byte) (half >> 24);
cursor = end;
}
/** {@inheritDoc} */
public int writeUnsignedLeb128(int value) {
int remaining = value >>> 7;
int count = 0;
while (remaining != 0) {
writeByte((value & 0x7f) | 0x80);
value = remaining;
remaining >>>= 7;
count++;
}
writeByte(value & 0x7f);
return count + 1;
}
/** {@inheritDoc} */
public int writeSignedLeb128(int value) {
int remaining = value >> 7;
int count = 0;
boolean hasMore = true;
int end = ((value & Integer.MIN_VALUE) == 0) ? 0 : -1;
while (hasMore) {
hasMore = (remaining != end)
|| ((remaining & 1) != ((value >> 6) & 1));
writeByte((value & 0x7f) | (hasMore ? 0x80 : 0));
value = remaining;
remaining >>= 7;
count++;
}
return count;
}
/** {@inheritDoc} */
public void write(ByteArray bytes) {
int blen = bytes.size();
int writeAt = cursor;
int end = writeAt + blen;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
bytes.getBytes(data, writeAt);
cursor = end;
}
/** {@inheritDoc} */
public void write(byte[] bytes, int offset, int length) {
int writeAt = cursor;
int end = writeAt + length;
int bytesEnd = offset + length;
// twos-complement math trick: ((x < 0) || (y < 0)) <=> ((x|y) < 0)
if (((offset | length | end) < 0) || (bytesEnd > bytes.length)) {
throw new IndexOutOfBoundsException("bytes.length " +
bytes.length + "; " +
offset + "..!" + end);
}
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
System.arraycopy(bytes, offset, data, writeAt, length);
cursor = end;
}
/** {@inheritDoc} */
public void write(byte[] bytes) {
write(bytes, 0, bytes.length);
}
/** {@inheritDoc} */
public void writeZeroes(int count) {
if (count < 0) {
throw new IllegalArgumentException("count < 0");
}
int end = cursor + count;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
/*
* There is no need to actually write zeroes, since the array is
* already preinitialized with zeroes.
*/
cursor = end;
}
/** {@inheritDoc} */
public void alignTo(int alignment) {
int end = AlignmentUtils.alignOffset(cursor, alignment);
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
cursor = end;
}
/** {@inheritDoc} */
public boolean annotates() {
return (annotations != null);
}
/** {@inheritDoc} */
public boolean isVerbose() {
return verbose;
}
/** {@inheritDoc} */
public void annotate(String msg) {
if (annotations == null) {
return;
}
endAnnotation();
annotations.add(new Annotation(cursor, msg));
}
/** {@inheritDoc} */
public void annotate(int amt, String msg) {
if (annotations == null) {
return;
}
endAnnotation();
int asz = annotations.size();
int lastEnd = (asz == 0) ? 0 : annotations.get(asz - 1).getEnd();
int startAt;
if (lastEnd <= cursor) {
startAt = cursor;
} else {
startAt = lastEnd;
}
annotations.add(new Annotation(startAt, startAt + amt, msg));
}
/** {@inheritDoc} */
public void endAnnotation() {
if (annotations == null) {
return;
}
int sz = annotations.size();
if (sz != 0) {
annotations.get(sz - 1).setEndIfUnset(cursor);
}
}
/** {@inheritDoc} */
public int getAnnotationWidth() {
int leftWidth = 8 + (hexCols * 2) + (hexCols / 2);
return annotationWidth - leftWidth;
}
/**
* Indicates that this instance should keep annotations. This method may
* be called only once per instance, and only before any data has been
* written to the it.
*
* @param annotationWidth >= 40; the desired maximum annotation width
* @param verbose whether or not to indicate verbose annotations
*/
public void enableAnnotations(int annotationWidth, boolean verbose) {
if ((annotations != null) || (cursor != 0)) {
throw new RuntimeException("cannot enable annotations");
}
if (annotationWidth < 40) {
throw new IllegalArgumentException("annotationWidth < 40");
}
int hexCols = (((annotationWidth - 7) / 15) + 1) & ~1;
if (hexCols < 6) {
hexCols = 6;
} else if (hexCols > 10) {
hexCols = 10;
}
this.annotations = new ArrayList<Annotation>(1000);
this.annotationWidth = annotationWidth;
this.hexCols = hexCols;
this.verbose = verbose;
}
/**
* Finishes up annotation processing. This closes off any open
* annotations and removes annotations that don't refer to written
* data.
*/
public void finishAnnotating() {
// Close off the final annotation, if any.
endAnnotation();
// Remove annotations that refer to unwritten data.
if (annotations != null) {
int asz = annotations.size();
while (asz > 0) {
Annotation last = annotations.get(asz - 1);
if (last.getStart() > cursor) {
annotations.remove(asz - 1);
asz--;
} else if (last.getEnd() > cursor) {
last.setEnd(cursor);
break;
} else {
break;
}
}
}
}
/**
* Throws the excpetion for when an attempt is made to write past the
* end of the instance.
*/
private static void throwBounds() {
throw new IndexOutOfBoundsException("attempt to write past the end");
}
/**
* Reallocates the underlying array if necessary. Calls to this method
* should be guarded by a test of {@link #stretchy}.
*
* @param desiredSize >= 0; the desired minimum total size of the array
*/
private void ensureCapacity(int desiredSize) {
if (data.length < desiredSize) {
byte[] newData = new byte[desiredSize * 2 + 1000];
System.arraycopy(data, 0, newData, 0, cursor);
data = newData;
}
}
/**
* Annotation on output.
*/
private static class Annotation {
/** >= 0; start of annotated range (inclusive) */
private final int start;
/**
* >= 0; end of annotated range (exclusive);
* <code>Integer.MAX_VALUE</code> if unclosed
*/
private int end;
/** non-null; annotation text */
private final String text;
/**
* Constructs an instance.
*
* @param start >= 0; start of annotated range
* @param end >= start; end of annotated range (exclusive) or
* <code>Integer.MAX_VALUE</code> if unclosed
* @param text non-null; annotation text
*/
public Annotation(int start, int end, String text) {
this.start = start;
this.end = end;
this.text = text;
}
/**
* Constructs an instance. It is initally unclosed.
*
* @param start >= 0; start of annotated range
* @param text non-null; annotation text
*/
public Annotation(int start, String text) {
this(start, Integer.MAX_VALUE, text);
}
/**
* Sets the end as given, but only if the instance is unclosed;
* otherwise, do nothing.
*
* @param end >= start; the end
*/
public void setEndIfUnset(int end) {
if (this.end == Integer.MAX_VALUE) {
this.end = end;
}
}
/**
* Sets the end as given.
*
* @param end >= start; the end
*/
public void setEnd(int end) {
this.end = end;
}
/**
* Gets the start.
*
* @return the start
*/
public int getStart() {
return start;
}
/**
* Gets the end.
*
* @return the end
*/
public int getEnd() {
return end;
}
/**
* Gets the text.
*
* @return non-null; the text
*/
public String getText() {
return text;
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/ByteArrayOutput.java
|
Java
|
asf20
| 15,638
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* File I/O utilities.
*/
public final class FileUtils {
/**
* This class is uninstantiable.
*/
private FileUtils() {
// This space intentionally left blank.
}
/**
* Reads the named file, translating {@link IOException} to a
* {@link RuntimeException} of some sort.
*
* @param fileName non-null; name of the file to read
* @return non-null; contents of the file
*/
public static byte[] readFile(String fileName)
throws IOException {
File file = new File(fileName);
return readFile(file);
}
/**
* Reads the given file, translating {@link IOException} to a
* {@link RuntimeException} of some sort.
*
* @param file non-null; the file to read
* @return non-null; contents of the file
*/
public static byte[] readFile(File file)
throws IOException {
return readFile(file, 0, -1);
}
/**
* Reads the specified block from the given file, translating
* {@link IOException} to a {@link RuntimeException} of some sort.
*
* @param file non-null; the file to read
* @param offset the offset to begin reading
* @param length the number of bytes to read, or -1 to read to the
* end of the file
* @return non-null; contents of the file
*/
public static byte[] readFile(File file, int offset, int length)
throws IOException {
if (!file.exists()) {
throw new RuntimeException(file + ": file not found");
}
if (!file.isFile()) {
throw new RuntimeException(file + ": not a file");
}
if (!file.canRead()) {
throw new RuntimeException(file + ": file not readable");
}
long longLength = file.length();
int fileLength = (int) longLength;
if (fileLength != longLength) {
throw new RuntimeException(file + ": file too long");
}
if (length == -1) {
length = fileLength - offset;
}
if (offset + length > fileLength) {
throw new RuntimeException(file + ": file too short");
}
FileInputStream in = new FileInputStream(file);
int at = offset;
while(at > 0) {
long amt = in.skip(at);
if (amt == -1) {
throw new RuntimeException(file + ": unexpected EOF");
}
at -= amt;
}
byte[] result = readStream(in, length);
in.close();
return result;
}
public static byte[] readStream(InputStream in, int length)
throws IOException {
byte[] result = new byte[length];
int at=0;
while (length > 0) {
int amt = in.read(result, at, length);
if (amt == -1) {
throw new RuntimeException("unexpected EOF");
}
at += amt;
length -= amt;
}
return result;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/FileUtils.java
|
Java
|
asf20
| 3,971
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.io.*;
/**
* Class that takes a combined output destination and provides two
* output writers, one of which ends up writing to the left column and
* one which goes on the right.
*/
public final class TwoColumnOutput {
/** non-null; underlying writer for final output */
private final Writer out;
/** > 0; the left column width */
private final int leftWidth;
/** non-null; pending left column output */
private final StringBuffer leftBuf;
/** non-null; pending right column output */
private final StringBuffer rightBuf;
/** non-null; left column writer */
private final IndentingWriter leftColumn;
/** non-null; right column writer */
private final IndentingWriter rightColumn;
/**
* Turns the given two strings (with widths) and spacer into a formatted
* two-column string.
*
* @param s1 non-null; first string
* @param width1 > 0; width of the first column
* @param spacer non-null; spacer string
* @param s2 non-null; second string
* @param width2 > 0; width of the second column
* @return non-null; an appropriately-formatted string
*/
public static String toString(String s1, int width1, String spacer,
String s2, int width2) {
int len1 = s1.length();
int len2 = s2.length();
StringWriter sw = new StringWriter((len1 + len2) * 3);
TwoColumnOutput twoOut =
new TwoColumnOutput(sw, width1, width2, spacer);
try {
twoOut.getLeft().write(s1);
twoOut.getRight().write(s2);
} catch (IOException ex) {
throw new RuntimeException("shouldn't happen", ex);
}
twoOut.flush();
return sw.toString();
}
/**
* Constructs an instance.
*
* @param out non-null; writer to send final output to
* @param leftWidth > 0; width of the left column, in characters
* @param rightWidth > 0; width of the right column, in characters
* @param spacer non-null; spacer string to sit between the two columns
*/
public TwoColumnOutput(Writer out, int leftWidth, int rightWidth,
String spacer) {
if (out == null) {
throw new NullPointerException("out == null");
}
if (leftWidth < 1) {
throw new IllegalArgumentException("leftWidth < 1");
}
if (rightWidth < 1) {
throw new IllegalArgumentException("rightWidth < 1");
}
if (spacer == null) {
throw new NullPointerException("spacer == null");
}
StringWriter leftWriter = new StringWriter(1000);
StringWriter rightWriter = new StringWriter(1000);
this.out = out;
this.leftWidth = leftWidth;
this.leftBuf = leftWriter.getBuffer();
this.rightBuf = rightWriter.getBuffer();
this.leftColumn = new IndentingWriter(leftWriter, leftWidth);
this.rightColumn =
new IndentingWriter(rightWriter, rightWidth, spacer);
}
/**
* Constructs an instance.
*
* @param out non-null; stream to send final output to
* @param leftWidth >= 1; width of the left column, in characters
* @param rightWidth >= 1; width of the right column, in characters
* @param spacer non-null; spacer string to sit between the two columns
*/
public TwoColumnOutput(OutputStream out, int leftWidth, int rightWidth,
String spacer) {
this(new OutputStreamWriter(out), leftWidth, rightWidth, spacer);
}
/**
* Gets the writer to use to write to the left column.
*
* @return non-null; the left column writer
*/
public Writer getLeft() {
return leftColumn;
}
/**
* Gets the writer to use to write to the right column.
*
* @return non-null; the right column writer
*/
public Writer getRight() {
return rightColumn;
}
/**
* Flushes the output. If there are more lines of pending output in one
* column, then the other column will get filled with blank lines.
*/
public void flush() {
try {
appendNewlineIfNecessary(leftBuf, leftColumn);
appendNewlineIfNecessary(rightBuf, rightColumn);
outputFullLines();
flushLeft();
flushRight();
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
/**
* Outputs to the final destination as many full line pairs as
* there are in the pending output, removing those lines from
* their respective buffers. This method terminates when at
* least one of the two column buffers is empty.
*/
private void outputFullLines() throws IOException {
for (;;) {
int leftLen = leftBuf.indexOf("\n");
if (leftLen < 0) {
return;
}
int rightLen = rightBuf.indexOf("\n");
if (rightLen < 0) {
return;
}
if (leftLen != 0) {
out.write(leftBuf.substring(0, leftLen));
}
if (rightLen != 0) {
writeSpaces(out, leftWidth - leftLen);
out.write(rightBuf.substring(0, rightLen));
}
out.write('\n');
leftBuf.delete(0, leftLen + 1);
rightBuf.delete(0, rightLen + 1);
}
}
/**
* Flushes the left column buffer, printing it and clearing the buffer.
* If the buffer is already empty, this does nothing.
*/
private void flushLeft() throws IOException {
appendNewlineIfNecessary(leftBuf, leftColumn);
while (leftBuf.length() != 0) {
rightColumn.write('\n');
outputFullLines();
}
}
/**
* Flushes the right column buffer, printing it and clearing the buffer.
* If the buffer is already empty, this does nothing.
*/
private void flushRight() throws IOException {
appendNewlineIfNecessary(rightBuf, rightColumn);
while (rightBuf.length() != 0) {
leftColumn.write('\n');
outputFullLines();
}
}
/**
* Appends a newline to the given buffer via the given writer, but
* only if it isn't empty and doesn't already end with one.
*
* @param buf non-null; the buffer in question
* @param out non-null; the writer to use
*/
private static void appendNewlineIfNecessary(StringBuffer buf,
Writer out)
throws IOException {
int len = buf.length();
if ((len != 0) && (buf.charAt(len - 1) != '\n')) {
out.write('\n');
}
}
/**
* Writes the given number of spaces to the given writer.
*
* @param out non-null; where to write
* @param amt >= 0; the number of spaces to write
*/
private static void writeSpaces(Writer out, int amt) throws IOException {
while (amt > 0) {
out.write(' ');
amt--;
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/TwoColumnOutput.java
|
Java
|
asf20
| 8,055
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
import java.util.HashMap;
public enum AccessFlags
{
PUBLIC(0x1, "public", true, true, true),
PRIVATE(0x2, "private", true, true, true),
PROTECTED(0x4, "protected", true, true, true),
STATIC(0x8, "static", true, true, true),
FINAL(0x10, "final", true, true, true),
SYNCHRONIZED(0x20, "synchronized", false, true, false),
VOLATILE(0x40, "volatile", false, false, true),
BRIDGE(0x40, "bridge", false, true, false),
TRANSIENT(0x80, "transient", false, false, true),
VARARGS(0x80, "varargs", false, true, false),
NATIVE(0x100, "native", false, true, false),
INTERFACE(0x200, "interface", true, false, false),
ABSTRACT(0x400, "abstract", true, true, false),
STRICTFP(0x800, "strictfp", false, true, false),
SYNTHETIC(0x1000, "synthetic", true, true, true),
ANNOTATION(0x2000, "annotation", true, false, false),
ENUM(0x4000, "enum", true, false, true),
CONSTRUCTOR(0x10000, "constructor", false, true, false),
DECLARED_SYNCHRONIZED(0x20000, "declared-synchronized", false, true, false);
private int value;
private String accessFlagName;
private boolean validForClass;
private boolean validForMethod;
private boolean validForField;
//cache the array of all AccessFlags, because .values() allocates a new array for every call
private final static AccessFlags[] allFlags;
private static HashMap<String, AccessFlags> accessFlagsByName;
static {
allFlags = AccessFlags.values();
accessFlagsByName = new HashMap<String, AccessFlags>();
for (AccessFlags accessFlag: allFlags) {
accessFlagsByName.put(accessFlag.accessFlagName, accessFlag);
}
}
private AccessFlags(int value, String accessFlagName, boolean validForClass, boolean validForMethod,
boolean validForField) {
this.value = value;
this.accessFlagName = accessFlagName;
this.validForClass = validForClass;
this.validForMethod = validForMethod;
this.validForField = validForField;
}
public static AccessFlags[] getAccessFlagsForClass(int accessFlagValue) {
int size = 0;
for (AccessFlags accessFlag: allFlags) {
if (accessFlag.validForClass && (accessFlagValue & accessFlag.value) != 0) {
size++;
}
}
AccessFlags[] accessFlags = new AccessFlags[size];
int accessFlagsPosition = 0;
for (AccessFlags accessFlag: allFlags) {
if (accessFlag.validForClass && (accessFlagValue & accessFlag.value) != 0) {
accessFlags[accessFlagsPosition++] = accessFlag;
}
}
return accessFlags;
}
private static String formatAccessFlags(AccessFlags[] accessFlags) {
int size = 0;
for (AccessFlags accessFlag: accessFlags) {
size += accessFlag.toString().length() + 1;
}
StringBuilder sb = new StringBuilder(size);
for (AccessFlags accessFlag: accessFlags) {
sb.append(accessFlag.toString());
sb.append(" ");
}
if (accessFlags.length > 0) {
sb.delete(sb.length() - 1, sb.length());
}
return sb.toString();
}
public static String formatAccessFlagsForClass(int accessFlagValue) {
return formatAccessFlags(getAccessFlagsForClass(accessFlagValue));
}
public static AccessFlags[] getAccessFlagsForMethod(int accessFlagValue) {
int size = 0;
for (AccessFlags accessFlag: allFlags) {
if (accessFlag.validForMethod && (accessFlagValue & accessFlag.value) != 0) {
size++;
}
}
AccessFlags[] accessFlags = new AccessFlags[size];
int accessFlagsPosition = 0;
for (AccessFlags accessFlag: allFlags) {
if (accessFlag.validForMethod && (accessFlagValue & accessFlag.value) != 0) {
accessFlags[accessFlagsPosition++] = accessFlag;
}
}
return accessFlags;
}
public static String formatAccessFlagsForMethod(int accessFlagValue) {
return formatAccessFlags(getAccessFlagsForMethod(accessFlagValue));
}
public static AccessFlags[] getAccessFlagsForField(int accessFlagValue) {
int size = 0;
for (AccessFlags accessFlag: allFlags) {
if (accessFlag.validForField && (accessFlagValue & accessFlag.value) != 0) {
size++;
}
}
AccessFlags[] accessFlags = new AccessFlags[size];
int accessFlagsPosition = 0;
for (AccessFlags accessFlag: allFlags) {
if (accessFlag.validForField && (accessFlagValue & accessFlag.value) != 0) {
accessFlags[accessFlagsPosition++] = accessFlag;
}
}
return accessFlags;
}
public static String formatAccessFlagsForField(int accessFlagValue) {
return formatAccessFlags(getAccessFlagsForField(accessFlagValue));
}
public static AccessFlags getAccessFlag(String accessFlag) {
return accessFlagsByName.get(accessFlag);
}
public int getValue() {
return value;
}
public String toString() {
return accessFlagName;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/AccessFlags.java
|
Java
|
asf20
| 6,794
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
/**
* Implementation of {@link AnnotatedOutput} which stores the written data
* into a <code>byte[]</code>.
*
* <p><b>Note:</b> As per the {@link Output} interface, multi-byte
* writes all use little-endian order.</p>
*/
public final class ByteArrayAnnotatedOutput
implements AnnotatedOutput {
/** default size for stretchy instances */
private static final int DEFAULT_SIZE = 1000;
/**
* whether the instance is stretchy, that is, whether its array
* may be resized to increase capacity
*/
private final boolean stretchy;
/** non-null; the data itself */
private byte[] data;
/** >= 0; current output cursor */
private int cursor;
/** whether annotations are to be verbose */
private boolean verbose;
/**
* null-ok; list of annotations, or <code>null</code> if this instance
* isn't keeping them
*/
private ArrayList<Annotation> annotations;
/** >= 40 (if used); the desired maximum annotation width */
private int annotationWidth;
/**
* >= 8 (if used); the number of bytes of hex output to use
* in annotations
*/
private int hexCols;
private int currentIndent = 0;
private int indentAmount = 2;
/**
* Constructs an instance with a fixed maximum size. Note that the
* given array is the only one that will be used to store data. In
* particular, no reallocation will occur in order to expand the
* capacity of the resulting instance. Also, the constructed
* instance does not keep annotations by default.
*
* @param data non-null; data array to use for output
*/
public ByteArrayAnnotatedOutput(byte[] data) {
this(data, false);
}
/**
* Constructs a "stretchy" instance. The underlying array may be
* reallocated. The constructed instance does not keep annotations
* by default.
*/
public ByteArrayAnnotatedOutput() {
this(new byte[DEFAULT_SIZE], true);
}
/**
* Internal constructor.
*
* @param data non-null; data array to use for output
* @param stretchy whether the instance is to be stretchy
*/
private ByteArrayAnnotatedOutput(byte[] data, boolean stretchy) {
if (data == null) {
throw new NullPointerException("data == null");
}
this.stretchy = stretchy;
this.data = data;
this.cursor = 0;
this.verbose = false;
this.annotations = null;
this.annotationWidth = 0;
this.hexCols = 0;
}
/**
* Gets the underlying <code>byte[]</code> of this instance, which
* may be larger than the number of bytes written
*
* @see #toByteArray
*
* @return non-null; the <code>byte[]</code>
*/
public byte[] getArray() {
return data;
}
/**
* Constructs and returns a new <code>byte[]</code> that contains
* the written contents exactly (that is, with no extra unwritten
* bytes at the end).
*
* @see #getArray
*
* @return non-null; an appropriately-constructed array
*/
public byte[] toByteArray() {
byte[] result = new byte[cursor];
System.arraycopy(data, 0, result, 0, cursor);
return result;
}
/** {@inheritDoc} */
public int getCursor() {
return cursor;
}
/** {@inheritDoc} */
public void assertCursor(int expectedCursor) {
if (cursor != expectedCursor) {
throw new ExceptionWithContext("expected cursor " +
expectedCursor + "; actual value: " + cursor);
}
}
/** {@inheritDoc} */
public void writeByte(int value) {
int writeAt = cursor;
int end = writeAt + 1;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
data[writeAt] = (byte) value;
cursor = end;
}
/** {@inheritDoc} */
public void writeShort(int value) {
int writeAt = cursor;
int end = writeAt + 2;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
data[writeAt] = (byte) value;
data[writeAt + 1] = (byte) (value >> 8);
cursor = end;
}
/** {@inheritDoc} */
public void writeInt(int value) {
int writeAt = cursor;
int end = writeAt + 4;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
data[writeAt] = (byte) value;
data[writeAt + 1] = (byte) (value >> 8);
data[writeAt + 2] = (byte) (value >> 16);
data[writeAt + 3] = (byte) (value >> 24);
cursor = end;
}
/** {@inheritDoc} */
public void writeLong(long value) {
int writeAt = cursor;
int end = writeAt + 8;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
int half = (int) value;
data[writeAt] = (byte) half;
data[writeAt + 1] = (byte) (half >> 8);
data[writeAt + 2] = (byte) (half >> 16);
data[writeAt + 3] = (byte) (half >> 24);
half = (int) (value >> 32);
data[writeAt + 4] = (byte) half;
data[writeAt + 5] = (byte) (half >> 8);
data[writeAt + 6] = (byte) (half >> 16);
data[writeAt + 7] = (byte) (half >> 24);
cursor = end;
}
/** {@inheritDoc} */
public int writeUnsignedLeb128(int value) {
long remaining = (value & 0xFFFFFFFFL) >> 7;
long lValue = value;
int count = 0;
while (remaining != 0) {
writeByte((int)(lValue & 0x7f) | 0x80);
lValue = remaining;
remaining >>= 7;
count++;
}
writeByte((int)(lValue & 0x7f));
return count + 1;
}
/** {@inheritDoc} */
public int writeSignedLeb128(int value) {
int remaining = value >> 7;
int count = 0;
boolean hasMore = true;
int end = ((value & Integer.MIN_VALUE) == 0) ? 0 : -1;
while (hasMore) {
hasMore = (remaining != end)
|| ((remaining & 1) != ((value >> 6) & 1));
writeByte((value & 0x7f) | (hasMore ? 0x80 : 0));
value = remaining;
remaining >>= 7;
count++;
}
return count;
}
/** {@inheritDoc} */
public void write(ByteArray bytes) {
int blen = bytes.size();
int writeAt = cursor;
int end = writeAt + blen;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
bytes.getBytes(data, writeAt);
cursor = end;
}
/** {@inheritDoc} */
public void write(byte[] bytes, int offset, int length) {
int writeAt = cursor;
int end = writeAt + length;
int bytesEnd = offset + length;
// twos-complement math trick: ((x < 0) || (y < 0)) <=> ((x|y) < 0)
if (((offset | length | end) < 0) || (bytesEnd > bytes.length)) {
throw new IndexOutOfBoundsException("bytes.length " +
bytes.length + "; " +
offset + "..!" + end);
}
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
System.arraycopy(bytes, offset, data, writeAt, length);
cursor = end;
}
/** {@inheritDoc} */
public void write(byte[] bytes) {
write(bytes, 0, bytes.length);
}
/** {@inheritDoc} */
public void writeZeroes(int count) {
if (count < 0) {
throw new IllegalArgumentException("count < 0");
}
int end = cursor + count;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
/*
* There is no need to actually write zeroes, since the array is
* already preinitialized with zeroes.
*/
cursor = end;
}
/** {@inheritDoc} */
public void alignTo(int alignment) {
int mask = alignment - 1;
if ((alignment < 0) || ((mask & alignment) != 0)) {
throw new IllegalArgumentException("bogus alignment");
}
int end = (cursor + mask) & ~mask;
if (stretchy) {
ensureCapacity(end);
} else if (end > data.length) {
throwBounds();
return;
}
/*
* There is no need to actually write zeroes, since the array is
* already preinitialized with zeroes.
*/
cursor = end;
}
/** {@inheritDoc} */
public boolean annotates() {
return (annotations != null);
}
/** {@inheritDoc} */
public boolean isVerbose() {
return verbose;
}
/** {@inheritDoc} */
public void annotate(String msg) {
if (annotations == null) {
return;
}
endAnnotation();
annotations.add(new Annotation(cursor, msg, currentIndent));
}
public void indent() {
currentIndent++;
}
public void deindent() {
currentIndent--;
if (currentIndent < 0) {
currentIndent = 0;
}
}
public void setIndentAmount(int indentAmount) {
this.indentAmount = indentAmount;
}
/** {@inheritDoc} */
public void annotate(int amt, String msg) {
if (annotations == null) {
return;
}
endAnnotation();
int asz = annotations.size();
int lastEnd = (asz == 0) ? 0 : annotations.get(asz - 1).getEnd();
int startAt;
if (lastEnd <= cursor) {
startAt = cursor;
} else {
startAt = lastEnd;
}
annotations.add(new Annotation(startAt, startAt + amt, msg, currentIndent));
}
/** {@inheritDoc} */
public void endAnnotation() {
if (annotations == null) {
return;
}
int sz = annotations.size();
if (sz != 0) {
annotations.get(sz - 1).setEndIfUnset(cursor);
}
}
/** {@inheritDoc} */
public int getAnnotationWidth() {
int leftWidth = 8 + (hexCols * 2) + (hexCols / 2);
return annotationWidth - leftWidth;
}
/**
* Indicates that this instance should keep annotations. This method may
* be called only once per instance, and only before any data has been
* written to the it.
*
* @param annotationWidth >= 40; the desired maximum annotation width
* @param verbose whether or not to indicate verbose annotations
*/
public void enableAnnotations(int annotationWidth, boolean verbose) {
if ((annotations != null) || (cursor != 0)) {
throw new RuntimeException("cannot enable annotations");
}
if (annotationWidth < 40) {
throw new IllegalArgumentException("annotationWidth < 40");
}
int hexCols = (((annotationWidth - 7) / 15) + 1) & ~1;
if (hexCols < 6) {
hexCols = 6;
} else if (hexCols > 10) {
hexCols = 10;
}
this.annotations = new ArrayList<Annotation>(1000);
this.annotationWidth = annotationWidth;
this.hexCols = hexCols;
this.verbose = verbose;
}
/**
* Finishes up annotation processing. This closes off any open
* annotations and removes annotations that don't refer to written
* data.
*/
public void finishAnnotating() {
// Close off the final annotation, if any.
endAnnotation();
// Remove annotations that refer to unwritten data.
if (annotations != null) {
int asz = annotations.size();
while (asz > 0) {
Annotation last = annotations.get(asz - 1);
if (last.getStart() > cursor) {
annotations.remove(asz - 1);
asz--;
} else if (last.getEnd() > cursor) {
last.setEnd(cursor);
break;
} else {
break;
}
}
}
}
/**
* Writes the annotated content of this instance to the given writer.
*
* @param out non-null; where to write to
*/
public void writeAnnotationsTo(Writer out) throws IOException {
int width2 = getAnnotationWidth();
int width1 = annotationWidth - width2 - 1;
StringBuilder padding = new StringBuilder();
for (int i=0; i<1000; i++) {
padding.append(' ');
}
TwoColumnOutput twoc = new TwoColumnOutput(out, width1, width2, "|");
Writer left = twoc.getLeft();
Writer right = twoc.getRight();
int leftAt = 0; // left-hand byte output cursor
int rightAt = 0; // right-hand annotation index
int rightSz = annotations.size();
while ((leftAt < cursor) && (rightAt < rightSz)) {
Annotation a = annotations.get(rightAt);
int start = a.getStart();
int end;
String text;
if (leftAt < start) {
// This is an area with no annotation.
end = start;
start = leftAt;
text = "";
} else {
// This is an area with an annotation.
end = a.getEnd();
text = padding.substring(0, a.getIndent() * this.indentAmount) + a.getText();
rightAt++;
}
left.write(Hex.dump(data, start, end - start, start, hexCols, 6));
right.write(text);
twoc.flush();
leftAt = end;
}
if (leftAt < cursor) {
// There is unannotated output at the end.
left.write(Hex.dump(data, leftAt, cursor - leftAt, leftAt,
hexCols, 6));
}
while (rightAt < rightSz) {
// There are zero-byte annotations at the end.
right.write(annotations.get(rightAt).getText());
rightAt++;
}
twoc.flush();
}
/**
* Throws the excpetion for when an attempt is made to write past the
* end of the instance.
*/
private static void throwBounds() {
throw new IndexOutOfBoundsException("attempt to write past the end");
}
/**
* Reallocates the underlying array if necessary. Calls to this method
* should be guarded by a test of {@link #stretchy}.
*
* @param desiredSize >= 0; the desired minimum total size of the array
*/
private void ensureCapacity(int desiredSize) {
if (data.length < desiredSize) {
byte[] newData = new byte[desiredSize * 2 + 1000];
System.arraycopy(data, 0, newData, 0, cursor);
data = newData;
}
}
/**
* Annotation on output.
*/
private static class Annotation {
/** >= 0; start of annotated range (inclusive) */
private final int start;
/**
* >= 0; end of annotated range (exclusive);
* <code>Integer.MAX_VALUE</code> if unclosed
*/
private int end;
/** non-null; annotation text */
private final String text;
private int indent;
/**
* Constructs an instance.
*
* @param start >= 0; start of annotated range
* @param end >= start; end of annotated range (exclusive) or
* <code>Integer.MAX_VALUE</code> if unclosed
* @param text non-null; annotation text
*/
public Annotation(int start, int end, String text, int indent) {
this.start = start;
this.end = end;
this.text = text;
this.indent = indent;
}
/**
* Constructs an instance. It is initally unclosed.
*
* @param start >= 0; start of annotated range
* @param text non-null; annotation text
*/
public Annotation(int start, String text, int indent) {
this(start, Integer.MAX_VALUE, text, indent);
}
/**
* Sets the end as given, but only if the instance is unclosed;
* otherwise, do nothing.
*
* @param end >= start; the end
*/
public void setEndIfUnset(int end) {
if (this.end == Integer.MAX_VALUE) {
this.end = end;
}
}
/**
* Sets the end as given.
*
* @param end >= start; the end
*/
public void setEnd(int end) {
this.end = end;
}
/**
* Gets the start.
*
* @return the start
*/
public int getStart() {
return start;
}
/**
* Gets the end.
*
* @return the end
*/
public int getEnd() {
return end;
}
/**
* Gets the text.
*
* @return non-null; the text
*/
public String getText() {
return text;
}
public int getIndent() {
return indent;
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/ByteArrayAnnotatedOutput.java
|
Java
|
asf20
| 18,635
|
/*
* Copyright (C) 2006 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* SparseArrays map integers to Objects. Unlike a normal array of Objects,
* there can be gaps in the indices. It is intended to be more efficient
* than using a HashMap to map Integers to Objects.
*/
public class SparseArray<E> {
private static final Object DELETED = new Object();
private boolean mGarbage = false;
/**
* Creates a new SparseArray containing no mappings.
*/
public SparseArray() {
this(10);
}
/**
* Creates a new SparseArray containing no mappings that will not
* require any additional memory allocation to store the specified
* number of mappings.
*/
public SparseArray(int initialCapacity) {
mKeys = new int[initialCapacity];
mValues = new Object[initialCapacity];
mSize = 0;
}
/**
* Gets the Object mapped from the specified key, or <code>null</code>
* if no such mapping has been made.
*/
public E get(int key) {
return get(key, null);
}
/**
* Gets the Object mapped from the specified key, or the specified Object
* if no such mapping has been made.
*/
public E get(int key, E valueIfKeyNotFound) {
int i = binarySearch(mKeys, 0, mSize, key);
if (i < 0 || mValues[i] == DELETED) {
return valueIfKeyNotFound;
} else {
return (E) mValues[i];
}
}
/**
* Removes the mapping from the specified key, if there was any.
*/
public void delete(int key) {
int i = binarySearch(mKeys, 0, mSize, key);
if (i >= 0) {
if (mValues[i] != DELETED) {
mValues[i] = DELETED;
mGarbage = true;
}
}
}
/**
* Alias for {@link #delete(int)}.
*/
public void remove(int key) {
delete(key);
}
private void gc() {
// Log.e("SparseArray", "gc start with " + mSize);
int n = mSize;
int o = 0;
int[] keys = mKeys;
Object[] values = mValues;
for (int i = 0; i < n; i++) {
Object val = values[i];
if (val != DELETED) {
if (i != o) {
keys[o] = keys[i];
values[o] = val;
}
o++;
}
}
mGarbage = false;
mSize = o;
// Log.e("SparseArray", "gc end with " + mSize);
}
/**
* Adds a mapping from the specified key to the specified value,
* replacing the previous mapping from the specified key if there
* was one.
*/
public void put(int key, E value) {
int i = binarySearch(mKeys, 0, mSize, key);
if (i >= 0) {
mValues[i] = value;
} else {
i = ~i;
if (i < mSize && mValues[i] == DELETED) {
mKeys[i] = key;
mValues[i] = value;
return;
}
if (mGarbage && mSize >= mKeys.length) {
gc();
// Search again because indices may have changed.
i = ~binarySearch(mKeys, 0, mSize, key);
}
if (mSize >= mKeys.length) {
int n = Math.max(mSize + 1, mKeys.length * 2);
int[] nkeys = new int[n];
Object[] nvalues = new Object[n];
// Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
if (mSize - i != 0) {
// Log.e("SparseArray", "move " + (mSize - i));
System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
}
mKeys[i] = key;
mValues[i] = value;
mSize++;
}
}
/**
* Returns the number of key-value mappings that this SparseArray
* currently stores.
*/
public int size() {
if (mGarbage) {
gc();
}
return mSize;
}
/**
* Given an index in the range <code>0...size()-1</code>, returns
* the key from the <code>index</code>th key-value mapping that this
* SparseArray stores.
*/
public int keyAt(int index) {
if (mGarbage) {
gc();
}
return mKeys[index];
}
/**
* Given an index in the range <code>0...size()-1</code>, returns
* the value from the <code>index</code>th key-value mapping that this
* SparseArray stores.
*/
public E valueAt(int index) {
if (mGarbage) {
gc();
}
return (E) mValues[index];
}
/**
* Given an index in the range <code>0...size()-1</code>, sets a new
* value for the <code>index</code>th key-value mapping that this
* SparseArray stores.
*/
public void setValueAt(int index, E value) {
if (mGarbage) {
gc();
}
mValues[index] = value;
}
/**
* Returns the index for which {@link #keyAt} would return the
* specified key, or a negative number if the specified
* key is not mapped.
*/
public int indexOfKey(int key) {
if (mGarbage) {
gc();
}
return binarySearch(mKeys, 0, mSize, key);
}
/**
* Returns an index for which {@link #valueAt} would return the
* specified key, or a negative number if no keys map to the
* specified value.
* Beware that this is a linear search, unlike lookups by key,
* and that multiple keys can map to the same value and this will
* find only one of them.
*/
public int indexOfValue(E value) {
if (mGarbage) {
gc();
}
for (int i = 0; i < mSize; i++)
if (mValues[i] == value)
return i;
return -1;
}
/**
* Removes all key-value mappings from this SparseArray.
*/
public void clear() {
int n = mSize;
Object[] values = mValues;
for (int i = 0; i < n; i++) {
values[i] = null;
}
mSize = 0;
mGarbage = false;
}
/**
* Puts a key/value pair into the array, optimizing for the case where
* the key is greater than all existing keys in the array.
*/
public void append(int key, E value) {
if (mSize != 0 && key <= mKeys[mSize - 1]) {
put(key, value);
return;
}
if (mGarbage && mSize >= mKeys.length) {
gc();
}
int pos = mSize;
if (pos >= mKeys.length) {
int n = Math.max(pos + 1, mKeys.length * 2);
int[] nkeys = new int[n];
Object[] nvalues = new Object[n];
// Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
mKeys[pos] = key;
mValues[pos] = value;
mSize = pos + 1;
}
/**
* Increases the size of the underlying storage if needed, to ensure that it can
* hold the specified number of items without having to allocate additional memory
* @param capacity the number of items
*/
public void ensureCapacity(int capacity) {
if (mGarbage && mSize >= mKeys.length) {
gc();
}
if (mKeys.length < capacity) {
int[] nkeys = new int[capacity];
Object[] nvalues = new Object[capacity];
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
}
private static int binarySearch(int[] a, int start, int len, int key) {
int high = start + len, low = start - 1, guess;
while (high - low > 1) {
guess = (high + low) / 2;
if (a[guess] < key)
low = guess;
else
high = guess;
}
if (high == start + len)
return ~(start + len);
else if (a[high] == key)
return high;
else
return ~high;
}
/**
* @return a read-only list of the values in this SparseArray which are in ascending order, based on their
* associated key
*/
public List<E> getValues() {
return Collections.unmodifiableList(Arrays.asList((E[])mValues));
}
private int[] mKeys;
private Object[] mValues;
private int mSize;
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/SparseArray.java
|
Java
|
asf20
| 9,798
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.io.FilterWriter;
import java.io.IOException;
import java.io.Writer;
/**
* Writer that wraps another writer and passes width-limited and
* optionally-prefixed output to its subordinate. When lines are
* wrapped they are automatically indented based on the start of the
* line.
*/
public final class IndentingWriter extends FilterWriter {
/** null-ok; optional prefix for every line */
private final String prefix;
/** > 0; the maximum output width */
private final int width;
/** > 0; the maximum indent */
private final int maxIndent;
/** >= 0; current output column (zero-based) */
private int column;
/** whether indent spaces are currently being collected */
private boolean collectingIndent;
/** >= 0; current indent amount */
private int indent;
/**
* Constructs an instance.
*
* @param out non-null; writer to send final output to
* @param width >= 0; the maximum output width (not including
* <code>prefix</code>), or <code>0</code> for no maximum
* @param prefix non-null; the prefix for each line
*/
public IndentingWriter(Writer out, int width, String prefix) {
super(out);
if (out == null) {
throw new NullPointerException("out == null");
}
if (width < 0) {
throw new IllegalArgumentException("width < 0");
}
if (prefix == null) {
throw new NullPointerException("prefix == null");
}
this.width = (width != 0) ? width : Integer.MAX_VALUE;
this.maxIndent = width >> 1;
this.prefix = (prefix.length() == 0) ? null : prefix;
bol();
}
/**
* Constructs a no-prefix instance.
*
* @param out non-null; writer to send final output to
* @param width >= 0; the maximum output width (not including
* <code>prefix</code>), or <code>0</code> for no maximum
*/
public IndentingWriter(Writer out, int width) {
this(out, width, "");
}
/** {@inheritDoc} */
@Override
public void write(int c) throws IOException {
synchronized (lock) {
if (collectingIndent) {
if (c == ' ') {
indent++;
if (indent >= maxIndent) {
indent = maxIndent;
collectingIndent = false;
}
} else {
collectingIndent = false;
}
}
if ((column == width) && (c != '\n')) {
out.write('\n');
column = 0;
/*
* Note: No else, so this should fall through to the next
* if statement.
*/
}
if (column == 0) {
if (prefix != null) {
out.write(prefix);
}
if (!collectingIndent) {
for (int i = 0; i < indent; i++) {
out.write(' ');
}
column = indent;
}
}
out.write(c);
if (c == '\n') {
bol();
} else {
column++;
}
}
}
/** {@inheritDoc} */
@Override
public void write(char[] cbuf, int off, int len) throws IOException {
synchronized (lock) {
while (len > 0) {
write(cbuf[off]);
off++;
len--;
}
}
}
/** {@inheritDoc} */
@Override
public void write(String str, int off, int len) throws IOException {
synchronized (lock) {
while (len > 0) {
write(str.charAt(off));
off++;
len--;
}
}
}
/**
* Indicates that output is at the beginning of a line.
*/
private void bol() {
column = 0;
collectingIndent = (maxIndent != 0);
indent = 0;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/IndentingWriter.java
|
Java
|
asf20
| 4,948
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
public class Pair<A, B> {
public final A first;
public final B second;
public Pair(A first, B second) {
this.first = first;
this.second = second;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/Pair.java
|
Java
|
asf20
| 1,715
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
import org.jf.dexlib.CodeItem;
import org.jf.dexlib.TypeIdItem;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
public class TryListBuilder
{
/*TODO: add logic to merge adjacent, identical try blocks, and remove superflous handlers
Also provide a "strict" mode, where the above isn't performed, which will be useful to be able to
exactly reproduce the original .dex file (for testing/verification purposes)*/
private TryRange firstTryRange = new TryRange(0,0);
private TryRange lastTryRange = new TryRange(0,0);
public TryListBuilder() {
firstTryRange.next = lastTryRange;
lastTryRange.previous = firstTryRange;
}
private class TryRange
{
public TryRange previous = null;
public TryRange next = null;
public int startAddress;
public int endAddress;
public LinkedList<Handler> handlers;
public int catchAllHandlerAddress;
public TryRange(int startAddress, int endAddress) {
this.startAddress = startAddress;
this.endAddress = endAddress;
this.handlers = new LinkedList<Handler>();
this.previous = null;
this.next = null;
catchAllHandlerAddress = -1;
}
public void append(TryRange tryRange) {
/*we use a dummy last item, so this.next will always
have a value*/
this.next.previous = tryRange;
tryRange.next = this.next;
this.next = tryRange;
tryRange.previous = this;
}
public void prepend(TryRange tryRange){
/*we use a dummy first item, so this.previous will always
have a value*/
this.previous.next = tryRange;
tryRange.previous = this.previous;
this.previous = tryRange;
tryRange.next = this;
}
/**
* This splits the current range into two ranges at the given
* address. The existing range will be shortened to the first
* half, and a new range will be created and returned for the
* 2nd half.
* @param address The address to split at
* @return The 2nd half of the
*/
public TryRange split(int address) {
//this is a private class, so address is assumed
//to be valid
TryRange tryRange = new TryRange(address, endAddress);
tryRange.catchAllHandlerAddress = this.catchAllHandlerAddress;
tryRange.handlers.addAll(this.handlers);
append(tryRange);
this.endAddress = address;
return tryRange;
}
public void appendHandler(Handler handler) {
handlers.addLast(handler);
}
public void prependHandler(Handler handler) {
handlers.addFirst(handler);
}
}
private class Handler
{
public final TypeIdItem type;
public final int handlerAddress;
public Handler(TypeIdItem type, int handlerAddress) {
this.type = type;
this.handlerAddress = handlerAddress;
}
}
public Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> encodeTries() {
if (firstTryRange.next == lastTryRange) {
return new Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>>(null, null);
}
ArrayList<CodeItem.TryItem> tries = new ArrayList<CodeItem.TryItem>();
ArrayList<CodeItem.EncodedCatchHandler> handlers = new ArrayList<CodeItem.EncodedCatchHandler>();
HashMap<CodeItem.EncodedCatchHandler, CodeItem.EncodedCatchHandler> handlerDict =
new HashMap<CodeItem.EncodedCatchHandler, CodeItem.EncodedCatchHandler>();
TryRange tryRange = firstTryRange.next;
while (tryRange != lastTryRange) {
CodeItem.EncodedTypeAddrPair[] encodedTypeAddrPairs =
new CodeItem.EncodedTypeAddrPair[tryRange.handlers.size()];
int index = 0;
for (Handler handler: tryRange.handlers) {
CodeItem.EncodedTypeAddrPair encodedTypeAddrPair = new CodeItem.EncodedTypeAddrPair(
handler.type,
handler.handlerAddress);
encodedTypeAddrPairs[index++] = encodedTypeAddrPair;
}
CodeItem.EncodedCatchHandler encodedCatchHandler = new CodeItem.EncodedCatchHandler(
encodedTypeAddrPairs,
tryRange.catchAllHandlerAddress);
CodeItem.EncodedCatchHandler internedEncodedCatchHandler = handlerDict.get(encodedCatchHandler);
if (internedEncodedCatchHandler == null) {
handlerDict.put(encodedCatchHandler, encodedCatchHandler);
handlers.add(encodedCatchHandler);
} else {
encodedCatchHandler = internedEncodedCatchHandler;
}
CodeItem.TryItem tryItem = new CodeItem.TryItem(
tryRange.startAddress,
tryRange.endAddress - tryRange.startAddress,
encodedCatchHandler);
tries.add(tryItem);
tryRange = tryRange.next;
}
return new Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>>(tries, handlers);
}
public void addCatchAllHandler(int startAddress, int endAddress, int handlerAddress) {
TryRange startRange;
TryRange endRange;
Pair<TryRange, TryRange> ranges = getBoundingRanges(startAddress, endAddress);
startRange = ranges.first;
endRange = ranges.second;
int previousEnd = startAddress;
TryRange tryRange = startRange;
/*Now we have the start and end ranges that exactly match the start and end
of the range being added. We need to iterate over all the ranges from the start
to end range inclusively, and append the handler to the end of each range's handler
list. We also need to create a new range for any "holes" in the existing ranges*/
do
{
//is there a hole? If so, add a new range to fill the hole
if (tryRange.startAddress > previousEnd) {
TryRange newRange = new TryRange(previousEnd, tryRange.startAddress);
tryRange.prepend(newRange);
tryRange = newRange;
}
if (tryRange.catchAllHandlerAddress == -1) {
tryRange.catchAllHandlerAddress = handlerAddress;
}
previousEnd = tryRange.endAddress;
tryRange = tryRange.next;
} while (tryRange.previous != endRange);
}
public Pair<TryRange, TryRange> getBoundingRanges(int startAddress, int endAddress) {
TryRange startRange = null;
TryRange endRange = null;
TryRange tryRange = firstTryRange.next;
while (tryRange != lastTryRange) {
if (startAddress == tryRange.startAddress) {
//|-----|
//^------
/*Bam. We hit the start of the range right on the head*/
startRange = tryRange;
break;
} else if (startAddress > tryRange.startAddress && startAddress < tryRange.endAddress) {
//|-----|
// ^----
/*Almost. The start of the range being added is in the middle
of an existing try range. We need to split the existing range
at the start address of the range being added*/
startRange = tryRange.split(startAddress);
break;
}else if (startAddress < tryRange.startAddress) {
if (endAddress <= tryRange.startAddress) {
// |-----|
//^--^
/*Oops, totally too far! The new range doesn't overlap any existing
ones, so we just add it and return*/
startRange = new TryRange(startAddress, endAddress);
tryRange.prepend(startRange);
return new Pair<TryRange, TryRange>(startRange, startRange);
} else {
// |-----|
//^---------
/*Oops, too far! We've passed the start of the range being added, but
the new range does overlap this one. We need to add a new range just
before this one*/
startRange = new TryRange(startAddress, tryRange.startAddress);
tryRange.prepend(startRange);
break;
}
}
tryRange = tryRange.next;
}
//|-----|
// ^-----
/*Either the list of tries is blank, or all the tries in the list
end before the range being added starts. In either case, we just need
to add a new range at the end of the list*/
if (startRange == null) {
startRange = new TryRange(startAddress, endAddress);
lastTryRange.prepend(startRange);
return new Pair<TryRange, TryRange>(startRange, startRange);
}
tryRange = startRange;
while (tryRange != lastTryRange) {
if (tryRange.endAddress == endAddress) {
//|-----|
//------^
/*Bam! We hit the end right on the head.*/
endRange = tryRange;
break;
} else if (tryRange.startAddress < endAddress && tryRange.endAddress > endAddress) {
//|-----|
//--^
/*Almost. The range being added ends in the middle of an
existing range. We need to split the existing range
at the end of the range being added.*/
tryRange.split(endAddress);
endRange = tryRange;
break;
} else if (tryRange.startAddress >= endAddress) {
//|-----| |-----|
//-----------^
/*Oops, too far! The current range starts after the range being added
ends. We need to create a new range that starts at the end of the
previous range, and ends at the end of the range being added*/
endRange = new TryRange(tryRange.previous.endAddress, endAddress);
tryRange.prepend(endRange);
break;
}
tryRange = tryRange.next;
}
//|-----|
//--------^
/*The last range in the list ended before the end of the range being added.
We need to add a new range that starts at the end of the last range in the
list, and ends at the end of the range being added.*/
if (endRange == null) {
endRange = new TryRange(lastTryRange.previous.endAddress, endAddress);
lastTryRange.prepend(endRange);
}
return new Pair<TryRange, TryRange>(startRange, endRange);
}
public void addHandler(TypeIdItem type, int startAddress, int endAddress, int handlerAddress) {
TryRange startRange;
TryRange endRange;
//TODO: need to check for pre-existing exception types in the handler list?
Pair<TryRange, TryRange> ranges = getBoundingRanges(startAddress, endAddress);
startRange = ranges.first;
endRange = ranges.second;
Handler handler = new Handler(type, handlerAddress);
int previousEnd = startAddress;
TryRange tryRange = startRange;
/*Now we have the start and end ranges that exactly match the start and end
of the range being added. We need to iterate over all the ranges from the start
to end range inclusively, and append the handler to the end of each range's handler
list. We also need to create a new range for any "holes" in the existing ranges*/
do
{
//is there a hole? If so, add a new range to fill the hole
if (tryRange.startAddress > previousEnd) {
TryRange newRange = new TryRange(previousEnd, tryRange.startAddress);
tryRange.prepend(newRange);
tryRange = newRange;
}
tryRange.appendHandler(handler);
previousEnd = tryRange.endAddress;
tryRange = tryRange.next;
} while (tryRange.previous != endRange);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/TryListBuilder.java
|
Java
|
asf20
| 14,158
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
import org.jf.dexlib.*;
import java.util.ArrayList;
import java.util.List;
/**
* This class is intended to provide an easy to use container to build up a method's debug info. You can easily add
* an "event" at a specific address, where an event is something like a line number, start/end local, etc.
* The events must be added such that the code addresses increase monotonically. This matches how a parser would
* generally behave, and is intended to increase performance.
*/
public class DebugInfoBuilder
{
private static final int LINE_BASE = -4;
private static final int LINE_RANGE = 15;
private static final int FIRST_SPECIAL = 0x0a;
private int lineStart = 0;
private ArrayList<String> parameterNames = new ArrayList<String>();
private ArrayList<Event> events = new ArrayList<Event>();
private int lastAddress = 0;
private boolean hasData;
private int currentAddress;
private int currentLine;
public DebugInfoBuilder() {
}
private void checkAddress(int address) {
if (lastAddress > address) {
throw new RuntimeException("Cannot add an event with an address before the address of the prior event");
}
}
public void addParameterName(String parameterName) {
if (parameterName != null) {
hasData = true;
}
parameterNames.add(parameterName);
}
public void addLine(int address, int line) {
hasData = true;
checkAddress(address);
if (lineStart == 0) {
lineStart = line;
}
events.add(new LineEvent(address, line));
}
public void addLocal(int address, int registerNumber, String localName, String localType) {
hasData = true;
checkAddress(address);
events.add(new StartLocalEvent(address, registerNumber, localName, localType));
}
public void addLocalExtended(int address, int registerNumber, String localName, String localType,
String signature) {
hasData = true;
checkAddress(address);
events.add(new StartLocalExtendedEvent(address, registerNumber, localName, localType, signature));
}
public void addEndLocal(int address, int registerNumber) {
hasData = true;
checkAddress(address);
events.add(new EndLocalEvent(address, registerNumber));
}
public void addRestartLocal(int address, int registerNumber) {
hasData = true;
checkAddress(address);
events.add(new RestartLocalEvent(address, registerNumber));
}
public void addPrologue(int address) {
hasData = true;
checkAddress(address);
events.add(new PrologueEvent(address));
}
public void addEpilogue(int address) {
hasData = true;
checkAddress(address);
events.add(new EpilogueEvent(address));
}
public void addSetFile(int address, String fileName) {
hasData = true;
checkAddress(address);
events.add(new SetFileEvent(address, fileName));
}
public int getParameterNameCount() {
return parameterNames.size();
}
public DebugInfoItem encodeDebugInfo(DexFile dexFile) {
if (!hasData) {
return null;
}
ByteArrayOutput out = new ByteArrayOutput();
StringIdItem[] parameterNamesArray = new StringIdItem[parameterNames.size()];
ArrayList<Item> referencedItems = new ArrayList<Item>();
if (lineStart == 0) {
lineStart = 1;
}
currentLine = lineStart;
for (Event event: events) {
event.emit(dexFile, out, referencedItems);
}
emitEndSequence(out);
int index = 0;
for (String parameterName: parameterNames) {
if (parameterName == null) {
parameterNamesArray[index++] = null;
} else {
parameterNamesArray[index++] = StringIdItem.internStringIdItem(dexFile, parameterName);
}
}
Item[] referencedItemsArray = new Item[referencedItems.size()];
referencedItems.toArray(referencedItemsArray);
return DebugInfoItem.internDebugInfoItem(dexFile, lineStart, parameterNamesArray, out.toByteArray(),
referencedItemsArray);
}
public static byte calculateSpecialOpcode(int lineDelta, int addressDelta) {
return (byte)(FIRST_SPECIAL + (addressDelta * LINE_RANGE) + (lineDelta - LINE_BASE));
}
private interface Event
{
int getAddress();
void emit(DexFile dexFile, Output out, List<Item> referencedItems);
}
private void emitEndSequence(Output out) {
out.writeByte(0);
}
private void emitAdvancePC(Output out, int address) {
int addressDelta = address-currentAddress;
if (addressDelta > 0) {
out.writeByte(1);
out.writeUnsignedLeb128(addressDelta);
currentAddress = address;
}
}
private void emitAdvanceLine(Output out, int lineDelta) {
out.writeByte(2);
out.writeSignedLeb128(lineDelta);
}
private void emitStartLocal(Output out, int registerNum) {
out.writeByte(3);
out.writeUnsignedLeb128(registerNum);
out.writeByte(1);
out.writeByte(1);
}
private void emitStartLocalExtended(Output out, int registerNum) {
out.writeByte(4);
out.writeUnsignedLeb128(registerNum);
out.writeByte(1);
out.writeByte(1);
out.writeByte(1);
}
private void emitEndLocal(Output out, int registerNum) {
out.writeByte(5);
out.writeUnsignedLeb128(registerNum);
}
private void emitRestartLocal(Output out, int registerNum) {
out.writeByte(6);
out.writeUnsignedLeb128(registerNum);
}
private void emitSetPrologueEnd(Output out) {
out.writeByte(7);
}
private void emitSetEpilogueBegin(Output out) {
out.writeByte(8);
}
private void emitSetFile(Output out) {
out.writeByte(9);
out.writeByte(1);
}
private void emitSpecialOpcode(Output out, byte opcode) {
out.writeByte(opcode);
}
private class LineEvent implements Event
{
private final int address;
private final int line;
public LineEvent(int address, int line) {
this.address = address;
this.line = line;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
int lineDelta = line - currentLine;
int addressDelta = address - currentAddress;
if (lineDelta < -4 || lineDelta > 10) {
emitAdvanceLine(out, lineDelta);
lineDelta = 0;
}
if (lineDelta < 2 && addressDelta > 16 || lineDelta > 1 && addressDelta > 15) {
emitAdvancePC(out, address);
addressDelta = 0;
}
//TODO: need to handle the case when the line delta is larger than a signed int
emitSpecialOpcode(out, calculateSpecialOpcode(lineDelta, addressDelta));
currentAddress = address;
currentLine = line;
}
}
private class StartLocalEvent implements Event
{
private final int address;
private final int registerNum;
private final String localName;
private final String localType;
public StartLocalEvent(int address, int registerNum, String localName, String localType) {
this.address = address;
this.registerNum = registerNum;
this.localName = localName;
this.localType = localType;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
emitAdvancePC(out, address);
emitStartLocal(out, registerNum);
referencedItems.add(localName==null?null:StringIdItem.internStringIdItem(dexFile, localName));
referencedItems.add(localType==null?null:TypeIdItem.internTypeIdItem(dexFile,
StringIdItem.internStringIdItem(dexFile, localType)));
}
}
private class StartLocalExtendedEvent implements Event
{
private final int address;
private final int registerNum;
private final String localName;
private final String localType;
private final String signature;
public StartLocalExtendedEvent(int address, int registerNum, String localName, String localType,
String signature) {
this.address = address;
this.registerNum = registerNum;
this.localName = localName;
this.localType = localType;
this.signature = signature;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
emitAdvancePC(out, address);
emitStartLocalExtended(out, registerNum);
if (localName != null) {
referencedItems.add(StringIdItem.internStringIdItem(dexFile, localName));
}
if (localType != null) {
referencedItems.add(TypeIdItem.internTypeIdItem(dexFile,
StringIdItem.internStringIdItem(dexFile, localType)));
}
if (signature != null) {
referencedItems.add(StringIdItem.internStringIdItem(dexFile, signature));
}
}
}
private class EndLocalEvent implements Event
{
private final int address;
private final int registerNum;
public EndLocalEvent(int address, int registerNum) {
this.address = address;
this.registerNum = registerNum;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
emitAdvancePC(out, address);
emitEndLocal(out, registerNum);
}
}
private class RestartLocalEvent implements Event
{
private final int address;
private final int registerNum;
public RestartLocalEvent(int address, int registerNum) {
this.address = address;
this.registerNum = registerNum;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
emitAdvancePC(out, address);
emitRestartLocal(out, registerNum);
}
}
private class PrologueEvent implements Event
{
private final int address;
public PrologueEvent(int address) {
this.address = address;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
emitAdvancePC(out, address);
emitSetPrologueEnd(out);
}
}
private class EpilogueEvent implements Event
{
private final int address;
public EpilogueEvent(int address) {
this.address = address;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
emitAdvancePC(out, address);
emitSetEpilogueBegin(out);
}
}
private class SetFileEvent implements Event
{
private final int address;
private final String fileName;
public SetFileEvent(int address, String fileName) {
this.address = address;
this.fileName = fileName;
}
public int getAddress() {
return address;
}
public void emit(DexFile dexFile, Output out, List<Item> referencedItems) {
emitAdvancePC(out, address);
emitSetFile(out);
if (fileName != null) {
referencedItems.add(StringIdItem.internStringIdItem(dexFile, fileName));
}
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/DebugInfoBuilder.java
|
Java
|
asf20
| 13,877
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
/**
* Wrapper for a <code>byte[]</code>, which provides read-only access and
* can "reveal" a partial slice of the underlying array.
*
* <b>Note:</b> Multibyte accessors all use big-endian order.
*/
public final class ByteArray {
/** non-null; underlying array */
private final byte[] bytes;
/** <code>>= 0</code>; start index of the slice (inclusive) */
private final int start;
/** <code>>= 0, <= bytes.length</code>; size computed as
* <code>end - start</code> (in the constructor) */
private final int size;
/**
* Constructs an instance.
*
* @param bytes non-null; the underlying array
* @param start <code>>= 0</code>; start index of the slice (inclusive)
* @param end <code>>= start, <= bytes.length</code>; end index of
* the slice (exclusive)
*/
public ByteArray(byte[] bytes, int start, int end) {
if (bytes == null) {
throw new NullPointerException("bytes == null");
}
if (start < 0) {
throw new IllegalArgumentException("start < 0");
}
if (end < start) {
throw new IllegalArgumentException("end < start");
}
if (end > bytes.length) {
throw new IllegalArgumentException("end > bytes.length");
}
this.bytes = bytes;
this.start = start;
this.size = end - start;
}
/**
* Constructs an instance from an entire <code>byte[]</code>.
*
* @param bytes non-null; the underlying array
*/
public ByteArray(byte[] bytes) {
this(bytes, 0, bytes.length);
}
/**
* Gets the size of the array, in bytes.
*
* @return >= 0; the size
*/
public int size() {
return size;
}
/**
* Returns a slice (that is, a sub-array) of this instance.
*
* @param start <code>>= 0</code>; start index of the slice (inclusive)
* @param end <code>>= start, <= size()</code>; end index of
* the slice (exclusive)
* @return non-null; the slice
*/
public ByteArray slice(int start, int end) {
checkOffsets(start, end);
return new ByteArray(bytes, start + this.start, end + this.start);
}
/**
* Returns the offset into the given array represented by the given
* offset into this instance.
*
* @param offset offset into this instance
* @param bytes non-null; (alleged) underlying array
* @return corresponding offset into <code>bytes</code>
* @throws IllegalArgumentException thrown if <code>bytes</code> is
* not the underlying array of this instance
*/
public int underlyingOffset(int offset, byte[] bytes) {
if (bytes != this.bytes) {
throw new IllegalArgumentException("wrong bytes");
}
return start + offset;
}
/**
* Gets the <code>signed byte</code> value at a particular offset.
*
* @param off <code>>= 0, < size(); offset to fetch
* @return <code>signed byte</code> at that offset
*/
public int getByte(int off) {
checkOffsets(off, off + 1);
return getByte0(off);
}
/**
* Gets the <code>signed short</code> value at a particular offset.
*
* @param off <code>>= 0, < (size() - 1); offset to fetch
* @return <code>signed short</code> at that offset
*/
public int getShort(int off) {
checkOffsets(off, off + 2);
return (getByte0(off) << 8) | getUnsignedByte0(off + 1);
}
/**
* Gets the <code>signed int</code> value at a particular offset.
*
* @param off <code>>= 0, < (size() - 3); offset to fetch
* @return <code>signed int</code> at that offset
*/
public int getInt(int off) {
checkOffsets(off, off + 4);
return (getByte0(off) << 24) |
(getUnsignedByte0(off + 1) << 16) |
(getUnsignedByte0(off + 2) << 8) |
getUnsignedByte0(off + 3);
}
/**
* Gets the <code>signed long</code> value at a particular offset.
*
* @param off <code>>= 0, < (size() - 7); offset to fetch
* @return <code>signed int</code> at that offset
*/
public long getLong(int off) {
checkOffsets(off, off + 8);
int part1 = (getByte0(off) << 24) |
(getUnsignedByte0(off + 1) << 16) |
(getUnsignedByte0(off + 2) << 8) |
getUnsignedByte0(off + 3);
int part2 = (getByte0(off + 4) << 24) |
(getUnsignedByte0(off + 5) << 16) |
(getUnsignedByte0(off + 6) << 8) |
getUnsignedByte0(off + 7);
return (part2 & 0xffffffffL) | ((long) part1) << 32;
}
/**
* Gets the <code>unsigned byte</code> value at a particular offset.
*
* @param off <code>>= 0, < size(); offset to fetch
* @return <code>unsigned byte</code> at that offset
*/
public int getUnsignedByte(int off) {
checkOffsets(off, off + 1);
return getUnsignedByte0(off);
}
/**
* Gets the <code>unsigned short</code> value at a particular offset.
*
* @param off <code>>= 0, < (size() - 1); offset to fetch
* @return <code>unsigned short</code> at that offset
*/
public int getUnsignedShort(int off) {
checkOffsets(off, off + 2);
return (getUnsignedByte0(off) << 8) | getUnsignedByte0(off + 1);
}
/**
* Copies the contents of this instance into the given raw
* <code>byte[]</code> at the given offset. The given array must be
* large enough.
*
* @param out non-null; array to hold the output
* @param offset non-null; index into <code>out</code> for the first
* byte of output
*/
public void getBytes(byte[] out, int offset) {
if ((out.length - offset) < size) {
throw new IndexOutOfBoundsException("(out.length - offset) < " +
"size()");
}
System.arraycopy(bytes, start, out, offset, size);
}
/**
* Checks a range of offsets for validity, throwing if invalid.
*
* @param s start offset (inclusive)
* @param e end offset (exclusive)
*/
private void checkOffsets(int s, int e) {
if ((s < 0) || (e < s) || (e > size)) {
throw new IllegalArgumentException("bad range: " + s + ".." + e +
"; actual size " + size);
}
}
/**
* Gets the <code>signed byte</code> value at the given offset,
* without doing any argument checking.
*
* @param off offset to fetch
* @return byte at that offset
*/
private int getByte0(int off) {
return bytes[start + off];
}
/**
* Gets the <code>unsigned byte</code> value at the given offset,
* without doing any argument checking.
*
* @param off offset to fetch
* @return byte at that offset
*/
private int getUnsignedByte0(int off) {
return bytes[start + off] & 0xff;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/ByteArray.java
|
Java
|
asf20
| 7,970
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
/**
* Implementation of {@link Input} which reads the data from a
* <code>byte[]</code> instance.
*
* <p><b>Note:</b> As per the {@link Input } interface, multi-byte
* reads all use little-endian order.</p>
*/
public class ByteArrayInput
implements Input {
/** non-null; the data itself */
private byte[] data;
/** >= 0; current read cursor */
private int cursor;
/* buffer for reading UTF-8 strings */
private char[] buffer = null;
/**
* Constructs an instance with the given data
*
* @param data non-null; data array to use for input
*/
public ByteArrayInput(byte[] data) {
if (data == null) {
throw new NullPointerException("data == null");
}
this.data = data;
this.cursor = 0;
}
/**
* Gets the underlying <code>byte[]</code> of this instance
*
* @return non-null; the <code>byte[]</code>
*/
public byte[] getArray() {
return data;
}
/** {@inheritDoc} */
public int getCursor() {
return cursor;
}
/** {@inheritDoc} */
public void setCursor(int cursor) {
if (cursor < 0 || cursor >= data.length)
throw new IndexOutOfBoundsException("The provided cursor value " +
"is not within the bounds of this instance's data array");
this.cursor = cursor;
}
/** {@inheritDoc} */
public void assertCursor(int expectedCursor) {
if (cursor != expectedCursor) {
throw new ExceptionWithContext("expected cursor " +
expectedCursor + "; actual value: " + cursor);
}
}
/** {@inheritDoc} */
public byte readByte() {
return data[cursor++];
}
/** {@inheritDoc} */
public int readShort() {
int readAt = cursor;
int result = ((data[readAt++] & 0xff) +
((data[readAt++] & 0xff) << 8));
cursor = readAt;
return result;
}
/** {@inheritDoc} */
public int readInt() {
int readAt = cursor;
int result = (data[readAt++] & 0xff) +
((data[readAt++] & 0xff) << 8) +
((data[readAt++] & 0xff) << 16) +
((data[readAt++] & 0xff) << 24);
cursor = readAt;
return result;
}
/** {@inheritDoc} */
public long readLong() {
int readAt = cursor;
long result = (data[readAt++] & 0xffL) |
((data[readAt++] & 0xffL) << 8) |
((data[readAt++] & 0xffL) << 16) |
((data[readAt++] & 0xffL) << 24) |
((data[readAt++] & 0xffL) << 32) |
((data[readAt++] & 0xffL) << 40) |
((data[readAt++] & 0xffL) << 48) |
((data[readAt++] & 0xffL) << 56);
cursor = readAt;
return result;
}
/** {@inheritDoc} */
public int readUnsignedOrSignedLeb128() {
int end = cursor;
int currentByteValue;
int result;
result = data[end++] & 0xff;
if (result > 0x7f) {
currentByteValue = data[end++] & 0xff;
result = (result & 0x7f) | ((currentByteValue & 0x7f) << 7);
if (currentByteValue > 0x7f) {
currentByteValue = data[end++] & 0xff;
result |= (currentByteValue & 0x7f) << 14;
if (currentByteValue > 0x7f) {
currentByteValue = data[end++] & 0xff;
result |= (currentByteValue & 0x7f) << 21;
if (currentByteValue > 0x7f) {
currentByteValue = data[end++] & 0xff;
if (currentByteValue > 0x0f) {
throwInvalidLeb();
}
result |= currentByteValue << 28;
}
}
}
} else {
cursor = end;
return result;
}
cursor = end;
//If the last byte is 0, then this was an unsigned value (incorrectly) written in a signed format
//The caller wants to know if this is the case, so we'll return the negated value instead
//If there was only a single byte that had a value of 0, then we would have returned in the above
//"else"
if (data[end-1] == 0) {
return ~result;
}
return result;
}
/** {@inheritDoc} */
public int readUnsignedLeb128() {
int end = cursor;
int currentByteValue;
int result;
result = data[end++] & 0xff;
if (result > 0x7f) {
currentByteValue = data[end++] & 0xff;
result = (result & 0x7f) | ((currentByteValue & 0x7f) << 7);
if (currentByteValue > 0x7f) {
currentByteValue = data[end++] & 0xff;
result |= (currentByteValue & 0x7f) << 14;
if (currentByteValue > 0x7f) {
currentByteValue = data[end++] & 0xff;
result |= (currentByteValue & 0x7f) << 21;
if (currentByteValue > 0x7f) {
currentByteValue = data[end++] & 0xff;
if (currentByteValue > 0x0f) {
throwInvalidLeb();
}
result |= currentByteValue << 28;
}
}
}
}
cursor = end;
return result;
}
/** {@inheritDoc} */
public int readSignedLeb128() {
int end = cursor;
int currentByteValue;
int result;
result = data[end++] & 0xff;
if (result <= 0x7f) {
result = (result << 25) >> 25;
} else {
currentByteValue = data[end++] & 0xff;
result = (result & 0x7f) | ((currentByteValue & 0x7f) << 7);
if (currentByteValue <= 0x7f) {
result = (result << 18) >> 18;
} else {
currentByteValue = data[end++] & 0xff;
result |= (currentByteValue & 0x7f) << 14;
if (currentByteValue <= 0x7f) {
result = (result << 11) >> 11;
} else {
currentByteValue = data[end++] & 0xff;
result |= (currentByteValue & 0x7f) << 21;
if (currentByteValue <= 0x7f) {
result = (result << 4) >> 4;
} else {
currentByteValue = data[end++] & 0xff;
if (currentByteValue > 0x0f) {
throwInvalidLeb();
}
result |= currentByteValue << 28;
}
}
}
}
cursor = end;
return result;
}
/** {@inheritDoc} */
public void read(byte[] bytes, int offset, int length) {
int end = cursor + length;
if (end > data.length) {
throwBounds();
}
System.arraycopy(data, cursor, bytes, offset, length);
cursor = end;
}
/** {@inheritDoc} */
public void read(byte[] bytes) {
int length = bytes.length;
int end = cursor + length;
if (end > data.length) {
throwBounds();
}
System.arraycopy(data, cursor, bytes, 0, length);
cursor = end;
}
/** {@inheritDoc} */
public byte[] readBytes(int length) {
int end = cursor + length;
if (end > data.length) {
throwBounds();
}
byte[] result = new byte[length];
System.arraycopy(data, cursor, result, 0, length);
cursor = end;
return result;
}
/** {@inheritDoc} */
public String realNullTerminatedUtf8String() {
int startPosition = cursor;
while (data[cursor] != 0) {
cursor++;
}
int byteCount = cursor - startPosition;
//skip the terminating null
cursor++;
if (buffer == null || buffer.length < byteCount) {
buffer = new char[byteCount];
}
return Utf8Utils.utf8BytesToString(buffer, data, startPosition, byteCount);
}
/** {@inheritDoc} */
public void skipBytes(int count) {
cursor += count;
}
/** {@inheritDoc} */
public void alignTo(int alignment) {
cursor = AlignmentUtils.alignOffset(cursor, alignment);
}
/**
* Throws the excpetion for when an attempt is made to read past the
* end of the instance.
*/
private static void throwBounds() {
throw new IndexOutOfBoundsException("attempt to read past the end");
}
/**
* Throws the exception for when an invalid LEB128 value is encountered
*/
private static void throwInvalidLeb() {
throw new RuntimeException("invalid LEB128 integer encountered");
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/ByteArrayInput.java
|
Java
|
asf20
| 9,850
|
/*
* Copyright (C) 2008 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
/**
* LEB128 (little-endian base 128) utilities.
*/
public final class Leb128Utils {
/**
* This class is uninstantiable.
*/
private Leb128Utils() {
// This space intentionally left blank.
}
/**
* Gets the number of bytes in the unsigned LEB128 encoding of the
* given value.
*
* @param value the value in question
* @return its write size, in bytes
*/
public static int unsignedLeb128Size(int value) {
// TODO: This could be much cleverer.
int remaining = value >>> 7;
int count = 0;
while (remaining != 0) {
value = remaining;
remaining >>>= 7;
count++;
}
return count + 1;
}
/**
* Gets the number of bytes in the signed LEB128 encoding of the
* given value.
*
* @param value the value in question
* @return its write size, in bytes
*/
public static int signedLeb128Size(int value) {
// TODO: This could be much cleverer.
int remaining = value >> 7;
int count = 0;
boolean hasMore = true;
int end = ((value & Integer.MIN_VALUE) == 0) ? 0 : -1;
while (hasMore) {
hasMore = (remaining != end)
|| ((remaining & 1) != ((value >> 6) & 1));
value = remaining;
remaining >>= 7;
count++;
}
return count;
}
/**
* Writes an unsigned leb128 to the buffer at the specified location
* @param value the value to write as an unsigned leb128
* @param buffer the buffer to write to
* @param bufferIndex the index to start writing at
*/
public static void writeUnsignedLeb128(int value, byte[] buffer, int bufferIndex) {
int remaining = value >>> 7;
int count = 0;
while (remaining != 0) {
buffer[bufferIndex] = (byte)((value & 0x7f) | 0x80);
bufferIndex++;
value = remaining;
remaining >>>= 7;
count++;
}
buffer[bufferIndex] = (byte)(value & 0x7f);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/Leb128Utils.java
|
Java
|
asf20
| 2,978
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
import java.util.Arrays;
import java.util.Comparator;
public class ArrayUtils {
/**
* Utility method to sort two related arrays - that is, two arrays where the elements are related to each other
* by their position in the array. i.e. firstArray[0] is related to secondArray[0], firstArray[1] is related to
* secondArray[1], and so on. The first array is sorted based on its implementation of Comparable, and the 2nd
* array is sorted by it's related item in the first array, so that the same elements are still related to each
* other after the sort
* @param firstArray The first array, which contains the values to sort
* @param secondArray The second array, which will be sorted based on the values in the first array
* @param <A> The type of element in the first array
* @param <B> the type of element in the second array
*/
public static <A extends Comparable<A>, B> void sortTwoArrays(A[] firstArray, B[] secondArray)
{
if (firstArray.length != secondArray.length) {
throw new RuntimeException("Both arrays must be of the same length");
}
class element
{
public A first;
public B second;
}
element[] elements = new element[firstArray.length];
Arrays.sort(elements, new Comparator<element>(){
public int compare(element a, element b) {
return a.first.compareTo(b.first);
}
});
for (int i=0; i<elements.length; i++) {
firstArray[i] = elements[i].first;
secondArray[i] = elements[i].second;
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/ArrayUtils.java
|
Java
|
asf20
| 3,181
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
public abstract class AlignmentUtils {
public static int alignOffset(int offset, int alignment) {
int mask = alignment - 1;
assert (alignment >= 0) && ((mask & alignment) == 0);
return (offset + mask) & ~mask;
}
public static boolean isAligned(int offset, int alignment) {
return (offset % alignment) == 0;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/AlignmentUtils.java
|
Java
|
asf20
| 1,891
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
public class NumberUtils {
/**
* Decodes the high signed 4-bit nibble from the given byte
* @param b the byte to decode
* @return the decoded signed nibble
*/
public static byte decodeHighSignedNibble(byte b) {
return (byte)(b >> 4);
}
/**
* Decodes the low signed 4-bit nibble from the given byte
* @param b the byte to decode
* @return the decoded signed nibble
*/
public static byte decodeLowSignedNibble(byte b) {
return (byte)(((byte)(b << 4)) >> 4);
}
/**
* Decodes the high unsigned 4-bit nibble from the given byte
* @param b the byte to decode
* @return the decoded unsigned nibble
*/
public static byte decodeHighUnsignedNibble(byte b) {
return (byte)((b & 0xFF) >>> 4);
}
/**
* Decodes the low unsigned 4-bit nibble from the given byte
* @param b the byte to decode
* @return the decoded unsigned nibble
*/
public static byte decodeLowUnsignedNibble(byte b) {
return (byte)(b & 0x0F);
}
/**
* Decodes an unsigned byte from a signed byte
* @param b the signed byte to decode
* @return the decoded unsigned byte as a short
*/
public static short decodeUnsignedByte(byte b) {
return (short)(b & 0xFF);
}
/**
* Decodes a signed short value from 2 individual bytes
* The parameters are in order from least significant byte to most significant byte
* @param lsb the least significant byte
* @param msb the most significant byte
* @return the decoded signed short value
*/
public static short decodeShort(byte lsb, byte msb) {
return (short)
( (lsb & 0xFF) |
(msb << 8)
);
}
/**
* Decodes a signed short value in little endian format from the given byte array at the given index.
* @param bytes the byte array
* @param index the index of the first byte of the signed short value to decode
* @return the decoded signed short value
*/
public static short decodeShort(byte[] bytes, int index) {
return (short)
( (bytes[index++] & 0xFF) |
(bytes[index] << 8)
);
}
/**
* Decodes an unsigned short value from 2 individual bytes
* The parameters are in order from least significant byte to most significant byte
* @param lsb the least significant byte
* @param msb the most significant byte
* @return the decoded unsigned short value as an int
*/
public static int decodeUnsignedShort(byte lsb, byte msb) {
return ( (lsb & 0xFF) |
((msb & 0xFF) << 8)
);
}
/**
* Decodes an unsigned short value in little endian format from the given byte array at the given index.
* @param bytes the byte array
* @param index the index of the first byte of the unsigned short value to decode
* @return the decoded unsigned short value as an int
*/
public static int decodeUnsignedShort(byte[] bytes, int index) {
return ( (bytes[index++] & 0xFF) |
((bytes[index] & 0xFF) << 8)
);
}
/**
* Decodes a signed integer value from 4 individual bytes
* The parameters are in order from least significant byte to most significant byte
* @param lsb the least significant byte
* @param mlsb the middle least significant byte
* @param mmsb the middle most significant byte
* @param msb the most significant byte
* @return the decoded signed integer value
*/
public static int decodeInt(byte lsb, byte mlsb, byte mmsb, byte msb) {
return (lsb & 0xFF) |
((mlsb & 0xFF) << 8) |
((mmsb & 0xFF) << 16) |
(msb << 24);
}
/**
* Decodes a signed integer value in little endian format from the given byte array at the given index.
* @param bytes the byte array
* @param index the index of the first byte of the signed integer value to decode
* @return the decoded signed integer value
*/
public static int decodeInt(byte[] bytes, int index) {
return (bytes[index++] & 0xFF) |
((bytes[index++] & 0xFF) << 8) |
((bytes[index++] & 0xFF) << 16) |
(bytes[index] << 24);
}
/**
* Decodes a signed long value from 8 individual bytes
* The parameters are in order from least significant byte to most significant byte
* @param llsb the lower least significant byte
* @param lmlsb the lower middle least significant byte
* @param lmmsb the lower middle most significant byte
* @param lgsb the lower greater significant byte
* @param glsb the greater least significant byte
* @param gmlsb the greater middle least significant byte
* @param gmmsb the greater middle most significant byte
* @param gmsb the greater most significant byte
* @return the decoded signed long value
*/
public static long decodeLong(byte llsb, byte lmlsb, byte lmmsb, byte lgsb, byte glsb, byte gmlsb, byte gmmsb,
byte gmsb) {
return (llsb & 0xFFL) |
((lmlsb & 0xFFL) << 8) |
((lmmsb & 0xFFL) << 16) |
((lgsb & 0xFFL) << 24) |
((glsb & 0xFFL) << 32) |
((gmlsb & 0xFFL) << 40) |
((gmmsb & 0xFFL) << 48) |
(((long)gmsb) << 56);
}
/**
* Decodes a signed long value in little endian format from the given byte array at the given index.
* @param bytes the byte array
* @param index the index of the first byte of the signed long value to decode
* @return the decoded signed long value
*/
public static long decodeLong(byte[] bytes, int index) {
return (bytes[index++] & 0xFFL) |
((bytes[index++] & 0xFFL) << 8) |
((bytes[index++] & 0xFFL) << 16) |
((bytes[index++] & 0xFFL) << 24) |
((bytes[index++] & 0xFFL) << 32) |
((bytes[index++] & 0xFFL) << 40) |
((bytes[index++] & 0xFFL) << 48) |
(((long)bytes[index]) << 56);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/NumberUtils.java
|
Java
|
asf20
| 7,841
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
import java.util.AbstractList;
import java.util.RandomAccess;
public class ReadOnlyArrayList<T> extends AbstractList<T> implements RandomAccess {
private final T[] arr;
public ReadOnlyArrayList(T[] arr) {
this.arr = arr;
}
public int size() {
return arr.length;
}
public T get(int i) {
return arr[i];
}
public static <T> ReadOnlyArrayList<T> of(T... items) {
return new ReadOnlyArrayList<T>(items);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/ReadOnlyArrayList.java
|
Java
|
asf20
| 2,007
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* Exception which carries around structured context.
*/
public class ExceptionWithContext
extends RuntimeException {
/** non-null; human-oriented context of the exception */
private StringBuffer context;
/**
* Augments the given exception with the given context, and return the
* result. The result is either the given exception if it was an
* {@link ExceptionWithContext}, or a newly-constructed exception if it
* was not.
*
* @param ex non-null; the exception to augment
* @param str non-null; context to add
* @return non-null; an appropriate instance
*/
public static ExceptionWithContext withContext(Throwable ex, String str) {
ExceptionWithContext ewc;
if (ex instanceof ExceptionWithContext) {
ewc = (ExceptionWithContext) ex;
} else {
ewc = new ExceptionWithContext(ex);
}
ewc.addContext(str);
return ewc;
}
/**
* Constructs an instance.
*
* @param message human-oriented message
*/
public ExceptionWithContext(String message) {
this(message, null);
}
/**
* Constructs an instance.
*
* @param cause null-ok; exception that caused this one
*/
public ExceptionWithContext(Throwable cause) {
this(null, cause);
}
/**
* Constructs an instance.
*
* @param message human-oriented message
* @param cause null-ok; exception that caused this one
*/
public ExceptionWithContext(String message, Throwable cause) {
super((message != null) ? message :
(cause != null) ? cause.getMessage() : null,
cause);
if (cause instanceof ExceptionWithContext) {
String ctx = ((ExceptionWithContext) cause).context.toString();
context = new StringBuffer(ctx.length() + 200);
context.append(ctx);
} else {
context = new StringBuffer(200);
}
}
/** {@inheritDoc} */
@Override
public void printStackTrace(PrintStream out) {
super.printStackTrace(out);
out.println(context);
}
/** {@inheritDoc} */
@Override
public void printStackTrace(PrintWriter out) {
super.printStackTrace(out);
out.println(context);
}
/**
* Adds a line of context to this instance.
*
* @param str non-null; new context
*/
public void addContext(String str) {
if (str == null) {
throw new NullPointerException("str == null");
}
context.append(str);
if (!str.endsWith("\n")) {
context.append('\n');
}
}
/**
* Gets the context.
*
* @return non-null; the context
*/
public String getContext() {
return context.toString();
}
/**
* Prints the message and context.
*
* @param out non-null; where to print to
*/
public void printContext(PrintStream out) {
out.println(getMessage());
out.print(context);
}
/**
* Prints the message and context.
*
* @param out non-null; where to print to
*/
public void printContext(PrintWriter out) {
out.println(getMessage());
out.print(context);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/ExceptionWithContext.java
|
Java
|
asf20
| 4,231
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
public class EncodedValueUtils {
public static byte getRequiredBytesForSignedIntegralValue(long value) {
/*
* Figure out how many bits are needed to represent the value,
* including a sign bit: The bit count is subtracted from 65
* and not 64 to account for the sign bit. The xor operation
* has the effect of leaving non-negative values alone and
* unary complementing negative values (so that a leading zero
* count always returns a useful number for our present
* purpose).
*/
int requiredBits =
65 - Long.numberOfLeadingZeros(value ^ (value >> 63));
// Round up the requiredBits to a number of bytes.
return (byte)((requiredBits + 0x07) >> 3);
}
public static long decodeSignedIntegralValue(byte[] bytes) {
long value = 0;
for (int i = 0; i < bytes.length; i++) {
value |= (((long)(bytes[i] & 0xFF)) << (i * 8));
}
int shift = (8 - bytes.length) * 8;
return value << shift >> shift;
}
public static byte[] encodeSignedIntegralValue(long value) {
int requiredBytes = getRequiredBytesForSignedIntegralValue(value);
byte[] bytes = new byte[requiredBytes];
for (int i = 0; i < requiredBytes; i++) {
bytes[i] = (byte) value;
value >>= 8;
}
return bytes;
}
public static byte getRequiredBytesForUnsignedIntegralValue(long value) {
// Figure out how many bits are needed to represent the value.
int requiredBits = 64 - Long.numberOfLeadingZeros(value);
if (requiredBits == 0) {
requiredBits = 1;
}
// Round up the requiredBits to a number of bytes.
return (byte)((requiredBits + 0x07) >> 3);
}
public static long decodeUnsignedIntegralValue(byte[] bytes) {
long value = 0;
for (int i = 0; i < bytes.length; i++) {
value |= (((long)(bytes[i] & 0xFF)) << i * 8);
}
return value;
}
public static byte[] encodeUnsignedIntegralValue(long value) {
int requiredBytes = getRequiredBytesForUnsignedIntegralValue(value);
byte[] bytes = new byte[requiredBytes];
for (int i = 0; i < requiredBytes; i++) {
bytes[i] = (byte) value;
value >>= 8;
}
return bytes;
}
public static int getRequiredBytesForRightZeroExtendedValue(long value) {
// Figure out how many bits are needed to represent the value.
int requiredBits = 64 - Long.numberOfTrailingZeros(value);
if (requiredBits == 0) {
requiredBits = 1;
}
// Round up the requiredBits to a number of bytes.
return (requiredBits + 0x07) >> 3;
}
public static long decodeRightZeroExtendedValue(byte[] bytes) {
long value = 0;
for (int i = 0; i < bytes.length; i++) {
value |= (((long)(bytes[i] & 0xFF)) << (i * 8));
}
return value << (8 - bytes.length) * 8;
}
public static byte[] encodeRightZeroExtendedValue(long value) {
int requiredBytes = getRequiredBytesForRightZeroExtendedValue(value);
// Scootch the first bits to be written down to the low-order bits.
value >>= 64 - (requiredBytes * 8);
byte[] bytes = new byte[requiredBytes];
for(int i = 0; i < requiredBytes; i++) {
bytes[i] = (byte)value;
value >>= 8;
}
return bytes;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/EncodedValueUtils.java
|
Java
|
asf20
| 5,081
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
/**
* Interface for a binary output destination that may be augmented
* with textual annotations.
*/
public interface AnnotatedOutput
extends Output {
/**
* Get whether this instance will actually keep annotations.
*
* @return <code>true</code> iff annotations are being kept
*/
public boolean annotates();
/**
* Get whether this instance is intended to keep verbose annotations.
* Annotators may use the result of calling this method to inform their
* annotation activity.
*
* @return <code>true</code> iff annotations are to be verbose
*/
public boolean isVerbose();
/**
* Add an annotation for the subsequent output. Any previously
* open annotation will be closed by this call, and the new
* annotation marks all subsequent output until another annotation
* call.
*
* @param msg non-null; the annotation message
*/
public void annotate(String msg);
/**
* Add an annotation for a specified amount of subsequent
* output. Any previously open annotation will be closed by this
* call. If there is already pending annotation from one or more
* previous calls to this method, the new call "consumes" output
* after all the output covered by the previous calls.
*
* @param amt >= 0; the amount of output for this annotation to
* cover
* @param msg non-null; the annotation message
*/
public void annotate(int amt, String msg);
/**
* End the most recent annotation. Subsequent output will be unannotated,
* until the next call to {@link #annotate}.
*/
public void endAnnotation();
/**
* Get the maximum width of the annotated output. This is advisory:
* Implementations of this interface are encouraged to deal with too-wide
* output, but annotaters are encouraged to attempt to avoid exceeding
* the indicated width.
*
* @return >= 1; the maximum width
*/
public int getAnnotationWidth();
public void setIndentAmount(int indentAmount);
public void indent();
public void deindent();
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/AnnotatedOutput.java
|
Java
|
asf20
| 3,013
|
/*
* Copyright (C) 2007 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
/**
* Interface for a source for binary input. This is similar to
* <code>java.util.DataInput</code>, but no <code>IOExceptions</code>
* are declared, and multibyte input is defined to be little-endian.
*/
public interface Input {
/**
* Gets the current cursor position. This is the same as the number of
* bytes read from this instance.
*
* @return >= 0; the cursor position
*/
public int getCursor();
/**
* Sets the current cursor position.
*
* @return >= 0; the cursor position
*/
public void setCursor(int cursor);
/**
* Asserts that the cursor is the given value.
*
* @param expectedCursor the expected cursor value
* @throws RuntimeException thrown if <code>getCursor() !=
* expectedCursor</code>
*/
public void assertCursor(int expectedCursor);
/**
* Reads a <code>byte</code> from this instance.
*
* @return the byte value that was read
*/
public byte readByte();
/**
* Reads a <code>short</code> from this instance.
*
* @return the short value that was read, as an int
*/
public int readShort();
/**
* Reads an <code>int</code> from this instance.
*
* @return the unsigned int value that was read
*/
public int readInt();
/**
* Reads a <code>long</code> from this instance.
*
* @return the long value that was read
*/
public long readLong();
/**
* Reads a DWARFv3-style signed LEB128 integer. For details,
* see the "Dalvik Executable Format" document or DWARF v3 section
* 7.6.
*
* @return the integer value that was read
*/
public int readSignedLeb128();
/**
* Reads a DWARFv3-style unsigned LEB128 integer. For details,
* see the "Dalvik Executable Format" document or DWARF v3 section
* 7.6.
*
* @return the integer value that was read
*/
public int readUnsignedLeb128();
/**
* Reads a unsigned value as a DWARFv3-style LEB128 integer. It specifically
* checks for the case when the value was incorrectly formatted as a signed
* LEB128, and returns the appropriate unsigned value, but negated
* @return If the value was formatted as a ULEB128, it returns the actual unsigned
* value. Otherwise, if the value was formatted as a signed LEB128, it negates the
* "correct" unsigned value and returns that
*/
public int readUnsignedOrSignedLeb128();
/**
* reads a <code>byte[]</code> from this instance.
*
* @param bytes non-null; the buffer to read the data into
* @param offset >= 0; offset into <code>bytes</code> for the first
* byte to write
* @param length >= 0; number of bytes to read
*/
public void read(byte[] bytes, int offset, int length);
/**
* reads a <code>byte[]</code> from this instance. This is just
* a convenient shorthand for <code>read(bytes, 0, bytes.length)</code>.
*
* @param bytes non-null; the buffer to read the data into
*/
public void read(byte[] bytes);
/**
* reads a <code>byte[]</code> from this instance
*
* @param length >= 0; number of bytes to read
* @return a byte array containing <code>length</code> bytes
*/
public byte[] readBytes(int length);
/**
* reads and decodes a null terminated utf8 string from the current cursor up to but not including
* the next null (0) byte. The terminating null byte is read and discarded, so that after the read,
* the cursor is positioned at the byte immediately after the terminating null
*
* @return a string representing the decoded value
*/
public String realNullTerminatedUtf8String();
/**
* Skips the given number of bytes.
*
* @param count >= 0; the number of bytes to skip
*/
public void skipBytes(int count);
/**
* Skip extra bytes if necessary to force alignment of the output
* cursor as given.
*
* @param alignment > 0; the alignment; must be a power of two
*/
public void alignTo(int alignment);
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/Input.java
|
Java
|
asf20
| 5,040
|
/*
* Copyright (C) 2006 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.
*/
/*
* As per the Apache license requirements, this file has been modified
* from its original state.
*
* Such modifications are Copyright (C) 2010 Ben Gruver, and are released
* under the original license
*/
package org.jf.dexlib.Util;
/**
* SparseIntArrays map integers to integers. Unlike a normal array of integers,
* there can be gaps in the indices. It is intended to be more efficient
* than using a HashMap to map Integers to Integers.
*/
public class SparseIntArray {
/**
* Creates a new SparseIntArray containing no mappings.
*/
public SparseIntArray() {
this(10);
}
/**
* Creates a new SparseIntArray containing no mappings that will not
* require any additional memory allocation to store the specified
* number of mappings.
*/
public SparseIntArray(int initialCapacity) {
mKeys = new int[initialCapacity];
mValues = new int[initialCapacity];
mSize = 0;
}
/**
* Gets the int mapped from the specified key, or <code>0</code>
* if no such mapping has been made.
*/
public int get(int key) {
return get(key, 0);
}
/**
* Gets the int mapped from the specified key, or the specified value
* if no such mapping has been made.
*/
public int get(int key, int valueIfKeyNotFound) {
int i = binarySearch(mKeys, 0, mSize, key);
if (i < 0) {
return valueIfKeyNotFound;
} else {
return mValues[i];
}
}
/**
* Gets the int mapped from the specified key, or if not present, the
* closest key that is less than the specified key.
*/
public int getClosestSmaller(int key) {
int i = binarySearch(mKeys, 0, mSize, key);
if (i < 0) {
i = ~i;
if (i > 0) {
i--;
}
return mValues[i];
} else {
return mValues[i];
}
}
/**
* Removes the mapping from the specified key, if there was any.
*/
public void delete(int key) {
int i = binarySearch(mKeys, 0, mSize, key);
if (i >= 0) {
removeAt(i);
}
}
/**
* Removes the mapping at the given index.
*/
public void removeAt(int index) {
System.arraycopy(mKeys, index + 1, mKeys, index, mSize - (index + 1));
System.arraycopy(mValues, index + 1, mValues, index, mSize - (index + 1));
mSize--;
}
/**
* Adds a mapping from the specified key to the specified value,
* replacing the previous mapping from the specified key if there
* was one.
*/
public void put(int key, int value) {
int i = binarySearch(mKeys, 0, mSize, key);
if (i >= 0) {
mValues[i] = value;
} else {
i = ~i;
if (mSize >= mKeys.length) {
int n = Math.max(mSize + 1, mKeys.length * 2);
int[] nkeys = new int[n];
int[] nvalues = new int[n];
// Log.e("SparseIntArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
if (mSize - i != 0) {
// Log.e("SparseIntArray", "move " + (mSize - i));
System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
}
mKeys[i] = key;
mValues[i] = value;
mSize++;
}
}
/**
* Returns the number of key-value mappings that this SparseIntArray
* currently stores.
*/
public int size() {
return mSize;
}
/**
* Given an index in the range <code>0...size()-1</code>, returns
* the key from the <code>index</code>th key-value mapping that this
* SparseIntArray stores.
*/
public int keyAt(int index) {
return mKeys[index];
}
/**
* Given an index in the range <code>0...size()-1</code>, returns
* the value from the <code>index</code>th key-value mapping that this
* SparseIntArray stores.
*/
public int valueAt(int index) {
return mValues[index];
}
/**
* Returns the index for which {@link #keyAt} would return the
* specified key, or a negative number if the specified
* key is not mapped.
*/
public int indexOfKey(int key) {
return binarySearch(mKeys, 0, mSize, key);
}
/**
* Returns an index for which {@link #valueAt} would return the
* specified key, or a negative number if no keys map to the
* specified value.
* Beware that this is a linear search, unlike lookups by key,
* and that multiple keys can map to the same value and this will
* find only one of them.
*/
public int indexOfValue(int value) {
for (int i = 0; i < mSize; i++)
if (mValues[i] == value)
return i;
return -1;
}
/**
* Removes all key-value mappings from this SparseIntArray.
*/
public void clear() {
mSize = 0;
}
/**
* Puts a key/value pair into the array, optimizing for the case where
* the key is greater than all existing keys in the array.
*/
public void append(int key, int value) {
if (mSize != 0 && key <= mKeys[mSize - 1]) {
put(key, value);
return;
}
int pos = mSize;
if (pos >= mKeys.length) {
int n = Math.max(pos + 1, mKeys.length * 2);
int[] nkeys = new int[n];
int[] nvalues = new int[n];
// Log.e("SparseIntArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
mKeys[pos] = key;
mValues[pos] = value;
mSize = pos + 1;
}
private static int binarySearch(int[] a, int start, int len, int key) {
int high = start + len, low = start - 1, guess;
while (high - low > 1) {
guess = (high + low) / 2;
if (a[guess] < key)
low = guess;
else
high = guess;
}
if (high == start + len)
return ~(start + len);
else if (a[high] == key)
return high;
else
return ~high;
}
private int[] mKeys;
private int[] mValues;
private int mSize;
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/SparseIntArray.java
|
Java
|
asf20
| 7,366
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
/**
* Utilities for formatting numbers as hexadecimal.
*/
public final class Hex {
/**
* This class is uninstantiable.
*/
private Hex() {
// This space intentionally left blank.
}
/**
* Formats a <code>long</code> as an 8-byte unsigned hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String u8(long v) {
char[] result = new char[16];
for (int i = 0; i < 16; i++) {
result[15 - i] = Character.forDigit((int) v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as a 4-byte unsigned hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String u4(int v) {
char[] result = new char[8];
for (int i = 0; i < 8; i++) {
result[7 - i] = Character.forDigit(v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as a 3-byte unsigned hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String u3(int v) {
char[] result = new char[6];
for (int i = 0; i < 6; i++) {
result[5 - i] = Character.forDigit(v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as a 2-byte unsigned hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String u2(int v) {
char[] result = new char[4];
for (int i = 0; i < 4; i++) {
result[3 - i] = Character.forDigit(v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as either a 2-byte unsigned hex value
* (if the value is small enough) or a 4-byte unsigned hex value (if
* not).
*
* @param v value to format
* @return non-null; formatted form
*/
public static String u2or4(int v) {
if (v == (char) v) {
return u2(v);
} else {
return u4(v);
}
}
/**
* Formats an <code>int</code> as a 1-byte unsigned hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String u1(int v) {
char[] result = new char[2];
for (int i = 0; i < 2; i++) {
result[1 - i] = Character.forDigit(v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as a 4-bit unsigned hex nibble.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String uNibble(int v) {
char[] result = new char[1];
result[0] = Character.forDigit(v & 0x0f, 16);
return new String(result);
}
/**
* Formats a <code>long</code> as an 8-byte signed hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String s8(long v) {
char[] result = new char[17];
if (v < 0) {
result[0] = '-';
v = -v;
} else {
result[0] = '+';
}
for (int i = 0; i < 16; i++) {
result[16 - i] = Character.forDigit((int) v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as a 4-byte signed hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String s4(int v) {
char[] result = new char[9];
if (v < 0) {
result[0] = '-';
v = -v;
} else {
result[0] = '+';
}
for (int i = 0; i < 8; i++) {
result[8 - i] = Character.forDigit(v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as a 2-byte signed hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String s2(int v) {
char[] result = new char[5];
if (v < 0) {
result[0] = '-';
v = -v;
} else {
result[0] = '+';
}
for (int i = 0; i < 4; i++) {
result[4 - i] = Character.forDigit(v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats an <code>int</code> as a 1-byte signed hex value.
*
* @param v value to format
* @return non-null; formatted form
*/
public static String s1(int v) {
char[] result = new char[3];
if (v < 0) {
result[0] = '-';
v = -v;
} else {
result[0] = '+';
}
for (int i = 0; i < 2; i++) {
result[2 - i] = Character.forDigit(v & 0x0f, 16);
v >>= 4;
}
return new String(result);
}
/**
* Formats a hex dump of a portion of a <code>byte[]</code>. The result
* is always newline-terminated, unless the passed-in length was zero,
* in which case the result is always the empty string (<code>""</code>).
*
* @param arr non-null; array to format
* @param offset >= 0; offset to the part to dump
* @param length >= 0; number of bytes to dump
* @param outOffset >= 0; first output offset to print
* @param bpl >= 0; number of bytes of output per line
* @param addressLength {2,4,6,8}; number of characters for each address
* header
* @return non-null; a string of the dump
*/
public static String dump(byte[] arr, int offset, int length,
int outOffset, int bpl, int addressLength) {
int end = offset + length;
// twos-complement math trick: ((x < 0) || (y < 0)) <=> ((x|y) < 0)
if (((offset | length | end) < 0) || (end > arr.length)) {
throw new IndexOutOfBoundsException("arr.length " +
arr.length + "; " +
offset + "..!" + end);
}
if (outOffset < 0) {
throw new IllegalArgumentException("outOffset < 0");
}
if (length == 0) {
return "";
}
StringBuffer sb = new StringBuffer(length * 4 + 6);
boolean bol = true;
int col = 0;
while (length > 0) {
if (col == 0) {
String astr;
switch (addressLength) {
case 2: astr = Hex.u1(outOffset); break;
case 4: astr = Hex.u2(outOffset); break;
case 6: astr = Hex.u3(outOffset); break;
default: astr = Hex.u4(outOffset); break;
}
sb.append(astr);
sb.append(": ");
} else if ((col & 1) == 0) {
sb.append(' ');
}
sb.append(Hex.u1(arr[offset]));
outOffset++;
offset++;
col++;
if (col == bpl) {
sb.append('\n');
col = 0;
}
length--;
}
if (col != 0) {
sb.append('\n');
}
return sb.toString();
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/Hex.java
|
Java
|
asf20
| 9,077
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
import org.jf.dexlib.EncodedValue.*;
import org.jf.dexlib.TypeIdItem;
public class TypeUtils
{
public static EncodedValue makeDefaultValueForType(String type) {
switch (type.charAt(0)) {
case 'Z':
return BooleanEncodedValue.FalseValue;
case 'B':
return new ByteEncodedValue((byte)0);
case 'S':
return new ShortEncodedValue((short)0);
case 'C':
return new CharEncodedValue((char)0);
case 'I':
return new IntEncodedValue(0);
case 'J':
return new LongEncodedValue(0);
case 'F':
return new FloatEncodedValue(0);
case 'D':
return new DoubleEncodedValue(0);
case 'L':
case '[':
return NullEncodedValue.NullValue;
}
return null;
}
public static EncodedValue makeDefaultValueForType(TypeIdItem type) {
return makeDefaultValueForType(type.getTypeDescriptor());
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/TypeUtils.java
|
Java
|
asf20
| 2,601
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.Util;
/**
* Interface for a sink for binary output. This is similar to
* <code>java.util.DataOutput</code>, but no <code>IOExceptions</code>
* are declared, and multibyte output is defined to be little-endian.
*/
public interface Output {
/**
* Gets the current cursor position. This is the same as the number of
* bytes written to this instance.
*
* @return >= 0; the cursor position
*/
public int getCursor();
/**
* Asserts that the cursor is the given value.
*
* @param expectedCursor the expected cursor value
* @throws RuntimeException thrown if <code>getCursor() !=
* expectedCursor</code>
*/
public void assertCursor(int expectedCursor);
/**
* Writes a <code>byte</code> to this instance.
*
* @param value the value to write; all but the low 8 bits are ignored
*/
public void writeByte(int value);
/**
* Writes a <code>short</code> to this instance.
*
* @param value the value to write; all but the low 16 bits are ignored
*/
public void writeShort(int value);
/**
* Writes an <code>int</code> to this instance.
*
* @param value the value to write
*/
public void writeInt(int value);
/**
* Writes a <code>long</code> to this instance.
*
* @param value the value to write
*/
public void writeLong(long value);
/**
* Writes a DWARFv3-style unsigned LEB128 integer. For details,
* see the "Dalvik Executable Format" document or DWARF v3 section
* 7.6.
*
* @param value value to write, treated as an unsigned value
* @return 1..5; the number of bytes actually written
*/
public int writeUnsignedLeb128(int value);
/**
* Writes a DWARFv3-style unsigned LEB128 integer. For details,
* see the "Dalvik Executable Format" document or DWARF v3 section
* 7.6.
*
* @param value value to write
* @return 1..5; the number of bytes actually written
*/
public int writeSignedLeb128(int value);
/**
* Writes a {@link org.jf.dexlib.Util.ByteArray} to this instance.
*
* @param bytes non-null; the array to write
*/
public void write(ByteArray bytes);
/**
* Writes a portion of a <code>byte[]</code> to this instance.
*
* @param bytes non-null; the array to write
* @param offset >= 0; offset into <code>bytes</code> for the first
* byte to write
* @param length >= 0; number of bytes to write
*/
public void write(byte[] bytes, int offset, int length);
/**
* Writes a <code>byte[]</code> to this instance. This is just
* a convenient shorthand for <code>write(bytes, 0, bytes.length)</code>.
*
* @param bytes non-null; the array to write
*/
public void write(byte[] bytes);
/**
* Writes the given number of <code>0</code> bytes.
*
* @param count >= 0; the number of zeroes to write
*/
public void writeZeroes(int count);
/**
* Adds extra bytes if necessary (with value <code>0</code>) to
* force alignment of the output cursor as given.
*
* @param alignment > 0; the alignment; must be a power of two
*/
public void alignTo(int alignment);
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/Util/Output.java
|
Java
|
asf20
| 4,821
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.EncodedValue.ArrayEncodedSubValue;
import org.jf.dexlib.EncodedValue.EncodedValue;
import org.jf.dexlib.Util.AccessFlags;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.TypeUtils;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.*;
public class ClassDefItem extends Item<ClassDefItem> {
private TypeIdItem classType;
private int accessFlags;
private @Nullable TypeIdItem superType;
private @Nullable TypeListItem implementedInterfaces;
private @Nullable StringIdItem sourceFile;
private @Nullable AnnotationDirectoryItem annotations;
private @Nullable ClassDataItem classData;
private @Nullable EncodedArrayItem staticFieldInitializers;
/**
* Creates a new uninitialized <code>ClassDefItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected ClassDefItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>ClassDefItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType The type of this class
* @param accessFlags The access flags of this class
* @param superType The superclass of this class, or null if none (only valid for java.lang.Object)
* @param implementedInterfaces A list of the interfaces that this class implements, or null if none
* @param sourceFile The main source file that this class is defined in, or null if not available
* @param annotations The annotations for this class and its fields, methods and method parameters, or null if none
* @param classData The <code>ClassDataItem</code> containing the method and field definitions for this class
* @param staticFieldInitializers The initial values for this class's static fields, or null if none. The initial
* values should be in the same order as the static fields in the <code>ClassDataItem</code>. It can contain
* fewer items than static fields, in which case the remaining static fields will be initialized with a default
* value of null/0. The initial value for any fields that don't specifically have a value can be either the
* type-appropriate null/0 encoded value, or null.
*/
private ClassDefItem(DexFile dexFile, TypeIdItem classType, int accessFlags, @Nullable TypeIdItem superType,
@Nullable TypeListItem implementedInterfaces, @Nullable StringIdItem sourceFile,
@Nullable AnnotationDirectoryItem annotations, @Nullable ClassDataItem classData,
@Nullable EncodedArrayItem staticFieldInitializers) {
super(dexFile);
assert classType != null;
this.classType = classType;
this.accessFlags = accessFlags;
this.superType = superType;
this.implementedInterfaces = implementedInterfaces;
this.sourceFile = sourceFile;
this.annotations = annotations;
this.classData = classData;
this.staticFieldInitializers = staticFieldInitializers;
}
/**
* Returns a <code>ClassDefItem</code> for the given values, and that has been interned into the given
* <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType The type of this class
* @param accessFlags The access flags of this class
* @param superType The superclass of this class, or null if none (only valid for java.lang.Object)
* @param implementedInterfaces A list of the interfaces that this class implements, or null if none
* @param sourceFile The main source file that this class is defined in, or null if not available
* @param annotations The annotations for this class and its fields, methods and method parameters, or null if none
* @param classData The <code>ClassDataItem</code> containing the method and field definitions for this class
* @param staticFieldInitializers The initial values for this class's static fields, or null if none. If it is not
* null, it must contain the same number of items as the number of static fields in this class. The value in the
* <code>StaticFieldInitializer</code> for any field that doesn't have an explicit initial value can either be null
* or be the type-appropriate null/0 value.
* @return a <code>ClassDefItem</code> for the given values, and that has been interned into the given
* <code>DexFile</code>
*/
public static ClassDefItem internClassDefItem(DexFile dexFile, TypeIdItem classType, int accessFlags,
@Nullable TypeIdItem superType, @Nullable TypeListItem implementedInterfaces,
@Nullable StringIdItem sourceFile, @Nullable AnnotationDirectoryItem annotations,
@Nullable ClassDataItem classData,
@Nullable List<StaticFieldInitializer> staticFieldInitializers) {
EncodedArrayItem encodedArrayItem = null;
if(!dexFile.getInplace() && staticFieldInitializers != null && staticFieldInitializers.size() > 0) {
assert classData != null;
assert staticFieldInitializers.size() == classData.getStaticFieldCount();
encodedArrayItem = makeStaticFieldInitializersItem(dexFile, staticFieldInitializers);
}
ClassDefItem classDefItem = new ClassDefItem(dexFile, classType, accessFlags, superType, implementedInterfaces,
sourceFile, annotations, classData, encodedArrayItem);
return dexFile.ClassDefsSection.intern(classDefItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
classType = dexFile.TypeIdsSection.getItemByIndex(in.readInt());
accessFlags = in.readInt();
superType = dexFile.TypeIdsSection.getOptionalItemByIndex(in.readInt());
implementedInterfaces = (TypeListItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_TYPE_LIST,
in.readInt());
sourceFile = dexFile.StringIdsSection.getOptionalItemByIndex(in.readInt());
annotations = (AnnotationDirectoryItem)readContext.getOptionalOffsettedItemByOffset(
ItemType.TYPE_ANNOTATIONS_DIRECTORY_ITEM, in.readInt());
classData = (ClassDataItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_CLASS_DATA_ITEM, in.readInt());
staticFieldInitializers = (EncodedArrayItem)readContext.getOptionalOffsettedItemByOffset(
ItemType.TYPE_ENCODED_ARRAY_ITEM, in.readInt());
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 32;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(4, "class_type: " + classType.getTypeDescriptor());
out.annotate(4, "access_flags: " + AccessFlags.formatAccessFlagsForClass(accessFlags));
out.annotate(4, "superclass_type: " + (superType==null?"":superType.getTypeDescriptor()));
out.annotate(4, "interfaces: " +
(implementedInterfaces==null?"":implementedInterfaces.getTypeListString(" ")));
out.annotate(4, "source_file: " + (sourceFile==null?"":sourceFile.getStringValue()));
out.annotate(4, "annotations_off: " +
(annotations==null?"":"0x"+Integer.toHexString(annotations.getOffset())));
out.annotate(4, "class_data_off:" +
(classData==null?"":"0x"+Integer.toHexString(classData.getOffset())));
out.annotate(4, "static_values_off: " +
(staticFieldInitializers==null?"":"0x"+Integer.toHexString(staticFieldInitializers.getOffset())));
}
out.writeInt(classType.getIndex());
out.writeInt(accessFlags);
out.writeInt(superType==null?-1:superType.getIndex());
out.writeInt(implementedInterfaces==null?0:implementedInterfaces.getOffset());
out.writeInt(sourceFile==null?-1:sourceFile.getIndex());
out.writeInt(annotations==null?0:annotations.getOffset());
out.writeInt(classData==null?0:classData.getOffset());
out.writeInt(staticFieldInitializers==null?0:staticFieldInitializers.getOffset());
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_CLASS_DEF_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "class_def_item: " + classType.getTypeDescriptor();
}
/** {@inheritDoc} */
public int compareTo(ClassDefItem o) {
//The actual sorting for this class is done during the placement phase, in ClassDefPlacer.
//This method is just used for sorting the associated ClassDataItem items after the ClassDefItems have been
//placed, so we can just do the comparison based on the offsets
return this.getOffset() - o.getOffset();
}
public TypeIdItem getClassType() {
return classType;
}
public int getAccessFlags() {
return accessFlags;
}
@Nullable
public TypeIdItem getSuperclass() {
return superType;
}
@Nullable
public TypeListItem getInterfaces() {
return implementedInterfaces;
}
@Nullable
public StringIdItem getSourceFile() {
return sourceFile;
}
@Nullable
public AnnotationDirectoryItem getAnnotations() {
return annotations;
}
@Nullable
public ClassDataItem getClassData() {
return classData;
}
@Nullable
public EncodedArrayItem getStaticFieldInitializers() {
return staticFieldInitializers;
}
public static int placeClassDefItems(IndexedSection<ClassDefItem> section, int offset) {
ClassDefPlacer cdp = new ClassDefPlacer(section);
return cdp.placeSection(offset);
}
/**
* This class places the items within a ClassDefItem section, such that superclasses and interfaces are
* placed before sub/implementing classes
*/
private static class ClassDefPlacer {
private final IndexedSection<ClassDefItem> section;
private final HashMap<TypeIdItem, ClassDefItem> unplacedClassDefsByType =
new HashMap<TypeIdItem, ClassDefItem>();
private int currentIndex = 0;
private int currentOffset;
public ClassDefPlacer(IndexedSection<ClassDefItem> section) {
this.section = section;
for (ClassDefItem classDefItem: section.items) {
TypeIdItem typeIdItem = classDefItem.classType;
unplacedClassDefsByType.put(typeIdItem, classDefItem);
}
}
public int placeSection(int offset) {
currentOffset = offset;
if (section.DexFile.getSortAllItems()) {
//presort the list, to guarantee a unique ordering
Collections.sort(section.items, new Comparator<ClassDefItem>() {
public int compare(ClassDefItem a, ClassDefItem b) {
return a.getClassType().compareTo(b.getClassType());
}
});
}
//we need to initialize the offset for all the classes to -1, so we can tell which ones
//have been placed
for (ClassDefItem classDefItem: section.items) {
classDefItem.offset = -1;
}
for (ClassDefItem classDefItem: section.items) {
placeClass(classDefItem);
}
for (ClassDefItem classDefItem: unplacedClassDefsByType.values()) {
section.items.set(classDefItem.getIndex(), classDefItem);
}
return currentOffset;
}
private void placeClass(ClassDefItem classDefItem) {
if (!classDefItem.isPlaced()) {
TypeIdItem superType = classDefItem.superType;
ClassDefItem superClassDefItem = unplacedClassDefsByType.get(superType);
if (superClassDefItem != null) {
placeClass(superClassDefItem);
}
TypeListItem interfaces = classDefItem.implementedInterfaces;
if (interfaces != null) {
for (TypeIdItem interfaceType: interfaces.getTypes()) {
ClassDefItem interfaceClass = unplacedClassDefsByType.get(interfaceType);
if (interfaceClass != null) {
placeClass(interfaceClass);
}
}
}
currentOffset = classDefItem.placeAt(currentOffset, currentIndex++);
unplacedClassDefsByType.remove(classDefItem.classType);
}
}
}
public static class StaticFieldInitializer implements Comparable<StaticFieldInitializer> {
public final EncodedValue value;
public final ClassDataItem.EncodedField field;
public StaticFieldInitializer(EncodedValue value, ClassDataItem.EncodedField field) {
this.value = value;
this.field = field;
}
public int compareTo(StaticFieldInitializer other) {
return field.compareTo(other.field);
}
}
/**
* A helper method to sort the static field initializers and populate the default values as needed
* @param dexFile the <code>DexFile</code>
* @param staticFieldInitializers the initial values
* @return an interned EncodedArrayItem containing the static field initializers
*/
private static EncodedArrayItem makeStaticFieldInitializersItem(DexFile dexFile,
@Nonnull List<StaticFieldInitializer> staticFieldInitializers) {
if (staticFieldInitializers.size() == 0) {
return null;
}
int len = staticFieldInitializers.size();
// make a copy before sorting. we don't want to modify the list passed to us
staticFieldInitializers = new ArrayList<StaticFieldInitializer>(staticFieldInitializers);
Collections.sort(staticFieldInitializers);
int lastIndex = -1;
for (int i=len-1; i>=0; i--) {
StaticFieldInitializer staticFieldInitializer = staticFieldInitializers.get(i);
if (staticFieldInitializer.value != null &&
(staticFieldInitializer.value.compareTo(TypeUtils.makeDefaultValueForType(
staticFieldInitializer.field.field.getFieldType())) != 0)) {
lastIndex = i;
break;
}
}
//we don't have any non-null/non-default values, so we don't need to create an EncodedArrayItem
if (lastIndex == -1) {
return null;
}
EncodedValue[] values = new EncodedValue[lastIndex+1];
for (int i=0; i<=lastIndex; i++) {
StaticFieldInitializer staticFieldInitializer = staticFieldInitializers.get(i);
EncodedValue encodedValue = staticFieldInitializer.value;
if (encodedValue == null) {
encodedValue = TypeUtils.makeDefaultValueForType(staticFieldInitializer.field.field.getFieldType());
}
values[i] = encodedValue;
}
ArrayEncodedSubValue encodedArrayValue = new ArrayEncodedSubValue(values);
return EncodedArrayItem.internEncodedArrayItem(dexFile, encodedArrayValue);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/ClassDefItem.java
|
Java
|
asf20
| 17,056
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public class ProtoIdItem extends Item<ProtoIdItem> {
private int hashCode = 0;
private StringIdItem shortyDescriptor;
private TypeIdItem returnType;
private TypeListItem parameters;
/**
* Creates a new uninitialized <code>ProtoIdItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected ProtoIdItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>ProtoIdItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param returnType the return type
* @param parameters a <code>TypeListItem</code> containing a list of the parameter types
*/
private ProtoIdItem(DexFile dexFile, TypeIdItem returnType, TypeListItem parameters) {
this(dexFile);
String shortyString = returnType.toShorty();
if (parameters != null) {
shortyString += parameters.getShortyString();
}
this.shortyDescriptor = StringIdItem.internStringIdItem(dexFile, shortyString);
this.returnType = returnType;
this.parameters = parameters;
}
/**
* Returns a <code>ProtoIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param returnType the return type
* @param parameters a <code>TypeListItem</code> containing a list of the parameter types
* @return a <code>ProtoIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static ProtoIdItem internProtoIdItem(DexFile dexFile, TypeIdItem returnType, TypeListItem parameters) {
ProtoIdItem protoIdItem = new ProtoIdItem(dexFile, returnType, parameters);
return dexFile.ProtoIdsSection.intern(protoIdItem);
}
/**
* Looks up the <code>ProtoIdItem</code> from the given <code>DexFile</code> for the given
* values
* @param dexFile the <code>Dexfile</code> to find the type in
* @param returnType the return type
* @param parameters a <code>TypeListItem</code> containing a list of the parameter types
* @return a <code>ProtoIdItem</code> from the given <code>DexFile</code> for the given
* values, or null if it doesn't exist
*/
public static ProtoIdItem lookupProtoIdItem(DexFile dexFile, TypeIdItem returnType, TypeListItem parameters) {
ProtoIdItem protoIdItem = new ProtoIdItem(dexFile, returnType, parameters);
return dexFile.ProtoIdsSection.getInternedItem(protoIdItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
shortyDescriptor = dexFile.StringIdsSection.getItemByIndex(in.readInt());
returnType = dexFile.TypeIdsSection.getItemByIndex(in.readInt());
parameters = (TypeListItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_TYPE_LIST, in.readInt());
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 12;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(4, "shorty_descriptor: " + shortyDescriptor.getStringValue());
out.annotate(4, "return_type: " + returnType.getTypeDescriptor());
if (parameters == null) {
out.annotate(4, "parameters:");
} else {
out.annotate(4, "parameters: " + parameters.getTypeListString(""));
}
}
out.writeInt(shortyDescriptor.getIndex());
out.writeInt(returnType.getIndex());
out.writeInt(parameters == null?0:parameters.getOffset());
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_PROTO_ID_ITEM;
}
/** {@inheritDoc} */
public int compareTo(ProtoIdItem o) {
int result = returnType.compareTo(o.returnType);
if (result != 0) {
return result;
}
if (parameters == null) {
if (o.parameters == null) {
return 0;
}
return -1;
} else if (o.parameters == null) {
return 1;
}
return parameters.compareTo(o.parameters);
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "proto_id_item: " + getPrototypeString();
}
private String cachedPrototypeString = null;
/**
* @return a string in the format (TTTT..)R where TTTT.. are the parameter types and R is the return type
*/
public String getPrototypeString() {
if (cachedPrototypeString == null) {
StringBuilder sb = new StringBuilder("(");
if (parameters != null) {
sb.append(parameters.getTypeListString(""));
}
sb.append(")");
sb.append(returnType.getTypeDescriptor());
cachedPrototypeString = sb.toString();
}
return cachedPrototypeString;
}
/**
* @return the return type of the method
*/
public TypeIdItem getReturnType() {
return returnType;
}
/**
* @return a <code>TypeListItem</code> containing the method parameter types
*/
public TypeListItem getParameters() {
return parameters;
}
/**
* @return the number of registers required for the parameters of this <code>ProtoIdItem</code>
*/
public int getParameterRegisterCount() {
if (parameters == null) {
return 0;
} else {
return parameters.getRegisterCount();
}
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = returnType.hashCode();
hashCode = 31 * hashCode + (parameters==null?0:parameters.hashCode());
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
//This assumes that the referenced items have been interned in both objects.
//This is a valid assumption because all outside code must use the static
//"getInterned..." style methods to make new items, and any item created
//internally is guaranteed to be interned
ProtoIdItem other = (ProtoIdItem)o;
return (returnType == other.returnType &&
parameters == other.parameters);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/ProtoIdItem.java
|
Java
|
asf20
| 8,467
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.ExceptionWithContext;
import org.jf.dexlib.Util.SparseArray;
import java.util.List;
/**
* This class stores context information that is only needed when reading in a dex file
* Namely, it handles "pre-creating" items when an item needs to resolve some other item
* that it references, and keeps track of those pre-created items, so the corresponding section
* for the pre-created items uses them, instead of creating new items
*/
public class ReadContext {
private SparseArray<TypeListItem> typeListItems = new SparseArray<TypeListItem>(0);
private SparseArray<AnnotationSetRefList> annotationSetRefLists = new SparseArray<AnnotationSetRefList>(0);
private SparseArray<AnnotationSetItem> annotationSetItems = new SparseArray<AnnotationSetItem>(0);
private SparseArray<ClassDataItem> classDataItems = new SparseArray<ClassDataItem>(0);
private SparseArray<CodeItem> codeItems = new SparseArray<CodeItem>(0);
private SparseArray<StringDataItem> stringDataItems = new SparseArray<StringDataItem>(0);
private SparseArray<DebugInfoItem> debugInfoItems = new SparseArray<DebugInfoItem>(0);
private SparseArray<AnnotationItem> annotationItems = new SparseArray<AnnotationItem>(0);
private SparseArray<EncodedArrayItem> encodedArrayItems = new SparseArray<EncodedArrayItem>(0);
private SparseArray<AnnotationDirectoryItem> annotationDirectoryItems = new SparseArray<AnnotationDirectoryItem>(0);
private SparseArray[] itemsByType = new SparseArray[] {
null, //string_id_item
null, //type_id_item
null, //proto_id_item
null, //field_id_item
null, //method_id_item
null, //class_def_item
typeListItems,
annotationSetRefLists,
annotationSetItems,
classDataItems,
codeItems,
stringDataItems,
debugInfoItems,
annotationItems,
encodedArrayItems,
annotationDirectoryItems,
null, //map_list
null //header_item
};
/**
* The section sizes that are passed in while reading HeaderItem/MapItem, via the
* addSection method.
*/
private int[] sectionSizes = new int[18];
/**
* The section offsets that are passed in while reading MapItem/HeaderItem, via the
* addSection method.
*/
private int[] sectionOffsets = new int[18];
/**
* Creates a new ReadContext instance.
*/
public ReadContext() {
for (int i=0; i<18; i++) {
sectionSizes[i] = -1;
sectionOffsets[i] = -1;
}
}
/**
* Gets the offsetted item of the specified type for the given offset. This method does not support retrieving an
* optional item where a value of 0 indicates "not present". Use getOptionalOffsettedItemByOffset instead.
*
* @param itemType The type of item to get
* @param offset The offset of the item
* @return the offsetted item of the specified type at the specified offset
*/
public Item getOffsettedItemByOffset(ItemType itemType, int offset) {
assert !itemType.isIndexedItem();
SparseArray<Item> sa = itemsByType[itemType.SectionIndex];
Item item = sa.get(offset);
if (item == null) {
throw new ExceptionWithContext(String.format("Could not find the %s item at offset %#x",
itemType.TypeName, offset));
}
return item;
}
/**
* Gets the optional offsetted item of the specified type for the given offset
*
* @param itemType The type of item to get
* @param offset The offset of the item
* @return the offsetted item of the specified type at the specified offset, or null if the offset is 0
*/
public Item getOptionalOffsettedItemByOffset(ItemType itemType, int offset) {
assert !itemType.isIndexedItem();
assert !itemType.isIndexedItem();
SparseArray<Item> sa = itemsByType[itemType.SectionIndex];
Item item = sa.get(offset);
if (item == null && offset != 0) {
throw new ExceptionWithContext(String.format("Could not find the %s item at offset %#x",
itemType.TypeName, offset));
}
return item;
}
/**
* Adds the size and offset information for the given offset
* @param itemType the item type of the section
* @param sectionSize the size of the section
* @param sectionOffset the offset of the section
*/
public void addSection(final ItemType itemType, int sectionSize, int sectionOffset) {
int storedSectionSize = sectionSizes[itemType.SectionIndex];
if (storedSectionSize == -1) {
sectionSizes[itemType.SectionIndex] = sectionSize;
} else {
if (storedSectionSize != sectionSize) {
throw new RuntimeException("The section size in the header and map for item type "
+ itemType + " do not match");
}
}
int storedSectionOffset = sectionOffsets[itemType.SectionIndex];
if (storedSectionOffset == -1) {
sectionOffsets[itemType.SectionIndex] = sectionOffset;
} else {
if (storedSectionOffset != sectionOffset) {
throw new RuntimeException("The section offset in the header and map for item type "
+ itemType + " do not match");
}
}
}
/**
* Sets the items for the specified section. This should be called by an offsetted section
* after it is finished reading in all its items.
* @param itemType the item type of the section. This must be an offsetted item type
* @param items the full list of items in the section, ordered by offset
*/
public void setItemsForSection(ItemType itemType, List<? extends Item> items) {
assert !itemType.isIndexedItem();
SparseArray<Item> sa = itemsByType[itemType.SectionIndex];
sa.ensureCapacity(items.size());
for (Item item: items) {
sa.append(item.getOffset(), item);
}
}
/**
* @param itemType the item type of the section
* @return the size of the given section as it was read in from the map item
*/
public int getSectionSize(ItemType itemType) {
return sectionSizes[itemType.SectionIndex];
}
/**
* @param itemType the item type of the section
* @return the offset of the given section as it was read in from the map item
*/
public int getSectionOffset(ItemType itemType) {
return sectionOffsets[itemType.SectionIndex];
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/ReadContext.java
|
Java
|
asf20
| 8,228
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public class MethodIdItem extends Item<MethodIdItem> implements Convertible<MethodIdItem> {
private int hashCode = 0;
private TypeIdItem classType;
private ProtoIdItem methodPrototype;
private StringIdItem methodName;
/**
* Creates a new uninitialized <code>MethodIdItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected MethodIdItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>MethodIdItem</code> for the given class, type and name
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType the class that the method is a member of
* @param methodPrototype the type of the method
* @param methodName the name of the method
*/
private MethodIdItem(DexFile dexFile, TypeIdItem classType, ProtoIdItem methodPrototype, StringIdItem methodName) {
this(dexFile);
this.classType = classType;
this.methodPrototype = methodPrototype;
this.methodName = methodName;
}
/**
* Returns a <code>MethodIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType the class that the method is a member of
* @param methodPrototype the type of the method
* @param methodName the name of the method
* @return a <code>MethodIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static MethodIdItem internMethodIdItem(DexFile dexFile, TypeIdItem classType,
ProtoIdItem methodPrototype, StringIdItem methodName) {
MethodIdItem methodIdItem = new MethodIdItem(dexFile, classType, methodPrototype, methodName);
return dexFile.MethodIdsSection.intern(methodIdItem);
}
/**
* Looks up a <code>MethodIdItem</code> from the given <code>DexFile</code> for the given
* values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param classType the class that the method is a member of
* @param methodPrototype the type of the method
* @param methodName the name of the method
* @return a <code>MethodIdItem</code> from the given <code>DexFile</code> for the given
* values, or null if it doesn't exist
*/
public static MethodIdItem lookupMethodIdItem(DexFile dexFile, TypeIdItem classType,
ProtoIdItem methodPrototype, StringIdItem methodName) {
MethodIdItem methodIdItem = new MethodIdItem(dexFile, classType, methodPrototype, methodName);
return dexFile.MethodIdsSection.getInternedItem(methodIdItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
classType = dexFile.TypeIdsSection.getItemByIndex(in.readShort());
methodPrototype = dexFile.ProtoIdsSection.getItemByIndex(in.readShort());
methodName = dexFile.StringIdsSection.getItemByIndex(in.readInt());
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 8;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(2, "class_type: " + classType.getTypeDescriptor());
out.annotate(2, "method_prototype: " + methodPrototype.getPrototypeString());
out.annotate(4, "method_name: " + methodName.getStringValue());
}
int classIndex = classType.getIndex();
if (classIndex > 0xffff) {
throw new RuntimeException(String.format("Error writing method_id_item for %s. The type index of " +
"defining class %s is too large", getMethodString(), classType.getTypeDescriptor()));
}
out.writeShort(classIndex);
int prototypeIndex = methodPrototype.getIndex();
if (prototypeIndex > 0xffff) {
throw new RuntimeException(String.format("Error writing method_id_item for %0. The prototype index of " +
"method prototype %s is too large", getMethodString(), methodPrototype.getPrototypeString()));
}
out.writeShort(prototypeIndex);
out.writeInt(methodName.getIndex());
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_METHOD_ID_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "method_id_item: " + getMethodString();
}
/** {@inheritDoc} */
public int compareTo(MethodIdItem o) {
int result = classType.compareTo(o.classType);
if (result != 0) {
return result;
}
result = methodName.compareTo(o.methodName);
if (result != 0) {
return result;
}
return methodPrototype.compareTo(o.methodPrototype);
}
private String cachedMethodString = null;
/**
* @return a string formatted like LclassName;->methodName(TTTT..)R
*/
public String getMethodString() {
if (cachedMethodString == null) {
String classType = this.classType.getTypeDescriptor();
String methodName = this.methodName.getStringValue();
String prototypeString = methodPrototype.getPrototypeString();
StringBuilder sb = new StringBuilder(classType.length() + methodName.length() + prototypeString.length() +
2);
sb.append(classType);
sb.append("->");
sb.append(methodName);
sb.append(prototypeString);
cachedMethodString = sb.toString();
}
return cachedMethodString;
}
private String cachedShortMethodString = null;
/**
* @return a string formatted like methodName(TTTT..)R
*/
public String getShortMethodString() {
if (cachedShortMethodString == null) {
String methodName = this.methodName.getStringValue();
String prototypeString = methodPrototype.getPrototypeString();
StringBuilder sb = new StringBuilder(methodName.length() + prototypeString.length());
sb.append(methodName);
sb.append(prototypeString);
cachedShortMethodString = sb.toString();
}
return cachedShortMethodString;
}
/**
* @return the method prototype
*/
public ProtoIdItem getPrototype() {
return methodPrototype;
}
/**
* @return the name of the method
*/
public StringIdItem getMethodName() {
return methodName;
}
/**
* @return the class this method is a member of
*/
public TypeIdItem getContainingClass() {
return classType;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = classType.hashCode();
hashCode = 31 * hashCode + methodPrototype.hashCode();
hashCode = 31 * hashCode + methodName.hashCode();
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
//This assumes that the referenced items have been interned in both objects.
//This is a valid assumption because all outside code must use the static
//"getInterned..." style methods to make new items, and any item created
//internally is guaranteed to be interned
MethodIdItem other = (MethodIdItem)o;
return (classType == other.classType &&
methodPrototype == other.methodPrototype &&
methodName == other.methodName);
}
public MethodIdItem convert() {
return this;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/MethodIdItem.java
|
Java
|
asf20
| 9,801
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.StringIdItem;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.Utf8Utils;
public class StringEncodedValue extends EncodedValue {
public final StringIdItem value;
/**
* Constructs a new <code>StringEncodedValue</code> by reading the string index from the given <code>Input</code>
* object. The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits
* of the first byte should be passed as the valueArg parameter
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected StringEncodedValue(DexFile dexFile, Input in, byte valueArg) {
int index = (int)EncodedValueUtils.decodeUnsignedIntegralValue(in.readBytes(valueArg+1));
value = dexFile.StringIdsSection.getItemByIndex(index);
}
/**
* Constructs a new <code>StringEncodedValue</code> with the given <code>StringIdItem</code> value
* @param value The <code>StringIdItem</code> value
*/
public StringEncodedValue(StringIdItem value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeUnsignedIntegralValue(value.getIndex());
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_STRING.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: \"" + Utf8Utils.escapeString(value.getStringValue()) + "\"");
}
out.writeByte(ValueType.VALUE_STRING.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForUnsignedIntegralValue(value.getIndex()) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
StringEncodedValue other = (StringEncodedValue)o;
return value.compareTo(other.value);
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_STRING;
}
@Override
public int hashCode() {
return value.hashCode();
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/StringEncodedValue.java
|
Java
|
asf20
| 3,990
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class DoubleEncodedValue extends EncodedValue {
public final double value;
/**
* Constructs a new <code>DoubleEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits of
* the first byte should be passed as the valueArg parameter
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected DoubleEncodedValue(Input in, byte valueArg) {
long longValue = EncodedValueUtils.decodeRightZeroExtendedValue(in.readBytes(valueArg + 1));
value = Double.longBitsToDouble(longValue);
}
/**
* Constructs a new <code>DoubleEncodedValue</code> with the given value
* @param value The value
*/
public DoubleEncodedValue(double value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeRightZeroExtendedValue(Double.doubleToRawLongBits(value));
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_DOUBLE.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: " + value);
}
out.writeByte(ValueType.VALUE_DOUBLE.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + 1 + EncodedValueUtils.getRequiredBytesForRightZeroExtendedValue(
Double.doubleToRawLongBits(value));
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
DoubleEncodedValue other = (DoubleEncodedValue)o;
return Double.compare(value, other.value);
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_DOUBLE;
}
@Override
public int hashCode() {
return (int)Double.doubleToRawLongBits(value);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/DoubleEncodedValue.java
|
Java
|
asf20
| 3,755
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class FloatEncodedValue extends EncodedValue {
public final float value;
/**
* Constructs a new <code>FloatEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits of
* the first byte should be passed as the valueArg parameter
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected FloatEncodedValue(Input in, byte valueArg) {
long longValue = EncodedValueUtils.decodeRightZeroExtendedValue(in.readBytes(valueArg + 1));
value = Float.intBitsToFloat((int)((longValue >> 32) & 0xFFFFFFFFL));
}
/**
* Constructs a new <code>FloatEncodedValue</code> with the given value
* @param value The value
*/
public FloatEncodedValue(float value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeRightZeroExtendedValue(((long)Float.floatToRawIntBits(value)) << 32);
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_FLOAT.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: " + value);
}
out.writeByte(ValueType.VALUE_FLOAT.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + 1 + EncodedValueUtils.getRequiredBytesForRightZeroExtendedValue(
((long)Float.floatToRawIntBits(value)) << 32);
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
FloatEncodedValue other = (FloatEncodedValue)o;
return Float.compare(value, other.value);
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_FLOAT;
}
@Override
public int hashCode() {
return Float.floatToRawIntBits(value);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/FloatEncodedValue.java
|
Java
|
asf20
| 3,778
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
public class NullEncodedValue extends EncodedValue {
/**
* The singleton value
*/
public static final NullEncodedValue NullValue = new NullEncodedValue();
/**
* Constructs a new <code>NullEncodedValue</code>
*/
private NullEncodedValue() {
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate("value_type=" + ValueType.VALUE_NULL.name() + ",value_arg=0");
}
out.writeByte(ValueType.VALUE_NULL.value);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
return 0;
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_NULL;
}
@Override
public int hashCode() {
return 1;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/NullEncodedValue.java
|
Java
|
asf20
| 2,502
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.TypeIdItem;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class TypeEncodedValue extends EncodedValue {
public final TypeIdItem value;
/**
* Constructs a new <code>TypeEncodedValue</code> by reading the type index from the given <code>Input</code>
* object. The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits
* of the first byte should be passed as the valueArg parameter
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected TypeEncodedValue(DexFile dexFile, Input in, byte valueArg) {
int index = (int) EncodedValueUtils.decodeUnsignedIntegralValue(in.readBytes(valueArg+1));
value = dexFile.TypeIdsSection.getItemByIndex(index);
}
/**
* Constructs a new <code>TypeEncodedValue</code> with the given <code>TypeIdItem</code> value
* @param value The <code>TypeIdItem</code> value
*/
public TypeEncodedValue(TypeIdItem value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeUnsignedIntegralValue(value.getIndex());
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_TYPE.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: " + value.getTypeDescriptor());
}
out.writeByte(ValueType.VALUE_TYPE.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForUnsignedIntegralValue(value.getIndex()) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
TypeEncodedValue other = (TypeEncodedValue)o;
return value.compareTo(other.value);
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_TYPE;
}
@Override
public int hashCode() {
return value.hashCode();
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/TypeEncodedValue.java
|
Java
|
asf20
| 3,890
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public abstract class EncodedValue implements Comparable<EncodedValue> {
/**
* Writes this <code>EncodedValue</code> to the given <code>AnnotatedOutput</code> object
* @param out the <code>AnnotatedOutput</code> object to write to
*/
public abstract void writeValue(AnnotatedOutput out);
/**
* Calculates the size of this encoded value and returns offset + size;
* @param offset The offset to place this encoded value
* @return the offset immediately after this encoded value
*/
public abstract int placeValue(int offset);
public static EncodedValue readEncodedValue(DexFile dexFile, Input in) {
Byte b = in.readByte();
ValueType valueType = ValueType.fromByte((byte)(b & 0x1f));
byte valueArg = (byte)((b & 0xFF) >> 5);
switch (valueType) {
case VALUE_BYTE:
return new ByteEncodedValue(in);
case VALUE_SHORT:
return new ShortEncodedValue(in, valueArg);
case VALUE_CHAR:
return new CharEncodedValue(in, valueArg);
case VALUE_INT:
return new IntEncodedValue(in, valueArg);
case VALUE_LONG:
return new LongEncodedValue(in, valueArg);
case VALUE_FLOAT:
return new FloatEncodedValue(in, valueArg);
case VALUE_DOUBLE:
return new DoubleEncodedValue(in, valueArg);
case VALUE_STRING:
return new StringEncodedValue(dexFile, in, valueArg);
case VALUE_TYPE:
return new TypeEncodedValue(dexFile, in, valueArg);
case VALUE_FIELD:
return new FieldEncodedValue(dexFile, in, valueArg);
case VALUE_METHOD:
return new MethodEncodedValue(dexFile, in, valueArg);
case VALUE_ENUM:
return new EnumEncodedValue(dexFile, in, valueArg);
case VALUE_ARRAY:
return new ArrayEncodedValue(dexFile, in);
case VALUE_ANNOTATION:
return new AnnotationEncodedValue(dexFile, in);
case VALUE_NULL:
return NullEncodedValue.NullValue;
case VALUE_BOOLEAN:
return BooleanEncodedValue.getBooleanEncodedValue(valueArg);
}
return null;
}
/** {@inheritDoc} */
public int compareTo(EncodedValue o) {
int comp = getValueType().compareTo(o.getValueType());
if (comp == 0) {
comp = compareValue(o);
}
return comp;
}
/**
* Compare the value of this <code>EncodedValue</code> against the value of the given <EncodedValue>, which
* is guaranteed to be of the same type as this <code>EncodedValue</code>
* @param o The <code>EncodedValue</code> to compare against
* @return A standard comparison integer value
*/
protected abstract int compareValue(EncodedValue o);
/**
* @return the <code>ValueType</code> representing the type of this <code>EncodedValue</code>
*/
public abstract ValueType getValueType();
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !(o instanceof EncodedValue)) {
return false;
}
return this.compareTo((EncodedValue)o) == 0;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/EncodedValue.java
|
Java
|
asf20
| 5,035
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class IntEncodedValue extends EncodedValue {
public final int value;
/**
* Constructs a new <code>IntEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits of
* the first byte should be passed as the valueArg parameter
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected IntEncodedValue(Input in, byte valueArg) {
value = (int)EncodedValueUtils.decodeSignedIntegralValue(in.readBytes(valueArg+1));
}
/**
* Constructs a new <code>IntEncodedValue</code> with the given value
* @param value The value
*/
public IntEncodedValue(int value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeSignedIntegralValue(value);
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_INT.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: 0x" + Integer.toHexString(value) + " (" + value + ")");
}
out.writeByte(ValueType.VALUE_INT.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForSignedIntegralValue(value) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
IntEncodedValue other = (IntEncodedValue)o;
return (value<other.value?-1:(value>other.value?1:0));
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_INT;
}
@Override
public int hashCode() {
return value;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/IntEncodedValue.java
|
Java
|
asf20
| 3,600
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.FieldIdItem;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class EnumEncodedValue extends EncodedValue {
public final FieldIdItem value;
/**
* Constructs a new <code>EnumEncodedValue</code> by reading the field index from the given <code>Input</code>
* object. The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits
* of the first byte should be passed as the valueArg parameter
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected EnumEncodedValue(DexFile dexFile, Input in, byte valueArg) {
int index = (int) EncodedValueUtils.decodeUnsignedIntegralValue(in.readBytes(valueArg+1));
value = dexFile.FieldIdsSection.getItemByIndex(index);
}
/**
* Constructs a new <code>EnumEncodedValue</code> with the given <code>FieldIdItem</code> value
* @param value The <code>FieldIdItem</code> value
*/
public EnumEncodedValue(FieldIdItem value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeUnsignedIntegralValue(value.getIndex());
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_ENUM.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: " + value.getFieldString());
}
out.writeByte(ValueType.VALUE_ENUM.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForUnsignedIntegralValue(value.getIndex()) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
EnumEncodedValue other = (EnumEncodedValue)o;
return value.compareTo(other.value);
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_ENUM;
}
@Override
public int hashCode() {
return value.hashCode();
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/EnumEncodedValue.java
|
Java
|
asf20
| 3,894
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class ShortEncodedValue extends EncodedValue {
public final short value;
/**
* Constructs a new <code>ShortEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits of
* the first byte should be passed as the valueArg parameter
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected ShortEncodedValue(Input in, byte valueArg) {
value = (short) EncodedValueUtils.decodeSignedIntegralValue(in.readBytes(valueArg+1));
}
/**
* Constructs a new <code>ShortEncodedValue</code> with the given value
* @param value The value
*/
public ShortEncodedValue(short value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeSignedIntegralValue(value);
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_SHORT.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: 0x" + Integer.toHexString(value) + " (" + value + ")");
}
out.writeByte(ValueType.VALUE_SHORT.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForSignedIntegralValue(value) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
ShortEncodedValue other = (ShortEncodedValue)o;
return (value<other.value?-1:(value>other.value?1:0));
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_SHORT;
}
@Override
public int hashCode() {
return value;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/ShortEncodedValue.java
|
Java
|
asf20
| 3,628
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.MethodIdItem;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class MethodEncodedValue extends EncodedValue {
public final MethodIdItem value;
/**
* Constructs a new <code>MethodEncodedValue</code> by reading the method index from the given <code>Input</code>
* object. The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits
* of the first byte should be passed as the valueArg parameter
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected MethodEncodedValue(DexFile dexFile, Input in, byte valueArg) {
int index = (int) EncodedValueUtils.decodeUnsignedIntegralValue(in.readBytes(valueArg+1));
value = dexFile.MethodIdsSection.getItemByIndex(index);
}
/**
* Constructs a new <code>MethodEncodedValue</code> with the given <code>MethodIdItem</code> value
* @param value The <code>MethodIdItem</code> value
*/
public MethodEncodedValue(MethodIdItem value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeUnsignedIntegralValue(value.getIndex());
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_METHOD.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: " + value.getMethodString());
}
out.writeByte(ValueType.VALUE_METHOD.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForUnsignedIntegralValue(value.getIndex()) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
MethodEncodedValue other = (MethodEncodedValue)o;
return value.compareTo(other.value);
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_METHOD;
}
@Override
public int hashCode() {
return value.hashCode();
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/MethodEncodedValue.java
|
Java
|
asf20
| 3,922
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
public class BooleanEncodedValue extends EncodedValue {
/**
* The dupliton values
*/
public static final BooleanEncodedValue TrueValue = new BooleanEncodedValue(true);
public static final BooleanEncodedValue FalseValue = new BooleanEncodedValue(false);
public final boolean value;
/**
* Constructs a new <code>BooleanEncodedValue</code> with the given value
* @param value The value
*/
private BooleanEncodedValue(boolean value) {
this.value = value;
}
/**
* Gets the <code>BooleanEncodedValue</code> for the given valueArg value. The high 3 bits of the first byte should
* be passed as the valueArg parameter
* @param valueArg The high 3 bits of the first byte of this encoded value
* @return the <code>BooleanEncodedValue</code> for the given valueArg value
*/
protected static BooleanEncodedValue getBooleanEncodedValue(byte valueArg) {
if (valueArg == 0) {
return FalseValue;
} else if (valueArg == 1) {
return TrueValue;
}
throw new RuntimeException("valueArg must be either 0 or 1");
}
/**
* Gets the <code>BooleanEncodedValue</code> for the given boolean value
* @param value the boolean value
* @return the <code>BooleanEncodedValue</code> for the given boolean value
*/
public static BooleanEncodedValue getBooleanEncodedValue(boolean value) {
if (value) {
return TrueValue;
}
return FalseValue;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate("value_type=" + ValueType.VALUE_BOOLEAN.name() + ",value=" + Boolean.toString(value));
}
out.writeByte(ValueType.VALUE_BOOLEAN.value | ((value?1:0) << 5));
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
BooleanEncodedValue other = (BooleanEncodedValue)o;
if (value == other.value)
return 0;
if (value)
return 1;
return -1;
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_BOOLEAN;
}
@Override
public int hashCode() {
return value?1:0;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/BooleanEncodedValue.java
|
Java
|
asf20
| 3,969
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.StringIdItem;
import org.jf.dexlib.TypeIdItem;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.Leb128Utils;
/**
* An <code>AnnotationEncodedSubValue</code> is identical to an <code>AnnotationEncodedValue</code>, except that it
* doesn't have the initial valueType/valueArg byte. This is used in the <code>AnnotationItem</code> object
*/
public class AnnotationEncodedSubValue extends EncodedValue {
private int hashCode = 0;
public final TypeIdItem annotationType;
public final StringIdItem[] names;
public final EncodedValue[] values;
/**
* Constructs a new <code>AnnotationEncodedSubValue</code> by reading the value from the given <code>Input</code>
* object.
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
*/
public AnnotationEncodedSubValue(DexFile dexFile, Input in) {
annotationType = dexFile.TypeIdsSection.getItemByIndex(in.readUnsignedLeb128());
names = new StringIdItem[in.readUnsignedLeb128()];
values = new EncodedValue[names.length];
for (int i=0; i<names.length; i++) {
names[i] = dexFile.StringIdsSection.getItemByIndex(in.readUnsignedLeb128());
values[i] = EncodedValue.readEncodedValue(dexFile, in);
}
}
/**
* Constructs a new <code>AnnotationEncodedValue</code> with the given values. names and values must be the same
* length, and must be sorted according to the name
* @param annotationType The type of the annotation
* @param names An array of the names of the elements of the annotation
* @param values An array of the values of the elements on the annotation
*/
public AnnotationEncodedSubValue(TypeIdItem annotationType, StringIdItem[] names, EncodedValue[] values) {
this.annotationType = annotationType;
if (names.length != values.length) {
throw new RuntimeException("The names and values parameters must be the same length");
}
this.names = names;
this.values = values;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
out.annotate("annotation_type: " + annotationType.getTypeDescriptor());
out.writeUnsignedLeb128(annotationType.getIndex());
out.annotate("element_count: 0x" + Integer.toHexString(names.length) + " (" + names.length + ")");
out.writeUnsignedLeb128(names.length);
for (int i=0; i<names.length; i++) {
out.annotate(0, "[" + i + "] annotation_element");
out.indent();
out.annotate("element_name: " + names[i].getStringValue());
out.writeUnsignedLeb128(names[i].getIndex());
out.annotate(0, "element_value:");
out.indent();
values[i].writeValue(out);
out.deindent();
out.deindent();
}
}
/** {@inheritDoc} */
public int placeValue(int offset) {
offset = offset + Leb128Utils.unsignedLeb128Size(annotationType.getIndex());
offset = offset + Leb128Utils.unsignedLeb128Size(names.length);
for (int i=0; i<names.length; i++) {
offset = offset + Leb128Utils.unsignedLeb128Size(names[i].getIndex());
offset = values[i].placeValue(offset);
}
return offset;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
AnnotationEncodedSubValue other = (AnnotationEncodedSubValue)o;
int comp = annotationType.compareTo(other.annotationType);
if (comp != 0) {
return comp;
}
comp = names.length - other.names.length;
if (comp != 0) {
return comp;
}
for (int i=0; i<names.length; i++) {
comp = names[i].compareTo(other.names[i]);
if (comp != 0) {
return comp;
}
comp = values[i].compareTo(other.values[i]);
if (comp != 0) {
return comp;
}
}
return comp;
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_ANNOTATION;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = annotationType.hashCode();
for (int i=0; i<names.length; i++) {
hashCode = 31 * hashCode + names[i].hashCode();
hashCode = 31 * hashCode + values[i].hashCode();
}
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/AnnotationEncodedSubValue.java
|
Java
|
asf20
| 6,422
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public class ArrayEncodedValue extends ArrayEncodedSubValue {
/**
* Constructs a new <code>ArrayEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
*/
protected ArrayEncodedValue(DexFile dexFile, Input in) {
super(dexFile, in);
}
/**
* Constructs a new <code>ArrayEncodedValue</code> with the given values
* @param values The array values
*/
public ArrayEncodedValue(EncodedValue[] values) {
super(values);
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate("value_type=" + ValueType.VALUE_ARRAY.name() + ",value_arg=0");
}
out.writeByte(ValueType.VALUE_ARRAY.value);
super.writeValue(out);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return super.placeValue(offset + 1);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/ArrayEncodedValue.java
|
Java
|
asf20
| 2,785
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.Leb128Utils;
/**
* An <code>ArrayEncodedSubValue</code> is identical to an <code>ArrayEncodedValue</code>, except that it
* doesn't have the initial valueType/valueArg byte. This is used in the <code>EncodedArrayItem</code> object
*/
public class ArrayEncodedSubValue extends EncodedValue {
private int hashCode = 0;
public final EncodedValue[] values;
/**
* Constructs a new <code>ArrayEncodedSubValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
*/
public ArrayEncodedSubValue(DexFile dexFile, Input in) {
values = new EncodedValue[in.readUnsignedLeb128()];
for (int i=0; i<values.length; i++) {
values[i] = EncodedValue.readEncodedValue(dexFile, in);
}
}
/**
* Constructs a new <code>ArrayEncodedSubValue</code> with the given values
* @param values The array values
*/
public ArrayEncodedSubValue(EncodedValue[] values) {
this.values = values;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
if (out.annotates())
{
out.annotate("array_size: 0x" + Integer.toHexString(values.length) + " (" + values.length + ")");
out.writeUnsignedLeb128(values.length);
int index = 0;
for (EncodedValue encodedValue: values) {
out.annotate(0, "[" + index++ + "] array_element");
out.indent();
encodedValue.writeValue(out);
out.deindent();
}
} else {
out.writeUnsignedLeb128(values.length);
for (EncodedValue encodedValue: values) {
encodedValue.writeValue(out);
}
}
}
/** {@inheritDoc} */
public int placeValue(int offset) {
offset = offset + Leb128Utils.unsignedLeb128Size(values.length);
for (EncodedValue encodedValue: values) {
offset = encodedValue.placeValue(offset);
}
return offset;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
ArrayEncodedSubValue other = (ArrayEncodedSubValue)o;
int comp = values.length - other.values.length;
if (comp != 0) {
return comp;
}
for (int i=0; i<values.length; i++) {
comp = values[i].compareTo(other.values[i]);
if (comp != 0) {
return comp;
}
}
return comp;
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_ARRAY;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = 0;
for (EncodedValue encodedValue: values) {
hashCode = 31 * hashCode + encodedValue.hashCode();
}
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/ArrayEncodedSubValue.java
|
Java
|
asf20
| 4,989
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class LongEncodedValue extends EncodedValue {
public final long value;
/**
* Constructs a new <code>LongEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits of
* the first byte should be passed as the valueArg parameter
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected LongEncodedValue(Input in, byte valueArg) {
value = EncodedValueUtils.decodeSignedIntegralValue(in.readBytes(valueArg+1));
}
/**
* Constructs a new <code>LongEncodedValue</code> with the given value
* @param value The value
*/
public LongEncodedValue(long value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeSignedIntegralValue(value);
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_LONG.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: 0x" + Long.toHexString(value) + " (" + value + ")");
}
out.writeByte(ValueType.VALUE_LONG.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForSignedIntegralValue(value) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
LongEncodedValue other = (LongEncodedValue)o;
return (value<other.value?-1:(value>other.value?1:0));
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_LONG;
}
@Override
public int hashCode() {
return (int)value;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/LongEncodedValue.java
|
Java
|
asf20
| 3,609
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.FieldIdItem;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class FieldEncodedValue extends EncodedValue {
public final FieldIdItem value;
/**
* Constructs a new <code>FieldEncodedValue</code> by reading the field index from the given <code>Input</code>
* object. The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits
* of the first byte should be passed as the valueArg parameter
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected FieldEncodedValue(DexFile dexFile, Input in, byte valueArg) {
int index = (int) EncodedValueUtils.decodeUnsignedIntegralValue(in.readBytes(valueArg+1));
value = dexFile.FieldIdsSection.getItemByIndex(index);
}
/**
* Constructs a new <code>FieldEncodedValue</code> with the given <code>FieldIdItem</code> value
* @param value The <code>FieldIdItem</code> value
*/
public FieldEncodedValue(FieldIdItem value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeUnsignedIntegralValue(value.getIndex());
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_FIELD.name() + ",value_arg=" + (bytes.length - 1));
out.annotate(bytes.length, "value: " + value.getFieldString());
}
out.writeByte(ValueType.VALUE_FIELD.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForUnsignedIntegralValue(value.getIndex()) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
FieldEncodedValue other = (FieldEncodedValue)o;
return value.compareTo(other.value);
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_FIELD;
}
@Override
public int hashCode() {
return value.hashCode();
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/FieldEncodedValue.java
|
Java
|
asf20
| 3,904
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class CharEncodedValue extends EncodedValue {
public final char value;
/**
* Constructs a new <code>CharEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value, and the high 3 bits of
* the first byte should be passed as the valueArg parameter
* @param in The <code>Input</code> object to read from
* @param valueArg The high 3 bits of the first byte of this encoded value
*/
protected CharEncodedValue(Input in, byte valueArg) {
value = (char)EncodedValueUtils.decodeUnsignedIntegralValue(in.readBytes(valueArg+1));
}
/**
* Constructs a new <code>CharEncodedValue</code> with the given value
* @param value The value
*/
public CharEncodedValue(char value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
byte[] bytes = EncodedValueUtils.encodeUnsignedIntegralValue(value);
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_CHAR.name() + ",value_arg=" + (bytes.length - 1));
char[] c = Character.toChars(value);
assert c.length > 0;
out.annotate(bytes.length, "value: 0x" + Integer.toHexString(value) + " '" + c[0] + "'");
}
out.writeByte(ValueType.VALUE_CHAR.value | ((bytes.length - 1) << 5));
out.write(bytes);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + EncodedValueUtils.getRequiredBytesForUnsignedIntegralValue(value) + 1;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
CharEncodedValue other = (CharEncodedValue)o;
return (value<other.value?-1:(value>other.value?1:0));
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_CHAR;
}
@Override
public int hashCode() {
return value;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/CharEncodedValue.java
|
Java
|
asf20
| 3,701
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.EncodedValueUtils;
import org.jf.dexlib.Util.Input;
public class ByteEncodedValue extends EncodedValue {
public final byte value;
/**
* Constructs a new <code>ByteEncodedValue</code> by reading the value from the given <code>Input</code> object.
* The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value
* @param in The <code>Input</code> object to read from
*/
protected ByteEncodedValue(Input in) {
value = (byte)EncodedValueUtils.decodeSignedIntegralValue(in.readBytes(1));
}
/**
* Constructs a new <code>ByteEncodedValue</code> with the given value
* @param value The value
*/
public ByteEncodedValue(byte value) {
this.value = value;
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(1, "value_type=" + ValueType.VALUE_BYTE.name() + ",value_arg=0");
out.annotate(1, "value: 0x" + Integer.toHexString(value) + " (" + value + ")");
}
out.writeByte(ValueType.VALUE_BYTE.value);
out.writeByte(value);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return offset + 2;
}
/** {@inheritDoc} */
protected int compareValue(EncodedValue o) {
ByteEncodedValue other = (ByteEncodedValue)o;
return (value<other.value?-1:(value>other.value?1:0));
}
/** {@inheritDoc} */
public ValueType getValueType() {
return ValueType.VALUE_BYTE;
}
@Override
public int hashCode() {
return value;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/ByteEncodedValue.java
|
Java
|
asf20
| 3,224
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.StringIdItem;
import org.jf.dexlib.TypeIdItem;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public class AnnotationEncodedValue extends AnnotationEncodedSubValue {
/**
* Constructs a new <code>AnnotationEncodedValue</code> by reading the value from the given <code>Input</code>
* object. The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
*/
protected AnnotationEncodedValue(DexFile dexFile, Input in) {
super(dexFile, in);
}
/**
* Constructs a new <code>AnnotationEncodedValue</code> with the given values. names and values must be the same
* length, and must be sorted according to the name
* @param annotationType The type of the annotation
* @param names An array of the names of the elements of the annotation
* @param values An array of the values of the elements on the annotation
*/
public AnnotationEncodedValue(TypeIdItem annotationType, StringIdItem[] names, EncodedValue[] values) {
super(annotationType, names, values);
}
/** {@inheritDoc} */
public void writeValue(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate("value_type=" + ValueType.VALUE_ANNOTATION.name() + ",value_arg=0");
}
out.writeByte(ValueType.VALUE_ANNOTATION.value);
super.writeValue(out);
}
/** {@inheritDoc} */
public int placeValue(int offset) {
return super.placeValue(offset + 1);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/AnnotationEncodedValue.java
|
Java
|
asf20
| 3,223
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib.EncodedValue;
import org.jf.dexlib.Util.SparseArray;
public enum ValueType {
VALUE_BYTE((byte) 0x00),
VALUE_SHORT((byte) 0x02),
VALUE_CHAR((byte) 0x03),
VALUE_INT((byte) 0x04),
VALUE_LONG((byte) 0x06),
VALUE_FLOAT((byte) 0x10),
VALUE_DOUBLE((byte) 0x11),
VALUE_STRING((byte) 0x17),
VALUE_TYPE((byte) 0x18),
VALUE_FIELD((byte) 0x19),
VALUE_METHOD((byte) 0x1a),
VALUE_ENUM((byte) 0x1b),
VALUE_ARRAY((byte) 0x1c),
VALUE_ANNOTATION((byte) 0x1d),
VALUE_NULL((byte) 0x1e),
VALUE_BOOLEAN((byte) 0x1f);
/**
* A map to facilitate looking up a <code>ValueType</code> by byte value
*/
private final static SparseArray<ValueType> valueTypeIntegerMap;
static {
/** build the <code>valueTypeIntegerMap</code> object */
valueTypeIntegerMap = new SparseArray<ValueType>(16);
for (ValueType valueType : ValueType.values()) {
valueTypeIntegerMap.put(valueType.value, valueType);
}
}
/**
* The byte value for this ValueType
*/
public final byte value;
private ValueType(byte value) {
this.value = value;
}
/**
* Converts a byte value to the corresponding ValueType enum value,
* or null if the value isn't a valid ValueType value
*
* @param valueType the byte value to convert to a ValueType
* @return the ValueType enum value corresponding to valueType, or null
* if not a valid ValueType value
*/
public static ValueType fromByte(byte valueType) {
return valueTypeIntegerMap.get(valueType);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedValue/ValueType.java
|
Java
|
asf20
| 3,141
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.EncodedValue.ArrayEncodedSubValue;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
public class EncodedArrayItem extends Item<EncodedArrayItem> {
private int hashCode = 0;
private ArrayEncodedSubValue encodedArray;
/**
* Creates a new uninitialized <code>EncodedArrayItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected EncodedArrayItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>EncodedArrayItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param encodedArray The encoded array value
*/
private EncodedArrayItem(DexFile dexFile, ArrayEncodedSubValue encodedArray) {
super(dexFile);
this.encodedArray = encodedArray;
}
/**
* Returns an <code>EncodedArrayItem</code> for the given values, and that has been interned into the given
* <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param encodedArray The encoded array value
* @return an <code>EncodedArrayItem</code> for the given values, and that has been interned into the given
*/
public static EncodedArrayItem internEncodedArrayItem(DexFile dexFile, ArrayEncodedSubValue encodedArray) {
EncodedArrayItem encodedArrayItem = new EncodedArrayItem(dexFile, encodedArray);
return dexFile.EncodedArraysSection.intern(encodedArrayItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
encodedArray = new ArrayEncodedSubValue(dexFile, in);
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return encodedArray.placeValue(offset);
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
encodedArray.writeValue(out);
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_ENCODED_ARRAY_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "encoded_array @0x" + Integer.toHexString(getOffset());
}
/** {@inheritDoc} */
public int compareTo(EncodedArrayItem encodedArrayItem) {
return encodedArray.compareTo(encodedArrayItem.encodedArray);
}
/**
* @return The encoded array value
*/
public ArrayEncodedSubValue getEncodedArray() {
return encodedArray;
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
hashCode = encodedArray.hashCode();
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
EncodedArrayItem other = (EncodedArrayItem)o;
return (encodedArray.compareTo(other.encodedArray) == 0);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/EncodedArrayItem.java
|
Java
|
asf20
| 4,792
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.Utf8Utils;
import javax.annotation.Nullable;
public class StringIdItem extends Item<StringIdItem> {
private StringDataItem stringDataItem;
/**
* Creates a new uninitialized <code>StringIdItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected StringIdItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>StringIdItem</code> for the given <code>StringDataItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param stringDataItem The <code>StringDataItem</code> that this <code>StringIdItem</code> represents
*/
protected StringIdItem(DexFile dexFile, StringDataItem stringDataItem) {
super(dexFile);
this.stringDataItem = stringDataItem;
}
/**
* Returns a <code>StringIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item will belong to
* @param stringValue The string value that this item represents
* @return a <code>StringIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static StringIdItem internStringIdItem(DexFile dexFile, String stringValue) {
StringDataItem stringDataItem = StringDataItem.internStringDataItem(dexFile, stringValue);
if (stringDataItem == null) {
return null;
}
StringIdItem stringIdItem = new StringIdItem(dexFile, stringDataItem);
return dexFile.StringIdsSection.intern(stringIdItem);
}
/**
* Looks up the <code>StringIdItem</code> from the given <code>DexFile</code> for the given
* string value
* @param dexFile the <code>Dexfile</code> to find the string value in
* @param stringValue The string value to look up
* @return a <code>StringIdItem</code> from the given <code>DexFile</code> for the given
* string value, or null if it doesn't exist
*/
public static StringIdItem lookupStringIdItem(DexFile dexFile, String stringValue) {
StringDataItem stringDataItem = StringDataItem.lookupStringDataItem(dexFile, stringValue);
if (stringDataItem == null) {
return null;
}
StringIdItem stringIdItem = new StringIdItem(dexFile, stringDataItem);
return dexFile.StringIdsSection.getInternedItem(stringIdItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
int stringDataOffset = in.readInt();
stringDataItem = (StringDataItem)readContext.getOffsettedItemByOffset(ItemType.TYPE_STRING_DATA_ITEM,
stringDataOffset);
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 4;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(4, stringDataItem.getConciseIdentity());
}
out.writeInt(stringDataItem.getOffset());
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_STRING_ID_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "string_id_item: " + Utf8Utils.escapeString(getStringValue());
}
/** {@inheritDoc} */
public int compareTo(StringIdItem o) {
//sort by the string value
return getStringValue().compareTo(o.getStringValue());
}
/**
* Get the <code>String</code> value that this <code>StringIdItem</code> represents
* @return the <code>String</code> value that this <code>StringIdItem</code> represents
*/
public String getStringValue() {
return stringDataItem.getStringValue();
}
/**
* Get the <code>String</code> value that the given <code>StringIdItem</code> represents
* @param stringIdItem The <code>StringIdItem</code> to get the string value of
* @return the <code>String</code> value that the given <code>StringIdItem</code> represents
*/
@Nullable
public static String getStringValue(@Nullable StringIdItem stringIdItem) {
return stringIdItem==null?null:stringIdItem.getStringValue();
}
/**
* Get the <code>StringDataItem</code> that this <code>StringIdItem</code> references
* @return the <code>StringDataItem</code> that this <code>StringIdItem</code> references
*/
public StringDataItem getStringDataItem() {
return stringDataItem;
}
@Override
public int hashCode() {
return stringDataItem.hashCode();
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
//This assumes that the referenced items have been interned in both objects.
//This is a valid assumption because all outside code must use the static
//"getInterned..." style methods to make new items, and any item created
//internally is guaranteed to be interned
StringIdItem other = (StringIdItem)o;
return stringDataItem == other.stringDataItem;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/StringIdItem.java
|
Java
|
asf20
| 6,913
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import javax.annotation.Nullable;
public class TypeIdItem extends Item<TypeIdItem> {
private StringIdItem typeDescriptor;
/**
* Creates a new uninitialized <code>TypeIdItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected TypeIdItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>TypeIdItem</code> for the given <code>StringIdItem</code>
* @param dexFile The <code>DexFile</code> that this item will belong to
* @param typeDescriptor The <code>StringIdItem</code> containing the type descriptor that
* this <code>TypeIdItem</code> represents
*/
private TypeIdItem(DexFile dexFile, StringIdItem typeDescriptor) {
super(dexFile);
this.typeDescriptor = typeDescriptor;
}
/**
* Returns a <code>TypeIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item will belong to
* @param typeDescriptor The <code>StringIdItem</code> containing the type descriptor that
* this <code>TypeIdItem</code> represents
* @return a <code>TypeIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static TypeIdItem internTypeIdItem(DexFile dexFile, StringIdItem typeDescriptor) {
TypeIdItem typeIdItem = new TypeIdItem(dexFile, typeDescriptor);
return dexFile.TypeIdsSection.intern(typeIdItem);
}
/**
* Returns a <code>TypeIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item will belong to
* @param typeDescriptor The string containing the type descriptor that this
* <code>TypeIdItem</code> represents
* @return a <code>TypeIdItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static TypeIdItem internTypeIdItem(DexFile dexFile, String typeDescriptor) {
StringIdItem stringIdItem = StringIdItem.internStringIdItem(dexFile, typeDescriptor);
if (stringIdItem == null) {
return null;
}
TypeIdItem typeIdItem = new TypeIdItem(dexFile, stringIdItem);
return dexFile.TypeIdsSection.intern(typeIdItem);
}
/**
* Looks up the <code>TypeIdItem</code> from the given <code>DexFile</code> for the given
* type descriptor
* @param dexFile the <code>Dexfile</code> to find the type in
* @param typeDescriptor The string containing the type descriptor to look up
* @return a <code>TypeIdItem</code> from the given <code>DexFile</code> for the given
* type descriptor, or null if it doesn't exist
*/
public static TypeIdItem lookupTypeIdItem(DexFile dexFile, String typeDescriptor) {
StringIdItem stringIdItem = StringIdItem.lookupStringIdItem(dexFile, typeDescriptor);
if (stringIdItem == null) {
return null;
}
TypeIdItem typeIdItem = new TypeIdItem(dexFile, stringIdItem);
return dexFile.TypeIdsSection.getInternedItem(typeIdItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
int stringIdIndex = in.readInt();
this.typeDescriptor = dexFile.StringIdsSection.getItemByIndex(stringIdIndex);
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 4;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(4, typeDescriptor.getConciseIdentity());
}
out.writeInt(typeDescriptor.getIndex());
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_TYPE_ID_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "type_id_item: " + getTypeDescriptor();
}
/** {@inheritDoc} */
public int compareTo(TypeIdItem o) {
//sort by the index of the StringIdItem
return typeDescriptor.compareTo(o.typeDescriptor);
}
/**
* Returns the type descriptor as a <code>String</code> for this type
* @return the type descriptor as a <code>String</code> for this type
*/
public String getTypeDescriptor() {
return typeDescriptor.getStringValue();
}
/**
* Returns the type descriptor as a <code>String</code> for the given type
* @param typeIdItem The <code>TypeIdItem</code> to get the type descriptor of
* @return the type descriptor as a <code>String</code> for the gvien type
*/
@Nullable
public static String getTypeDescriptor(@Nullable TypeIdItem typeIdItem) {
return typeIdItem==null?null:typeIdItem.getTypeDescriptor();
}
/**
* Returns the "shorty" representation of this type, used to create the shorty prototype string for a method
* @return the "shorty" representation of this type, used to create the shorty prototype string for a method
*/
public String toShorty() {
String type = getTypeDescriptor();
if (type.length() > 1) {
return "L";
} else {
return type;
}
}
/**
* Calculates the number of 2-byte registers that an instance of this type requires
* @return The number of 2-byte registers that an instance of this type requires
*/
public int getRegisterCount() {
String type = this.getTypeDescriptor();
/** Only the long and double primitive types are 2 words,
* everything else is a single word
*/
if (type.charAt(0) == 'J' || type.charAt(0) == 'D') {
return 2;
} else {
return 1;
}
}
@Override
public int hashCode() {
return typeDescriptor.hashCode();
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
//This assumes that the referenced items have been interned in both objects.
//This is a valid assumption because all outside code must use the static
//"getInterned..." style methods to make new items, and any item created
//internally is guaranteed to be interned
TypeIdItem other = (TypeIdItem)o;
return typeDescriptor == other.typeDescriptor;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/TypeIdItem.java
|
Java
|
asf20
| 8,191
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.*;
import java.io.*;
import java.security.DigestException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.zip.Adler32;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
/**
* <h3>Main use cases</h3>
*
* <p>These are the main use cases that drove the design of this library</p>
*
* <ol>
* <li><p><b>Annotate an existing dex file</b> - In this case, the intent is to document the structure of
* an existing dex file. We want to be able to read in the dex file, and then write out a dex file
* that is exactly the same (while adding annotation information to an AnnotatedOutput object)</p></li>
*
* <li><p><b>Canonicalize an existing dex file</b> - In this case, the intent is to rewrite an existing dex file
* so that it is in a canonical form. There is a certain amount of leeway in how various types of
* tems in a dex file are ordered or represented. It is sometimes useful to be able to easily
* compare a disassebled and reassembled dex file with the original dex file. If both dex-files are
* written canonically, they "should" match exactly, barring any explicit changes to the reassembled
* file.</p>
*
* <p>Currently, there are a couple of pieces of information that probably won't match exactly
* <ul>
* <li>the order of exception handlers in the <code>EncodedCatchHandlerList</code> for a method</li>
* <li>the ordering of some of the debug info in the <code>{@link org.jf.dexlib.DebugInfoItem}</code> for a method</li>
* </ul></p>
*
*
* <p>Note that the above discrepancies should typically only be "intra-item" differences. They
* shouldn't change the size of the item, or affect how anything else is placed or laid out</p></li>
*
* <li><p><b>Creating a dex file from scratch</b> - In this case, a blank dex file is created and then classes
* are added to it incrementally by calling the {@link org.jf.dexlib.Section#intern intern} method of
* {@link DexFile#ClassDefsSection}, which will add all the information necessary to represent the given
* class. For example, when assembling a dex file from a set of assembly text files.</p>
*
* <p>In this case, we can choose to write the dex file in a canonical form or not. It is somewhat
* slower to write it in a canonical format, due to the extra sorting and calculations that are
* required.</p></li>
*
*
* <li><p><b>Reading in the dex file</b> - In this case, the intent is to read in a dex file and expose all the
* data to the calling application. For example, when disassembling a dex file into a text based
* assembly format, or doing other misc processing of the dex file.</p></li>
*
*
* <h3>Other use cases</h3>
*
* <p>These are other use cases that are possible, but did not drive the design of the library.
* No effort was made to test these use cases or ensure that they work. Some of these could
* probably be better achieved with a disassemble - modify - reassemble type process, using
* smali/baksmali or another assembler/disassembler pair that are compatible with each other</p>
*
* <ul>
* <li>deleting classes/methods/etc. from a dex file</li>
* <li>merging 2 dex files</li>
* <li>splitting a dex file</li>
* <li>moving classes from 1 dex file to another</li>
* <li>removing the debug information from a dex file</li>
* <li>obfustication of a dex file</li>
* </ul>
*/
public class DexFile
{
/**
* A mapping from ItemType to the section that contains items of the given type
*/
private final Section[] sectionsByType;
/**
* Ordered lists of the indexed and offsetted sections. The order of these lists specifies the order
* that the sections will be written in
*/
private final IndexedSection[] indexedSections;
private final OffsettedSection[] offsettedSections;
/**
* dalvik had a bug where it wrote the registers for certain types of debug info in a signed leb
* format, instead of an unsigned leb format. There are no negative registers of course, but
* certain positive values have a different encoding depending on whether they are encoded as
* an unsigned leb128 or a signed leb128. Specifically, the signed leb128 is 1 byte longer in some cases.
*
* This determine whether we should keep any signed registers as signed, or force all register to
* unsigned. By default we don't keep track of whether they were signed or not, and write them back
* out as unsigned. This option only has an effect when reading an existing dex file. It has no
* effect when a dex file is created from scratch
*
* The 2 main use-cases in play are
* 1. Annotate an existing dex file - In this case, preserveSignedRegisters should be false, so that we keep
* track of any signed registers and write them back out as signed Leb128 values.
*
* 2. Canonicalize an existing dex file - In this case, fixRegisters should be true, so that all
* registers in the debug info are written as unsigned Leb128 values regardless of how they were
* originally encoded
*/
private final boolean preserveSignedRegisters;
/**
* When true, any instructions in a code item are skipped over instead of being read in. This is useful when
* you only need the information about the classes and their methods, for example, when loading the BOOTCLASSPATH
* jars in order to analyze a dex file
*/
private final boolean skipInstructions;
/**
* When true, this prevents any sorting of the items during placement of the dex file. This
* should *only* be set to true when this dex file was read in from an existing (valid) dex file,
* and no modifications were made (i.e. no items added or deleted). Otherwise it is likely that
* an invalid dex file will be generated.
*
* This is useful for the first use case (annotating an existing dex file). This ensures the items
* retain the same order as in the original dex file.
*/
private boolean inplace = false;
/**
* When true, this imposes an full ordering on all the items, to force them into a (possibly
* arbitrary) canonical order. When false, only the items that the dex format specifies
* an order for are sorted. The rest of the items are not ordered.
*
* This is useful for the second use case (canonicalizing an existing dex file) or possibly for
* the third use case (creating a dex file from scratch), if there is a need to write the new
* dex file in a canonical form.
*/
private boolean sortAllItems = false;
/**
* Is this file an odex file? This is only set when reading in an odex file
*/
private boolean isOdex = false;
private OdexHeader odexHeader;
private OdexDependencies odexDependencies;
private int dataOffset;
private int dataSize;
private int fileSize;
/**
* A private constructor containing common code to initialize the section maps and lists
* @param preserveSignedRegisters If true, keep track of any registers in the debug information
* @param skipInstructions If true, skip the instructions in any code item.
* that are signed, so they will be written in the same format. See
* <code>getPreserveSignedRegisters()</code>
*/
private DexFile(boolean preserveSignedRegisters, boolean skipInstructions) {
this.preserveSignedRegisters = preserveSignedRegisters;
this.skipInstructions = skipInstructions;
sectionsByType = new Section[] {
StringIdsSection,
TypeIdsSection,
ProtoIdsSection,
FieldIdsSection,
MethodIdsSection,
ClassDefsSection,
TypeListsSection,
AnnotationSetRefListsSection,
AnnotationSetsSection,
ClassDataSection,
CodeItemsSection,
AnnotationDirectoriesSection,
StringDataSection,
DebugInfoItemsSection,
AnnotationsSection,
EncodedArraysSection,
null,
null
};
indexedSections = new IndexedSection[] {
StringIdsSection,
TypeIdsSection,
ProtoIdsSection,
FieldIdsSection,
MethodIdsSection,
ClassDefsSection
};
offsettedSections = new OffsettedSection[] {
AnnotationSetRefListsSection,
AnnotationSetsSection,
CodeItemsSection,
AnnotationDirectoriesSection,
TypeListsSection,
StringDataSection,
AnnotationsSection,
EncodedArraysSection,
ClassDataSection,
DebugInfoItemsSection
};
}
/**
* Construct a new DexFile instance by reading in the given dex file.
* @param file The dex file to read in
* @throws IOException if an IOException occurs
*/
public DexFile(String file)
throws IOException {
this(new File(file), true, false);
}
/**
* Construct a new DexFile instance by reading in the given dex file,
* and optionally keep track of any registers in the debug information that are signed,
* so they will be written in the same format.
* @param file The dex file to read in
* @param preserveSignedRegisters If true, keep track of any registers in the debug information
* that are signed, so they will be written in the same format. See
* @param skipInstructions If true, skip the instructions in any code item.
* <code>getPreserveSignedRegisters()</code>
* @throws IOException if an IOException occurs
*/
public DexFile(String file, boolean preserveSignedRegisters, boolean skipInstructions)
throws IOException {
this(new File(file), preserveSignedRegisters, skipInstructions);
}
/**
* Construct a new DexFile instance by reading in the given dex file.
* @param file The dex file to read in
* @throws IOException if an IOException occurs
*/
public DexFile(File file)
throws IOException {
this(file, true, false);
}
/**
* Construct a new DexFile instance by reading in the given dex file,
* and optionally keep track of any registers in the debug information that are signed,
* so they will be written in the same format.
* @param file The dex file to read in
* @param preserveSignedRegisters If true, keep track of any registers in the debug information
* that are signed, so they will be written in the same format.
* @param skipInstructions If true, skip the instructions in any code item.
* @see #getPreserveSignedRegisters
* @throws IOException if an IOException occurs
*/
public DexFile(File file, boolean preserveSignedRegisters, boolean skipInstructions)
throws IOException {
this(preserveSignedRegisters, skipInstructions);
long fileLength;
byte[] magic = FileUtils.readFile(file, 0, 8);
InputStream inputStream = null;
Input in = null;
ZipFile zipFile = null;
try {
//do we have a zip file?
if (magic[0] == 0x50 && magic[1] == 0x4B) {
zipFile = new ZipFile(file);
ZipEntry zipEntry = zipFile.getEntry("classes.dex");
if (zipEntry == null) {
throw new NoClassesDexException("zip file " + file.getName() + " does not contain a classes.dex " +
"file");
}
fileLength = zipEntry.getSize();
if (fileLength < 40) {
throw new RuntimeException("The classes.dex file in " + file.getName() + " is too small to be a" +
" valid dex file");
} else if (fileLength > Integer.MAX_VALUE) {
throw new RuntimeException("The classes.dex file in " + file.getName() + " is too large to read in");
}
inputStream = new BufferedInputStream(zipFile.getInputStream(zipEntry));
inputStream.mark(8);
for (int i=0; i<8; i++) {
magic[i] = (byte)inputStream.read();
}
inputStream.reset();
} else {
fileLength = file.length();
if (fileLength < 40) {
throw new RuntimeException(file.getName() + " is too small to be a valid dex file");
}
if (fileLength < 40) {
throw new RuntimeException(file.getName() + " is too small to be a valid dex file");
} else if (fileLength > Integer.MAX_VALUE) {
throw new RuntimeException(file.getName() + " is too large to read in");
}
inputStream = new FileInputStream(file);
}
byte[] dexMagic, odexMagic;
boolean isDex = false;
this.isOdex = false;
for (int i=0; i<HeaderItem.MAGIC_VALUES.length; i++) {
byte[] magic_value = HeaderItem.MAGIC_VALUES[i];
if (Arrays.equals(magic, magic_value)) {
isDex = true;
break;
}
}
if (!isDex) {
if (Arrays.equals(magic, OdexHeader.MAGIC_35)) {
isOdex = true;
} else if (Arrays.equals(magic, OdexHeader.MAGIC_36)) {
isOdex = true;
}
}
if (isOdex) {
byte[] odexHeaderBytes = FileUtils.readStream(inputStream, 40);
Input odexHeaderIn = new ByteArrayInput(odexHeaderBytes);
odexHeader = new OdexHeader(odexHeaderIn);
int dependencySkip = odexHeader.depsOffset - odexHeader.dexOffset - odexHeader.dexLength;
if (dependencySkip < 0) {
throw new ExceptionWithContext("Unexpected placement of the odex dependency data");
}
if (odexHeader.dexOffset > 40) {
FileUtils.readStream(inputStream, odexHeader.dexOffset - 40);
}
in = new ByteArrayInput(FileUtils.readStream(inputStream, odexHeader.dexLength));
if (dependencySkip > 0) {
FileUtils.readStream(inputStream, dependencySkip);
}
odexDependencies = new OdexDependencies(
new ByteArrayInput(FileUtils.readStream(inputStream, odexHeader.depsLength)));
} else if (isDex) {
in = new ByteArrayInput(FileUtils.readStream(inputStream, (int)fileLength));
} else {
StringBuffer sb = new StringBuffer("bad magic value:");
for (int i=0; i<8; i++) {
sb.append(" ");
sb.append(Hex.u1(magic[i]));
}
throw new RuntimeException(sb.toString());
}
} finally {
if (inputStream != null) {
inputStream.close();
}
if (zipFile != null) {
zipFile.close();
}
}
ReadContext readContext = new ReadContext();
HeaderItem.readFrom(in, 0, readContext);
//the map offset was set while reading in the header item
int mapOffset = readContext.getSectionOffset(ItemType.TYPE_MAP_LIST);
in.setCursor(mapOffset);
MapItem.readFrom(in, 0, readContext);
//the sections are ordered in such a way that the item types
Section sections[] = new Section[] {
StringDataSection,
StringIdsSection,
TypeIdsSection,
TypeListsSection,
ProtoIdsSection,
FieldIdsSection,
MethodIdsSection,
AnnotationsSection,
AnnotationSetsSection,
AnnotationSetRefListsSection,
AnnotationDirectoriesSection,
DebugInfoItemsSection,
CodeItemsSection,
ClassDataSection,
EncodedArraysSection,
ClassDefsSection
};
for (Section section: sections) {
if (section == null) {
continue;
}
if (skipInstructions && (section == CodeItemsSection || section == DebugInfoItemsSection)) {
continue;
}
int sectionOffset = readContext.getSectionOffset(section.ItemType);
if (sectionOffset > 0) {
int sectionSize = readContext.getSectionSize(section.ItemType);
in.setCursor(sectionOffset);
section.readFrom(sectionSize, in, readContext);
}
}
}
/**
* Constructs a new, blank dex file. Classes can be added to this dex file by calling
* the <code>Section.intern()</code> method of <code>ClassDefsSection</code>
*/
public DexFile() {
this(true, false);
}
/**
* Get the <code>Section</code> containing items of the same type as the given item
* @param item Get the <code>Section</code> that contains items of this type
* @param <T> The specific item subclass - inferred from the passed item
* @return the <code>Section</code> containing items of the same type as the given item
*/
public <T extends Item> Section<T> getSectionForItem(T item) {
return (Section<T>)sectionsByType[item.getItemType().SectionIndex];
}
/**
* Get the <code>Section</code> containing items of the given type
* @param itemType the type of item
* @return the <code>Section</code> containing items of the given type
*/
public Section getSectionForType(ItemType itemType) {
return sectionsByType[itemType.SectionIndex];
}
/**
* Get a boolean value indicating whether this dex file preserved any signed
* registers in the debug info as it read the dex file in. By default, the dex file
* doesn't check whether the registers are encoded as unsigned or signed values.
*
* This does *not* affect the actual register value that is read in. The value is
* read correctly regardless
*
* This does affect whether any signed registers will retain the same encoding or be
* forced to the (correct) unsigned encoding when the dex file is written back out.
*
* See the discussion about signed register values in the documentation for
* <code>DexFile</code>
* @return a boolean indicating whether this dex file preserved any signed registers
* as it was read in
*/
public boolean getPreserveSignedRegisters() {
return preserveSignedRegisters;
}
/**
* Get a boolean value indicating whether to skip any instructions in a code item while reading in the dex file.
* This is useful when you only need the information about the classes and their methods, for example, when
* loading the BOOTCLASSPATH jars in order to analyze a dex file
* @return a boolean value indicating whether to skip any instructions in a code item
*/
public boolean skipInstructions() {
return skipInstructions;
}
/**
* Get a boolean value indicating whether all items should be placed into a
* (possibly arbitrary) "canonical" ordering. If false, then only the items
* that must be ordered per the dex specification are sorted.
*
* When true, writing the dex file involves somewhat more overhead
*
* If both SortAllItems and Inplace are true, Inplace takes precedence
* @return a boolean value indicating whether all items should be sorted
*/
public boolean getSortAllItems() {
return this.sortAllItems;
}
/**
* Set a boolean value indicating whether all items should be placed into a
* (possibly arbitrary) "canonical" ordering. If false, then only the items
* that must be ordered per the dex specification are sorted.
*
* When true, writing the dex file involves somewhat more overhead
*
* If both SortAllItems and Inplace are true, Inplace takes precedence
* @param value a boolean value indicating whether all items should be sorted
*/
public void setSortAllItems(boolean value) {
this.sortAllItems = value;
}
/**
* @return a boolean value indicating whether this dex file was created by reading in an odex file
*/
public boolean isOdex() {
return this.isOdex;
}
/**
* @return an OdexDependencies object that contains the dependencies for this odex, or null if this
* DexFile represents a dex file instead of an odex file
*/
public OdexDependencies getOdexDependencies() {
return odexDependencies;
}
/**
* @return An OdexHeader object containing the information from the odex header in this dex file, or null if there
* is no odex header
*/
public OdexHeader getOdexHeader() {
return odexHeader;
}
/**
* Get a boolean value indicating whether items in this dex file should be
* written back out "in-place", or whether the normal layout logic should be
* applied.
*
* This should only be used for a dex file that has been read from an existing
* dex file, and no modifications have been made to the dex file. Otherwise,
* there is a good chance that the resulting dex file will be invalid due to
* items that aren't placed correctly
*
* If both SortAllItems and Inplace are true, Inplace takes precedence
* @return a boolean value indicating whether items in this dex file should be
* written back out in-place.
*/
public boolean getInplace() {
return this.inplace;
}
/**
* @return the size of the file, in bytes
*/
public int getFileSize() {
return fileSize;
}
/**
* @return the size of the data section, in bytes
*/
public int getDataSize() {
return dataSize;
}
/**
* @return the offset where the data section begins
*/
public int getDataOffset() {
return dataOffset;
}
/**
* Set a boolean value indicating whether items in this dex file should be
* written back out "in-place", or whether the normal layout logic should be
* applied.
*
* This should only be used for a dex file that has been read from an existing
* dex file, and no modifications have been made to the dex file. Otherwise,
* there is a good chance that the resulting dex file will be invalid due to
* items that aren't placed correctly
*
* If both SortAllItems and Inplace are true, Inplace takes precedence
* @param value a boolean value indicating whether items in this dex file should be
* written back out in-place.
*/
public void setInplace(boolean value) {
this.inplace = value;
}
/**
* Get an array of Section objects that are sorted by offset.
* @return an array of Section objects that are sorted by offset.
*/
protected Section[] getOrderedSections() {
int sectionCount = 0;
for (Section section: sectionsByType) {
if (section != null && section.getItems().size() > 0) {
sectionCount++;
}
}
Section[] sections = new Section[sectionCount];
sectionCount = 0;
for (Section section: sectionsByType) {
if (section != null && section.getItems().size() > 0) {
sections[sectionCount++] = section;
}
}
Arrays.sort(sections, new Comparator<Section>() {
public int compare(Section a, Section b) {
return a.getOffset() - b.getOffset();
}
});
return sections;
}
/**
* This method should be called before writing a dex file. It sorts the sections
* as needed or as indicated by <code>getSortAllItems()</code> and <code>getInplace()</code>,
* and then performs a pass through all of the items, finalizing the position (i.e.
* index and/or offset) of each item in the dex file.
*
* This step is needed primarily so that the indexes and offsets of all indexed and
* offsetted items are available when writing references to those items elsewhere.
*/
public void place() {
int offset = HeaderItem.placeAt(0, 0);
int sectionsPosition = 0;
Section[] sections;
if (this.inplace) {
sections = this.getOrderedSections();
} else {
sections = new Section[indexedSections.length + offsettedSections.length];
System.arraycopy(indexedSections, 0, sections, 0, indexedSections.length);
System.arraycopy(offsettedSections, 0, sections, indexedSections.length, offsettedSections.length);
}
while (sectionsPosition < sections.length && sections[sectionsPosition].ItemType.isIndexedItem()) {
Section section = sections[sectionsPosition];
if (!this.inplace) {
section.sortSection();
}
offset = section.placeAt(offset);
sectionsPosition++;
}
dataOffset = offset;
while (sectionsPosition < sections.length) {
Section section = sections[sectionsPosition];
if (this.sortAllItems && !this.inplace) {
section.sortSection();
}
offset = section.placeAt(offset);
sectionsPosition++;
}
offset = AlignmentUtils.alignOffset(offset, ItemType.TYPE_MAP_LIST.ItemAlignment);
offset = MapItem.placeAt(offset, 0);
fileSize = offset;
dataSize = offset - dataOffset;
}
/**
* Writes the dex file to the give <code>AnnotatedOutput</code> object. If
* <code>out.Annotates()</code> is true, then annotations that document the format
* of the dex file are written.
*
* You must call <code>place()</code> on this dex file, before calling this method
* @param out the AnnotatedOutput object to write the dex file and annotations to
*
* After calling this method, you should call <code>calcSignature()</code> and
* then <code>calcChecksum()</code> on the resulting byte array, to calculate the
* signature and checksum in the header
*/
public void writeTo(AnnotatedOutput out) {
out.annotate(0, "-----------------------------");
out.annotate(0, "header item");
out.annotate(0, "-----------------------------");
out.annotate(0, " ");
HeaderItem.writeTo(out);
out.annotate(0, " ");
int sectionsPosition = 0;
Section[] sections;
if (this.inplace) {
sections = this.getOrderedSections();
} else {
sections = new Section[indexedSections.length + offsettedSections.length];
System.arraycopy(indexedSections, 0, sections, 0, indexedSections.length);
System.arraycopy(offsettedSections, 0, sections, indexedSections.length, offsettedSections.length);
}
while (sectionsPosition < sections.length) {
sections[sectionsPosition].writeTo(out);
sectionsPosition++;
}
out.alignTo(MapItem.getItemType().ItemAlignment);
out.annotate(0, " ");
out.annotate(0, "-----------------------------");
out.annotate(0, "map item");
out.annotate(0, "-----------------------------");
out.annotate(0, " ");
MapItem.writeTo(out);
}
public final HeaderItem HeaderItem = new HeaderItem(this);
public final MapItem MapItem = new MapItem(this);
/**
* The <code>IndexedSection</code> containing <code>StringIdItem</code> items
*/
public final IndexedSection<StringIdItem> StringIdsSection =
new IndexedSection<StringIdItem>(this, ItemType.TYPE_STRING_ID_ITEM);
/**
* The <code>IndexedSection</code> containing <code>TypeIdItem</code> items
*/
public final IndexedSection<TypeIdItem> TypeIdsSection =
new IndexedSection<TypeIdItem>(this, ItemType.TYPE_TYPE_ID_ITEM);
/**
* The <code>IndexedSection</code> containing <code>ProtoIdItem</code> items
*/
public final IndexedSection<ProtoIdItem> ProtoIdsSection =
new IndexedSection<ProtoIdItem>(this, ItemType.TYPE_PROTO_ID_ITEM);
/**
* The <code>IndexedSection</code> containing <code>FieldIdItem</code> items
*/
public final IndexedSection<FieldIdItem> FieldIdsSection =
new IndexedSection<FieldIdItem>(this, ItemType.TYPE_FIELD_ID_ITEM);
/**
* The <code>IndexedSection</code> containing <code>MethodIdItem</code> items
*/
public final IndexedSection<MethodIdItem> MethodIdsSection =
new IndexedSection<MethodIdItem>(this, ItemType.TYPE_METHOD_ID_ITEM);
/**
* The <code>IndexedSection</code> containing <code>ClassDefItem</code> items
*/
public final IndexedSection<ClassDefItem> ClassDefsSection =
new IndexedSection<ClassDefItem>(this, ItemType.TYPE_CLASS_DEF_ITEM) {
public int placeAt(int offset) {
if (DexFile.this.getInplace()) {
return super.placeAt(offset);
}
int ret = ClassDefItem.placeClassDefItems(this, offset);
Collections.sort(this.items);
this.offset = items.get(0).getOffset();
return ret;
}
protected void sortSection() {
// Do nothing. Sorting is handled by ClassDefItem.ClassDefPlacer, during placement
}
};
/**
* The <code>OffsettedSection</code> containing <code>TypeListItem</code> items
*/
public final OffsettedSection<TypeListItem> TypeListsSection =
new OffsettedSection<TypeListItem>(this, ItemType.TYPE_TYPE_LIST);
/**
* The <code>OffsettedSection</code> containing <code>AnnotationSetRefList</code> items
*/
public final OffsettedSection<AnnotationSetRefList> AnnotationSetRefListsSection =
new OffsettedSection<AnnotationSetRefList>(this, ItemType.TYPE_ANNOTATION_SET_REF_LIST);
/**
* The <code>OffsettedSection</code> containing <code>AnnotationSetItem</code> items
*/
public final OffsettedSection<AnnotationSetItem> AnnotationSetsSection =
new OffsettedSection<AnnotationSetItem>(this, ItemType.TYPE_ANNOTATION_SET_ITEM);
/**
* The <code>OffsettedSection</code> containing <code>ClassDataItem</code> items
*/
public final OffsettedSection<ClassDataItem> ClassDataSection =
new OffsettedSection<ClassDataItem>(this, ItemType.TYPE_CLASS_DATA_ITEM);
/**
* The <code>OffsettedSection</code> containing <code>CodeItem</code> items
*/
public final OffsettedSection<CodeItem> CodeItemsSection =
new OffsettedSection<CodeItem>(this, ItemType.TYPE_CODE_ITEM);
/**
* The <code>OffsettedSection</code> containing <code>StringDataItem</code> items
*/
public final OffsettedSection<StringDataItem> StringDataSection =
new OffsettedSection<StringDataItem>(this, ItemType.TYPE_STRING_DATA_ITEM);
/**
* The <code>OffsettedSection</code> containing <code>DebugInfoItem</code> items
*/
public final OffsettedSection<DebugInfoItem> DebugInfoItemsSection =
new OffsettedSection<DebugInfoItem>(this, ItemType.TYPE_DEBUG_INFO_ITEM);
/**
* The <code>OffsettedSection</code> containing <code>AnnotationItem</code> items
*/
public final OffsettedSection<AnnotationItem> AnnotationsSection =
new OffsettedSection<AnnotationItem>(this, ItemType.TYPE_ANNOTATION_ITEM);
/**
* The <code>OffsettedSection</code> containing <code>EncodedArrayItem</code> items
*/
public final OffsettedSection<EncodedArrayItem> EncodedArraysSection =
new OffsettedSection<EncodedArrayItem>(this, ItemType.TYPE_ENCODED_ARRAY_ITEM);
/**
* The <code>OffsettedSection</code> containing <code>AnnotationDirectoryItem</code> items
*/
public final OffsettedSection<AnnotationDirectoryItem> AnnotationDirectoriesSection =
new OffsettedSection<AnnotationDirectoryItem>(this, ItemType.TYPE_ANNOTATIONS_DIRECTORY_ITEM);
/**
* Calculates the signature for the dex file in the given byte array,
* and then writes the signature to the appropriate location in the header
* containing in the array
*
* @param bytes non-null; the bytes of the file
*/
public static void calcSignature(byte[] bytes) {
MessageDigest md;
try {
md = MessageDigest.getInstance("SHA-1");
} catch (NoSuchAlgorithmException ex) {
throw new RuntimeException(ex);
}
md.update(bytes, 32, bytes.length - 32);
try {
int amt = md.digest(bytes, 12, 20);
if (amt != 20) {
throw new RuntimeException("unexpected digest write: " + amt +
" bytes");
}
} catch (DigestException ex) {
throw new RuntimeException(ex);
}
}
/**
* Calculates the checksum for the <code>.dex</code> file in the
* given array, and modify the array to contain it.
*
* @param bytes non-null; the bytes of the file
*/
public static void calcChecksum(byte[] bytes) {
Adler32 a32 = new Adler32();
a32.update(bytes, 12, bytes.length - 12);
int sum = (int) a32.getValue();
bytes[8] = (byte) sum;
bytes[9] = (byte) (sum >> 8);
bytes[10] = (byte) (sum >> 16);
bytes[11] = (byte) (sum >> 24);
}
public static class NoClassesDexException extends ExceptionWithContext {
public NoClassesDexException(String message) {
super(message);
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/DexFile.java
|
Java
|
asf20
| 36,012
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import com.google.common.base.Preconditions;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.Utf8Utils;
public class HeaderItem extends Item<HeaderItem> {
/**
* the file format magic number, represented as the
* low-order bytes of a string
*/
public static final byte[][] MAGIC_VALUES = new byte[][] {
new byte[] {0x64, 0x65, 0x78, 0x0A, 0x30, 0x33, 0x35, 0x00}, //"dex\n035" + '\0';
new byte[] {0x64, 0x65, 0x78, 0x0A, 0x30, 0x33, 0x36, 0x00}}; //"dex\n036" + '\0';
/** size of this section, in bytes */
private static final int HEADER_SIZE = 0x70;
/** the endianness constants */
private static final int LITTLE_ENDIAN = 0x12345678;
private static final int BIG_ENDIAN = 0x78563412;
/* Which magic value to use when writing out the header item */
private int magic_index = 0;
private boolean checksumSignatureSet = false;
private int checksum;
private byte[] signature;
/**
* Create a new uninitialized <code>HeaderItem</code>
* @param dexFile The <code>DexFile</code> containing this <code>HeaderItem</code>
*/
protected HeaderItem(final DexFile dexFile) {
super(dexFile);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
byte[] readMagic = in.readBytes(8);
boolean success = false;
for (int i=0; i<MAGIC_VALUES.length; i++) {
byte[] magic_value = MAGIC_VALUES[i];
boolean matched = true;
for (int j=0; j<8; j++) {
if (magic_value[j] != readMagic[j]) {
matched = false;
break;
}
}
if (matched) {
success = true;
magic_index = i;
break;
}
}
if (!success) {
throw new RuntimeException("Unrecognized dex magic value");
}
checksum = in.readInt(); //checksum
signature = in.readBytes(20); //signature
checksumSignatureSet = true;
in.readInt(); //filesize
in.readInt(); //header size
int endianTag = in.readInt();
if (endianTag == BIG_ENDIAN) {
throw new RuntimeException("This dex file is big endian. Only little endian is currently supported.");
} else if (endianTag != LITTLE_ENDIAN) {
throw new RuntimeException("The endian tag is not 0x12345678 or 0x78563412");
}
//link_size + link_off
if ((in.readInt() | in.readInt()) != 0) {
System.err.println("This dex file has a link section, which is not supported. Ignoring.");
}
int sectionSize;
int sectionOffset;
//map_offset
sectionOffset = in.readInt();
readContext.addSection(ItemType.TYPE_MAP_LIST, 1, sectionOffset);
//string_id_item
sectionSize = in.readInt();
sectionOffset = in.readInt();
readContext.addSection(ItemType.TYPE_STRING_ID_ITEM, sectionSize, sectionOffset);
//type_id_item
sectionSize = in.readInt();
sectionOffset = in.readInt();
readContext.addSection(ItemType.TYPE_TYPE_ID_ITEM, sectionSize, sectionOffset);
//proto_id_item
sectionSize = in.readInt();
sectionOffset = in.readInt();
readContext.addSection(ItemType.TYPE_PROTO_ID_ITEM, sectionSize, sectionOffset);
//field_id_item
sectionSize = in.readInt();
sectionOffset = in.readInt();
readContext.addSection(ItemType.TYPE_FIELD_ID_ITEM, sectionSize, sectionOffset);
//method_id_item
sectionSize = in.readInt();
sectionOffset = in.readInt();
readContext.addSection(ItemType.TYPE_METHOD_ID_ITEM, sectionSize, sectionOffset);
//class_data_item
sectionSize = in.readInt();
sectionOffset = in.readInt();
readContext.addSection(ItemType.TYPE_CLASS_DEF_ITEM, sectionSize, sectionOffset);
in.readInt(); //data_size
in.readInt(); //data_off
}
/**
* Sets the dex version number.
*
* 35 is the default.
* 36 is for dex files that use extended opcodes (only works with ICS+)
*
* @param version - must be either 35 or 36
*/
public void setVersion(int version) {
if (version == 35) {
magic_index = 0;
return;
}
if (version == 36) {
magic_index = 1;
return;
}
throw new RuntimeException("Invalid dex version number passed to setVersion");
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return HEADER_SIZE;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
StringBuilder magicBuilder = new StringBuilder();
for (int i=0; i<8; i++) {
magicBuilder.append((char)MAGIC_VALUES[magic_index][i]);
}
out.annotate("magic: " + Utf8Utils.escapeString(magicBuilder.toString()));
out.write(MAGIC_VALUES[magic_index]);
out.annotate("checksum");
out.writeInt(0);
out.annotate("signature");
out.write(new byte[20]);
out.annotate("file_size: 0x" + Integer.toHexString(dexFile.getFileSize()) + " (" + dexFile.getFileSize() +
" bytes)");
out.writeInt(dexFile.getFileSize());
out.annotate("header_size: 0x" + Integer.toHexString(HEADER_SIZE));
out.writeInt(HEADER_SIZE);
out.annotate("endian_tag: 0x" + Integer.toHexString(LITTLE_ENDIAN));
out.writeInt(LITTLE_ENDIAN);
out.annotate("link_size: 0");
out.writeInt(0);
out.annotate("link_off: 0");
out.writeInt(0);
out.annotate("map_off: 0x" + Integer.toHexString(dexFile.MapItem.getOffset()));
out.writeInt(dexFile.MapItem.getOffset());
out.annotate("string_ids_size: " + dexFile.StringIdsSection.getItems().size());
out.writeInt(dexFile.StringIdsSection.getItems().size());
out.annotate("string_ids_off: 0x" + Integer.toHexString(dexFile.StringIdsSection.getOffset()));
out.writeInt(dexFile.StringIdsSection.getOffset());
out.annotate("type_ids_size: " + dexFile.TypeIdsSection.getItems().size());
out.writeInt(dexFile.TypeIdsSection.getItems().size());
out.annotate("type_ids_off: 0x" + Integer.toHexString(dexFile.TypeIdsSection.getOffset()));
out.writeInt(dexFile.TypeIdsSection.getOffset());
out.annotate("proto_ids_size: " + dexFile.ProtoIdsSection.getItems().size());
out.writeInt(dexFile.ProtoIdsSection.getItems().size());
out.annotate("proto_ids_off: 0x" + Integer.toHexString(dexFile.ProtoIdsSection.getOffset()));
out.writeInt(dexFile.ProtoIdsSection.getOffset());
out.annotate("field_ids_size: " + dexFile.FieldIdsSection.getItems().size());
out.writeInt(dexFile.FieldIdsSection.getItems().size());
out.annotate("field_ids_off: 0x" + Integer.toHexString(dexFile.FieldIdsSection.getOffset()));
out.writeInt(dexFile.FieldIdsSection.getOffset());
out.annotate("method_ids_size: " + dexFile.MethodIdsSection.getItems().size());
out.writeInt(dexFile.MethodIdsSection.getItems().size());
out.annotate("method_ids_off: 0x" + Integer.toHexString(dexFile.MethodIdsSection.getOffset()));
out.writeInt(dexFile.MethodIdsSection.getOffset());
out.annotate("class_defs_size: " + dexFile.ClassDefsSection.getItems().size());
out.writeInt(dexFile.ClassDefsSection.getItems().size());
out.annotate("class_defs_off: 0x" + Integer.toHexString(dexFile.ClassDefsSection.getOffset()));
out.writeInt(dexFile.ClassDefsSection.getOffset());
out.annotate("data_size: 0x" + Integer.toHexString(dexFile.getDataSize()) + " (" + dexFile.getDataSize() +
" bytes)");
out.writeInt(dexFile.getDataSize());
out.annotate("data_off: 0x" + Integer.toHexString(dexFile.getDataOffset()));
out.writeInt(dexFile.getDataOffset());
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_HEADER_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "header_item";
}
/** {@inheritDoc} */
public int compareTo(HeaderItem o) {
//there is only 1 header item
return 0;
}
/**
* Get the checksum that was originally stored as part of this header item
*
* Note that this should only be called if this HeaderItem is from a DexFile that was read from disk, as opposed
* to one that is created from scratch.
*
* @return The addler32 checksum (as an integer) of the dex file
*/
public int getChecksum() {
Preconditions.checkState(checksumSignatureSet,
"This can only be called on a DexFile that was read from disk.");
return checksum;
}
/**
* Get the signature that was originally stored as part of this header item
*
* Note that this should only be called if this HeaderItem is from a DexFile that was read from disk, as opposed
* to one that is created from scratch.
*
* @return The sha1 checksum of the dex file, as a 20-element byte array
*/
public byte[] getSignature() {
Preconditions.checkState(checksumSignatureSet,
"This can only be called on a DexFile that was read from disk.");
return signature;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/HeaderItem.java
|
Java
|
asf20
| 11,143
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.AnnotatedOutput;
import org.jf.dexlib.Util.Input;
import org.jf.dexlib.Util.ReadOnlyArrayList;
import java.util.List;
public class TypeListItem extends Item<TypeListItem> {
private int hashCode = 0;
private TypeIdItem[] typeList;
/**
* Creates a new uninitialized <code>TypeListItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
protected TypeListItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>TypeListItem</code> for the given string
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param typeList A list of the types that this <code>TypeListItem</code> represents
*/
private TypeListItem(DexFile dexFile, TypeIdItem[] typeList) {
super(dexFile);
this.typeList = typeList;
}
/**
* Returns a <code>TypeListItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param typeList A list of the types that this <code>TypeListItem</code> represents
* @return a <code>TypeListItem</code> for the given values, and that has been interned into
* the given <code>DexFile</code>
*/
public static TypeListItem internTypeListItem(DexFile dexFile, List<TypeIdItem> typeList) {
TypeIdItem[] typeArray = new TypeIdItem[typeList.size()];
typeList.toArray(typeArray);
TypeListItem typeListItem = new TypeListItem(dexFile, typeArray);
return dexFile.TypeListsSection.intern(typeListItem);
}
/**
* Looks up the <code>TypeListItem</code> from the given <code>DexFile</code> for the given
* list of types
* @param dexFile the <code>Dexfile</code> to find the type in
* @param typeList A list of the types that the <code>TypeListItem</code> represents
* @return a <code>TypeListItem</code> from the given <code>DexFile</code> for the given
* list of types, or null if it doesn't exist
*/
public static TypeListItem lookupTypeListItem(DexFile dexFile, List<TypeIdItem> typeList) {
TypeIdItem[] typeArray = new TypeIdItem[typeList.size()];
typeList.toArray(typeArray);
TypeListItem typeListItem = new TypeListItem(dexFile, typeArray);
return dexFile.TypeListsSection.getInternedItem(typeListItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
int size = in.readInt();
typeList = new TypeIdItem[size];
for (int i=0; i<size; i++) {
int typeIndex = in.readShort();
typeList[i] = dexFile.TypeIdsSection.getItemByIndex(typeIndex);
}
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
return offset + 4 + typeList.length * 2;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
//yes, the code to write the item is duplicated. This eliminates the need to iterate over the list twice
if (out.annotates()) {
out.annotate(4, "size: 0x" + Integer.toHexString(typeList.length) + " (" + typeList.length +")");
for (TypeIdItem typeIdItem: typeList) {
out.annotate(2, "type_id_item: " + typeIdItem.getTypeDescriptor());
}
}
out.writeInt(typeList.length);
for (TypeIdItem typeIdItem: typeList) {
int typeIndex = typeIdItem.getIndex();
if (typeIndex > 0xffff) {
throw new RuntimeException(String.format("Error writing type_list entry. The type index of " +
"type %s is too large", typeIdItem.getTypeDescriptor()));
}
out.writeShort(typeIndex);
}
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_TYPE_LIST;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
return "type_list: " + getTypeListString("");
}
/** {@inheritDoc} */
public int compareTo(TypeListItem o) {
if (o == null) {
return 1;
}
int thisSize = typeList.length;
int otherSize = o.typeList.length;
int size = Math.min(thisSize, otherSize);
for (int i = 0; i < size; i++) {
int result = typeList[i].compareTo(o.typeList[i]);
if (result != 0) {
return result;
}
}
if (thisSize < otherSize) {
return -1;
} else if (thisSize > otherSize) {
return 1;
} else {
return 0;
}
}
/**
* @return the number of registers required for this <code>TypeListItem</code>
*/
public int getRegisterCount() {
int wordCount = 0;
for (TypeIdItem typeIdItem: typeList) {
wordCount += typeIdItem.getRegisterCount();
}
return wordCount;
}
/**
* @return a string consisting of the type descriptors in this <code>TypeListItem</code>
* that are separated by the given separator
* @param separator the separator between each type
*/
public String getTypeListString(String separator) {
int size = 0;
for (TypeIdItem typeIdItem: typeList) {
size += typeIdItem.getTypeDescriptor().length();
size += separator.length();
}
StringBuilder sb = new StringBuilder(size);
for (TypeIdItem typeIdItem: typeList) {
sb.append(typeIdItem.getTypeDescriptor());
sb.append(separator);
}
if (typeList.length > 0) {
sb.delete(sb.length() - separator.length(), sb.length());
}
return sb.toString();
}
/**
* @return a string consisting of the shorty form of the type descriptors in this
* <code>TypeListItem</code> that are directly concatenated together
*/
public String getShortyString() {
StringBuilder sb = new StringBuilder();
for (TypeIdItem typeIdItem: typeList) {
sb.append(typeIdItem.toShorty());
}
return sb.toString();
}
/**
* @param index the index of the <code>TypeIdItem</code> to get
* @return the <code>TypeIdItem</code> at the given index
*/
public TypeIdItem getTypeIdItem(int index) {
return typeList[index];
}
/**
* @return the number of types in this <code>TypeListItem</code>
*/
public int getTypeCount() {
return typeList.length;
}
/**
* @return an array of the <code>TypeIdItems</code> in this <code>TypeListItem</code>
*/
public List<TypeIdItem> getTypes() {
return new ReadOnlyArrayList<TypeIdItem>(typeList);
}
/**
* Helper method to allow easier "inline" retrieval of of the list of TypeIdItems
* @param typeListItem the typeListItem to return the types of (can be null)
* @return an array of the <code>TypeIdItems</code> in the specified <code>TypeListItem</code>, or null if the
* TypeListItem is null
*/
public static List<TypeIdItem> getTypes(TypeListItem typeListItem) {
return typeListItem==null?null:typeListItem.getTypes();
}
/**
* calculate and cache the hashcode
*/
private void calcHashCode() {
int hashCode = 1;
for (TypeIdItem typeIdItem: typeList) {
hashCode = 31 * hashCode + typeIdItem.hashCode();
}
this.hashCode = hashCode;
}
@Override
public int hashCode() {
//there's a small possibility that the actual hash code will be 0. If so, we'll
//just end up recalculating it each time
if (hashCode == 0)
calcHashCode();
return hashCode;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
//This assumes that the referenced items have been interned in both objects.
//This is a valid assumption because all outside code must use the static
//"getInterned..." style methods to make new items, and any item created
//internally is guaranteed to be interned
TypeListItem other = (TypeListItem)o;
if (typeList.length != other.typeList.length) {
return false;
}
for (int i=0; i<typeList.length; i++) {
if (typeList[i] != other.typeList[i]) {
return false;
}
}
return true;
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/TypeListItem.java
|
Java
|
asf20
| 10,193
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import com.google.common.base.Preconditions;
import org.jf.dexlib.Util.*;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.*;
public class ClassDataItem extends Item<ClassDataItem> {
@Nullable
private EncodedField[] staticFields = null;
@Nullable
private EncodedField[] instanceFields = null;
@Nullable
private EncodedMethod[] directMethods = null;
@Nullable
private EncodedMethod[] virtualMethods = null;
/**
* Creates a new uninitialized <code>ClassDataItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
public ClassDataItem(final DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>ClassDataItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param staticFields The static fields for this class
* @param instanceFields The instance fields for this class
* @param directMethods The direct methods for this class
* @param virtualMethods The virtual methods for this class
*/
private ClassDataItem(DexFile dexFile, @Nullable EncodedField[] staticFields,
@Nullable EncodedField[] instanceFields, @Nullable EncodedMethod[] directMethods,
@Nullable EncodedMethod[] virtualMethods) {
super(dexFile);
this.staticFields = staticFields;
this.instanceFields = instanceFields;
this.directMethods = directMethods;
this.virtualMethods = virtualMethods;
}
/**
* Creates a new <code>ClassDataItem</code> with the given values
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param staticFields The static fields for this class
* @param instanceFields The instance fields for this class
* @param directMethods The direct methods for this class
* @param virtualMethods The virtual methods for this class
* @return a new <code>ClassDataItem</code> with the given values
*/
public static ClassDataItem internClassDataItem(DexFile dexFile, @Nullable List<EncodedField> staticFields,
@Nullable List<EncodedField> instanceFields,
@Nullable List<EncodedMethod> directMethods,
@Nullable List<EncodedMethod> virtualMethods) {
EncodedField[] staticFieldsArray = null;
EncodedField[] instanceFieldsArray = null;
EncodedMethod[] directMethodsArray = null;
EncodedMethod[] virtualMethodsArray = null;
if (staticFields != null && staticFields.size() > 0) {
SortedSet<EncodedField> staticFieldsSet = new TreeSet<EncodedField>();
for (EncodedField staticField: staticFields) {
if (staticFieldsSet.contains(staticField)) {
System.err.println(String.format("Ignoring duplicate static field definition: %s",
staticField.field.getFieldString()));
continue;
}
staticFieldsSet.add(staticField);
}
staticFieldsArray = new EncodedField[staticFieldsSet.size()];
staticFieldsArray = staticFieldsSet.toArray(staticFieldsArray);
}
if (instanceFields != null && instanceFields.size() > 0) {
SortedSet<EncodedField> instanceFieldsSet = new TreeSet<EncodedField>();
for (EncodedField instanceField: instanceFields) {
if (instanceFieldsSet.contains(instanceField)) {
System.err.println(String.format("Ignoring duplicate instance field definition: %s",
instanceField.field.getFieldString()));
continue;
}
instanceFieldsSet.add(instanceField);
}
instanceFieldsArray = new EncodedField[instanceFieldsSet.size()];
instanceFieldsArray = instanceFieldsSet.toArray(instanceFieldsArray);
}
TreeSet<EncodedMethod> directMethodSet = new TreeSet<EncodedMethod>();
if (directMethods != null && directMethods.size() > 0) {
for (EncodedMethod directMethod: directMethods) {
if (directMethodSet.contains(directMethod)) {
System.err.println(String.format("Ignoring duplicate direct method definition: %s",
directMethod.method.getMethodString()));
continue;
}
directMethodSet.add(directMethod);
}
directMethodsArray = new EncodedMethod[directMethodSet.size()];
directMethodsArray = directMethodSet.toArray(directMethodsArray);
}
if (virtualMethods != null && virtualMethods.size() > 0) {
TreeSet<EncodedMethod> virtualMethodSet = new TreeSet<EncodedMethod>();
for (EncodedMethod virtualMethod: virtualMethods) {
if (directMethodSet.contains(virtualMethod)) {
// If both a direct and virtual definition is present, dalvik's behavior seems to be undefined,
// so we can't gracefully handle this case, like we can if the duplicates are all direct or all
// virtual -- in which case, we ignore all but the first definition
throw new RuntimeException(String.format("Duplicate direct+virtual method definition: %s",
virtualMethod.method.getMethodString()));
}
if (virtualMethodSet.contains(virtualMethod)) {
System.err.println(String.format("Ignoring duplicate virtual method definition: %s",
virtualMethod.method.getMethodString()));
continue;
}
virtualMethodSet.add(virtualMethod);
}
virtualMethodsArray = new EncodedMethod[virtualMethodSet.size()];
virtualMethodsArray = virtualMethodSet.toArray(virtualMethodsArray);
}
ClassDataItem classDataItem = new ClassDataItem(dexFile, staticFieldsArray, instanceFieldsArray,
directMethodsArray, virtualMethodsArray);
return dexFile.ClassDataSection.intern(classDataItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
int staticFieldsCount = in.readUnsignedLeb128();
int instanceFieldsCount = in.readUnsignedLeb128();
int directMethodsCount = in.readUnsignedLeb128();
int virtualMethodsCount = in.readUnsignedLeb128();
if (staticFieldsCount > 0) {
staticFields = new EncodedField[staticFieldsCount];
EncodedField previousEncodedField = null;
for (int i=0; i<staticFieldsCount; i++) {
try {
staticFields[i] = previousEncodedField = new EncodedField(dexFile, in, previousEncodedField);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while reading static field at index " + i);
}
}
}
if (instanceFieldsCount > 0) {
instanceFields = new EncodedField[instanceFieldsCount];
EncodedField previousEncodedField = null;
for (int i=0; i<instanceFieldsCount; i++) {
try {
instanceFields[i] = previousEncodedField = new EncodedField(dexFile, in, previousEncodedField);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while reading instance field at index " + i);
}
}
}
if (directMethodsCount > 0) {
directMethods = new EncodedMethod[directMethodsCount];
EncodedMethod previousEncodedMethod = null;
for (int i=0; i<directMethodsCount; i++) {
try {
directMethods[i] = previousEncodedMethod = new EncodedMethod(dexFile, readContext, in,
previousEncodedMethod);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while reading direct method at index " + i);
}
}
}
if (virtualMethodsCount > 0) {
virtualMethods = new EncodedMethod[virtualMethodsCount];
EncodedMethod previousEncodedMethod = null;
for (int i=0; i<virtualMethodsCount; i++) {
try {
virtualMethods[i] = previousEncodedMethod = new EncodedMethod(dexFile, readContext, in,
previousEncodedMethod);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while reading virtual method at index " + i);
}
}
}
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
offset += Leb128Utils.unsignedLeb128Size(getStaticFieldCount());
offset += Leb128Utils.unsignedLeb128Size(getInstanceFieldCount());
offset += Leb128Utils.unsignedLeb128Size(getDirectMethodCount());
offset += Leb128Utils.unsignedLeb128Size(getVirtualMethodCount());
if (staticFields != null) {
EncodedField previousEncodedField = null;
for (EncodedField encodedField: staticFields) {
offset = encodedField.place(offset, previousEncodedField);
previousEncodedField = encodedField;
}
}
if (instanceFields != null) {
EncodedField previousEncodedField = null;
for (EncodedField encodedField: instanceFields) {
offset = encodedField.place(offset, previousEncodedField);
previousEncodedField = encodedField;
}
}
if (directMethods != null) {
EncodedMethod previousEncodedMethod = null;
for (EncodedMethod encodedMethod: directMethods) {
offset = encodedMethod.place(offset, previousEncodedMethod);
previousEncodedMethod = encodedMethod;
}
}
if (virtualMethods != null) {
EncodedMethod previousEncodedMethod = null;
for (EncodedMethod encodedMethod: virtualMethods) {
offset = encodedMethod.place(offset, previousEncodedMethod);
previousEncodedMethod = encodedMethod;
}
}
return offset;
}
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
if (out.annotates()) {
int staticFieldCount = getStaticFieldCount();
out.annotate("static_fields_size: 0x" + Integer.toHexString(staticFieldCount) + " (" +
staticFieldCount + ")");
out.writeUnsignedLeb128(staticFieldCount);
int instanceFieldCount = getInstanceFieldCount();
out.annotate("instance_fields_size: 0x" + Integer.toHexString(instanceFieldCount) + " (" +
instanceFieldCount + ")");
out.writeUnsignedLeb128(instanceFieldCount);
int directMethodCount = getDirectMethodCount();
out.annotate("direct_methods_size: 0x" + Integer.toHexString(directMethodCount) + " (" +
directMethodCount + ")");
out.writeUnsignedLeb128(directMethodCount);
int virtualMethodCount = getVirtualMethodCount();
out.annotate("virtual_methods_size: 0x" + Integer.toHexString(virtualMethodCount) + " (" +
virtualMethodCount + ")");
out.writeUnsignedLeb128(virtualMethodCount);
if (staticFields != null) {
int index = 0;
EncodedField previousEncodedField = null;
for (EncodedField encodedField: staticFields) {
out.annotate("[" + index++ + "] static_field");
out.indent();
encodedField.writeTo(out, previousEncodedField);
out.deindent();
previousEncodedField = encodedField;
}
}
if (instanceFields != null) {
int index = 0;
EncodedField previousEncodedField = null;
for (EncodedField encodedField: instanceFields) {
out.annotate("[" + index++ + "] instance_field");
out.indent();
encodedField.writeTo(out, previousEncodedField);
out.deindent();
previousEncodedField = encodedField;
}
}
if (directMethods != null) {
int index = 0;
EncodedMethod previousEncodedMethod = null;
for (EncodedMethod encodedMethod: directMethods) {
out.annotate("[" + index++ + "] direct_method");
out.indent();
encodedMethod.writeTo(out, previousEncodedMethod);
out.deindent();
previousEncodedMethod = encodedMethod;
}
}
if (virtualMethods != null) {
int index = 0;
EncodedMethod previousEncodedMethod = null;
for (EncodedMethod encodedMethod: virtualMethods) {
out.annotate("[" + index++ + "] virtual_method");
out.indent();
encodedMethod.writeTo(out, previousEncodedMethod);
out.deindent();
previousEncodedMethod = encodedMethod;
}
}
} else {
out.writeUnsignedLeb128(getStaticFieldCount());
out.writeUnsignedLeb128(getInstanceFieldCount());
out.writeUnsignedLeb128(getDirectMethodCount());
out.writeUnsignedLeb128(getVirtualMethodCount());
if (staticFields != null) {
EncodedField previousEncodedField = null;
for (EncodedField encodedField: staticFields) {
encodedField.writeTo(out, previousEncodedField);
previousEncodedField = encodedField;
}
}
if (instanceFields != null) {
EncodedField previousEncodedField = null;
for (EncodedField encodedField: instanceFields) {
encodedField.writeTo(out, previousEncodedField);
previousEncodedField = encodedField;
}
}
if (directMethods != null) {
EncodedMethod previousEncodedMethod = null;
for (EncodedMethod encodedMethod: directMethods) {
encodedMethod.writeTo(out, previousEncodedMethod);
previousEncodedMethod = encodedMethod;
}
}
if (virtualMethods != null) {
EncodedMethod previousEncodedMethod = null;
for (EncodedMethod encodedMethod: virtualMethods) {
encodedMethod.writeTo(out, previousEncodedMethod);
previousEncodedMethod = encodedMethod;
}
}
}
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_CLASS_DATA_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
TypeIdItem parentType = getParentType();
if (parentType == null) {
return "class_data_item @0x" + Integer.toHexString(getOffset());
}
return "class_data_item @0x" + Integer.toHexString(getOffset()) + " (" + parentType.getTypeDescriptor() +")";
}
/** {@inheritDoc} */
public int compareTo(ClassDataItem other) {
Preconditions.checkNotNull(other);
// An empty CodeDataItem may be shared by multiple ClassDefItems, so we can't use parent in this case
if (isEmpty()) {
if (other.isEmpty()) {
return 0;
}
return -1;
}
if (other.isEmpty()) {
return 1;
}
TypeIdItem parentType = getParentType();
TypeIdItem otherParentType= other.getParentType();
if (parentType == null) {
if (otherParentType == null) {
return 0;
}
return -1;
}
if (otherParentType == null) {
return 1;
}
return parentType.compareTo(otherParentType);
}
@Override
public int hashCode() {
// If the item has a single parent, we can use the re-use the identity (hash) of that parent
TypeIdItem parentType = getParentType();
if (parentType != null) {
return parentType.hashCode();
}
return 0;
}
/**
* Returns the parent type for a non-empty ClassDataItem, or null for an empty one (which could be referenced by
* multiple ClassDefItem parents)
*
* Only an empty ClassDataItem may have multiple parents.
*
* @return The parent type for this ClassDefItem, or null if it may have multiple parents
*/
@Nullable
public TypeIdItem getParentType() {
if (staticFields != null && staticFields.length > 0) {
return staticFields[0].field.getContainingClass();
}
if (instanceFields != null && instanceFields.length > 0) {
return instanceFields[0].field.getContainingClass();
}
if (directMethods != null && directMethods.length > 0) {
return directMethods[0].method.getContainingClass();
}
if (virtualMethods != null && virtualMethods.length > 0) {
return virtualMethods[0].method.getContainingClass();
}
return null;
}
/**
* @return the static fields for this class
*/
@Nonnull
public List<EncodedField> getStaticFields() {
if (staticFields == null) {
return Collections.emptyList();
}
return ReadOnlyArrayList.of(staticFields);
}
/**
* @return the instance fields for this class
*/
@Nonnull
public List<EncodedField> getInstanceFields() {
if (instanceFields == null) {
return Collections.emptyList();
}
return ReadOnlyArrayList.of(instanceFields);
}
/**
* @return the direct methods for this class
*/
@Nonnull
public List<EncodedMethod> getDirectMethods() {
if (directMethods == null) {
return Collections.emptyList();
}
return ReadOnlyArrayList.of(directMethods);
}
/**
* @return the virtual methods for this class
*/
@Nonnull
public List<EncodedMethod> getVirtualMethods() {
if (virtualMethods == null) {
return Collections.emptyList();
}
return ReadOnlyArrayList.of(virtualMethods);
}
/**
* @return The number of static fields in this <code>ClassDataItem</code>
*/
public int getStaticFieldCount() {
if (staticFields == null) {
return 0;
}
return staticFields.length;
}
/**
* @return The number of instance fields in this <code>ClassDataItem</code>
*/
public int getInstanceFieldCount() {
if (instanceFields == null) {
return 0;
}
return instanceFields.length;
}
/**
* @return The number of direct methods in this <code>ClassDataItem</code>
*/
public int getDirectMethodCount() {
if (directMethods == null) {
return 0;
}
return directMethods.length;
}
/**
* @return The number of virtual methods in this <code>ClassDataItem</code>
*/
public int getVirtualMethodCount() {
if (virtualMethods == null) {
return 0;
}
return virtualMethods.length;
}
/**
* @return true if this is an empty ClassDataItem
*/
public boolean isEmpty() {
return (getStaticFieldCount() + getInstanceFieldCount() +
getDirectMethodCount() + getVirtualMethodCount()) == 0;
}
/**
* Performs a binary search for the definition of the specified direct method
* @param methodIdItem The MethodIdItem of the direct method to search for
* @return The EncodedMethod for the specified direct method, or null if not found
*/
public EncodedMethod findDirectMethodByMethodId(MethodIdItem methodIdItem) {
return findMethodByMethodIdInternal(methodIdItem.index, directMethods);
}
/**
* Performs a binary search for the definition of the specified virtual method
* @param methodIdItem The MethodIdItem of the virtual method to search for
* @return The EncodedMethod for the specified virtual method, or null if not found
*/
public EncodedMethod findVirtualMethodByMethodId(MethodIdItem methodIdItem) {
return findMethodByMethodIdInternal(methodIdItem.index, virtualMethods);
}
/**
* Performs a binary search for the definition of the specified method. It can be either direct or virtual
* @param methodIdItem The MethodIdItem of the virtual method to search for
* @return The EncodedMethod for the specified virtual method, or null if not found
*/
public EncodedMethod findMethodByMethodId(MethodIdItem methodIdItem) {
EncodedMethod encodedMethod = findMethodByMethodIdInternal(methodIdItem.index, directMethods);
if (encodedMethod != null) {
return encodedMethod;
}
return findMethodByMethodIdInternal(methodIdItem.index, virtualMethods);
}
private static EncodedMethod findMethodByMethodIdInternal(int methodIdItemIndex, EncodedMethod[] encodedMethods) {
int min = 0;
int max = encodedMethods.length;
while (min<max) {
int index = (min+max)>>1;
EncodedMethod encodedMethod = encodedMethods[index];
int encodedMethodIndex = encodedMethod.method.getIndex();
if (encodedMethodIndex == methodIdItemIndex) {
return encodedMethod;
} else if (encodedMethodIndex < methodIdItemIndex) {
if (min == index) {
break;
}
min = index;
} else {
if (max == index) {
break;
}
max = index;
}
}
return null;
}
public static class EncodedField implements Comparable<EncodedField> {
/**
* The <code>FieldIdItem</code> that this <code>EncodedField</code> is associated with
*/
public final FieldIdItem field;
/**
* The access flags for this field
*/
public final int accessFlags;
/**
* Constructs a new <code>EncodedField</code> with the given values
* @param field The <code>FieldIdItem</code> that this <code>EncodedField</code> is associated with
* @param accessFlags The access flags for this field
*/
public EncodedField(FieldIdItem field, int accessFlags) {
this.field = field;
this.accessFlags = accessFlags;
}
/**
* This is used internally to construct a new <code>EncodedField</code> while reading in a <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that is being read in
* @param in the Input object to read the <code>EncodedField</code> from
* @param previousEncodedField The previous <code>EncodedField</code> in the list containing this
* <code>EncodedField</code>.
*/
private EncodedField(DexFile dexFile, Input in, @Nullable EncodedField previousEncodedField) {
int previousIndex = previousEncodedField==null?0:previousEncodedField.field.getIndex();
field = dexFile.FieldIdsSection.getItemByIndex(in.readUnsignedLeb128() + previousIndex);
accessFlags = in.readUnsignedLeb128();
}
/**
* Writes the <code>EncodedField</code> to the given <code>AnnotatedOutput</code> object
* @param out the <code>AnnotatedOutput</code> object to write to
* @param previousEncodedField The previous <code>EncodedField</code> in the list containing this
* <code>EncodedField</code>.
*/
private void writeTo(AnnotatedOutput out, EncodedField previousEncodedField) {
int previousIndex = previousEncodedField==null?0:previousEncodedField.field.getIndex();
if (out.annotates()) {
out.annotate("field: " + field.getFieldString());
out.writeUnsignedLeb128(field.getIndex() - previousIndex);
out.annotate("access_flags: " + AccessFlags.formatAccessFlagsForField(accessFlags));
out.writeUnsignedLeb128(accessFlags);
}else {
out.writeUnsignedLeb128(field.getIndex() - previousIndex);
out.writeUnsignedLeb128(accessFlags);
}
}
/**
* Calculates the size of this <code>EncodedField</code> and returns the offset
* immediately following it
* @param offset the offset of this <code>EncodedField</code> in the <code>DexFile</code>
* @param previousEncodedField The previous <code>EncodedField</code> in the list containing this
* <code>EncodedField</code>.
* @return the offset immediately following this <code>EncodedField</code>
*/
private int place(int offset, EncodedField previousEncodedField) {
int previousIndex = previousEncodedField==null?0:previousEncodedField.field.getIndex();
offset += Leb128Utils.unsignedLeb128Size(field.getIndex() - previousIndex);
offset += Leb128Utils.unsignedLeb128Size(accessFlags);
return offset;
}
/**
* Compares this <code>EncodedField</code> to another, based on the comparison of the associated
* <code>FieldIdItem</code>
* @param other The <code>EncodedField</code> to compare against
* @return a standard integer comparison value indicating the relationship
*/
public int compareTo(EncodedField other)
{
return field.compareTo(other.field);
}
/**
* Determines if this <code>EncodedField</code> is equal to other, based on the equality of the associated
* <code>FieldIdItem</code>
* @param other The <code>EncodedField</code> to test for equality
* @return true if other is equal to this instance, otherwise false
*/
public boolean equals(Object other) {
if (other instanceof EncodedField) {
return compareTo((EncodedField)other) == 0;
}
return false;
}
/**
* @return true if this is a static field
*/
public boolean isStatic() {
return (accessFlags & AccessFlags.STATIC.getValue()) != 0;
}
}
public static class EncodedMethod implements Comparable<EncodedMethod> {
/**
* The <code>MethodIdItem</code> that this <code>EncodedMethod</code> is associated with
*/
public final MethodIdItem method;
/**
* The access flags for this method
*/
public final int accessFlags;
/**
* The <code>CodeItem</code> containing the code for this method, or null if there is no code for this method
* (i.e. an abstract method)
*/
public final CodeItem codeItem;
/**
* Constructs a new <code>EncodedMethod</code> with the given values
* @param method The <code>MethodIdItem</code> that this <code>EncodedMethod</code> is associated with
* @param accessFlags The access flags for this method
* @param codeItem The <code>CodeItem</code> containing the code for this method, or null if there is no code
* for this method (i.e. an abstract method)
*/
public EncodedMethod(MethodIdItem method, int accessFlags, CodeItem codeItem) {
this.method = method;
this.accessFlags = accessFlags;
this.codeItem = codeItem;
if (codeItem != null) {
codeItem.setParent(this);
}
}
/**
* This is used internally to construct a new <code>EncodedMethod</code> while reading in a <code>DexFile</code>
* @param dexFile The <code>DexFile</code> that is being read in
* @param readContext a <code>ReadContext</code> object to hold information that is only needed while reading
* in a file
* @param in the Input object to read the <code>EncodedMethod</code> from
* @param previousEncodedMethod The previous <code>EncodedMethod</code> in the list containing this
* <code>EncodedMethod</code>.
*/
public EncodedMethod(DexFile dexFile, ReadContext readContext, Input in, EncodedMethod previousEncodedMethod) {
int previousIndex = previousEncodedMethod==null?0:previousEncodedMethod.method.getIndex();
method = dexFile.MethodIdsSection.getItemByIndex(in.readUnsignedLeb128() + previousIndex);
accessFlags = in.readUnsignedLeb128();
if (dexFile.skipInstructions()) {
in.readUnsignedLeb128();
codeItem = null;
} else {
codeItem = (CodeItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_CODE_ITEM,
in.readUnsignedLeb128());
}
if (codeItem != null) {
codeItem.setParent(this);
}
}
/**
* Writes the <code>EncodedMethod</code> to the given <code>AnnotatedOutput</code> object
* @param out the <code>AnnotatedOutput</code> object to write to
* @param previousEncodedMethod The previous <code>EncodedMethod</code> in the list containing this
* <code>EncodedMethod</code>.
*/
private void writeTo(AnnotatedOutput out, EncodedMethod previousEncodedMethod) {
int previousIndex = previousEncodedMethod==null?0:previousEncodedMethod.method.getIndex();
if (out.annotates()) {
out.annotate("method: " + method.getMethodString());
out.writeUnsignedLeb128(method.getIndex() - previousIndex);
out.annotate("access_flags: " + AccessFlags.formatAccessFlagsForMethod(accessFlags));
out.writeUnsignedLeb128(accessFlags);
if (codeItem != null) {
out.annotate("code_off: 0x" + Integer.toHexString(codeItem.getOffset()));
out.writeUnsignedLeb128(codeItem.getOffset());
} else {
out.annotate("code_off: 0x0");
out.writeUnsignedLeb128(0);
}
}else {
out.writeUnsignedLeb128(method.getIndex() - previousIndex);
out.writeUnsignedLeb128(accessFlags);
out.writeUnsignedLeb128(codeItem==null?0:codeItem.getOffset());
}
}
/**
* Calculates the size of this <code>EncodedMethod</code> and returns the offset
* immediately following it
* @param offset the offset of this <code>EncodedMethod</code> in the <code>DexFile</code>
* @param previousEncodedMethod The previous <code>EncodedMethod</code> in the list containing this
* <code>EncodedMethod</code>.
* @return the offset immediately following this <code>EncodedField</code>
*/
private int place(int offset, EncodedMethod previousEncodedMethod) {
int previousIndex = previousEncodedMethod==null?0:previousEncodedMethod.method.getIndex();
offset += Leb128Utils.unsignedLeb128Size(method.getIndex() - previousIndex);
offset += Leb128Utils.unsignedLeb128Size(accessFlags);
offset += codeItem==null?1:Leb128Utils.unsignedLeb128Size(codeItem.getOffset());
return offset;
}
/**
* Compares this <code>EncodedMethod</code> to another, based on the comparison of the associated
* <code>MethodIdItem</code>
* @param other The <code>EncodedMethod</code> to compare against
* @return a standard integer comparison value indicating the relationship
*/
public int compareTo(EncodedMethod other) {
return method.compareTo(other.method);
}
/**
* Determines if this <code>EncodedMethod</code> is equal to other, based on the equality of the associated
* <code>MethodIdItem</code>
* @param other The <code>EncodedMethod</code> to test for equality
* @return true if other is equal to this instance, otherwise false
*/
public boolean equals(Object other) {
if (other instanceof EncodedMethod) {
return compareTo((EncodedMethod)other) == 0;
}
return false;
}
/**
* @return true if this is a direct method
*/
public boolean isDirect() {
return ((accessFlags & (AccessFlags.STATIC.getValue() | AccessFlags.PRIVATE.getValue() |
AccessFlags.CONSTRUCTOR.getValue())) != 0);
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/ClassDataItem.java
|
Java
|
asf20
| 35,230
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Code.Format.*;
import org.jf.dexlib.Code.*;
import org.jf.dexlib.Debug.DebugInstructionIterator;
import org.jf.dexlib.Debug.DebugOpcode;
import org.jf.dexlib.Util.*;
import java.util.ArrayList;
import java.util.List;
public class CodeItem extends Item<CodeItem> {
private int registerCount;
private int inWords;
private int outWords;
private DebugInfoItem debugInfo;
private Instruction[] instructions;
private TryItem[] tries;
private EncodedCatchHandler[] encodedCatchHandlers;
private ClassDataItem.EncodedMethod parent;
/**
* Creates a new uninitialized <code>CodeItem</code>
* @param dexFile The <code>DexFile</code> that this item belongs to
*/
public CodeItem(DexFile dexFile) {
super(dexFile);
}
/**
* Creates a new <code>CodeItem</code> with the given values.
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param registerCount the number of registers that the method containing this code uses
* @param inWords the number of 2-byte words that the parameters to the method containing this code take
* @param outWords the maximum number of 2-byte words for the arguments of any method call in this code
* @param debugInfo the debug information for this code/method
* @param instructions the instructions for this code item
* @param tries an array of the tries defined for this code/method
* @param encodedCatchHandlers an array of the exception handlers defined for this code/method
*/
private CodeItem(DexFile dexFile,
int registerCount,
int inWords,
int outWords,
DebugInfoItem debugInfo,
Instruction[] instructions,
TryItem[] tries,
EncodedCatchHandler[] encodedCatchHandlers) {
super(dexFile);
this.registerCount = registerCount;
this.inWords = inWords;
this.outWords = outWords;
this.debugInfo = debugInfo;
if (debugInfo != null) {
debugInfo.setParent(this);
}
this.instructions = instructions;
this.tries = tries;
this.encodedCatchHandlers = encodedCatchHandlers;
}
/**
* Returns a new <code>CodeItem</code> with the given values.
* @param dexFile The <code>DexFile</code> that this item belongs to
* @param registerCount the number of registers that the method containing this code uses
* @param inWords the number of 2-byte words that the parameters to the method containing this code take
* @param outWords the maximum number of 2-byte words for the arguments of any method call in this code
* @param debugInfo the debug information for this code/method
* @param instructions the instructions for this code item
* @param tries a list of the tries defined for this code/method or null if none
* @param encodedCatchHandlers a list of the exception handlers defined for this code/method or null if none
* @return a new <code>CodeItem</code> with the given values.
*/
public static CodeItem internCodeItem(DexFile dexFile,
int registerCount,
int inWords,
int outWords,
DebugInfoItem debugInfo,
List<Instruction> instructions,
List<TryItem> tries,
List<EncodedCatchHandler> encodedCatchHandlers) {
TryItem[] triesArray = null;
EncodedCatchHandler[] encodedCatchHandlersArray = null;
Instruction[] instructionsArray = null;
if (tries != null && tries.size() > 0) {
triesArray = new TryItem[tries.size()];
tries.toArray(triesArray);
}
if (encodedCatchHandlers != null && encodedCatchHandlers.size() > 0) {
encodedCatchHandlersArray = new EncodedCatchHandler[encodedCatchHandlers.size()];
encodedCatchHandlers.toArray(encodedCatchHandlersArray);
}
if (instructions != null && instructions.size() > 0) {
instructionsArray = new Instruction[instructions.size()];
instructions.toArray(instructionsArray);
}
CodeItem codeItem = new CodeItem(dexFile, registerCount, inWords, outWords, debugInfo, instructionsArray,
triesArray, encodedCatchHandlersArray);
return dexFile.CodeItemsSection.intern(codeItem);
}
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
this.registerCount = in.readShort();
this.inWords = in.readShort();
this.outWords = in.readShort();
int triesCount = in.readShort();
this.debugInfo = (DebugInfoItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_DEBUG_INFO_ITEM,
in.readInt());
if (this.debugInfo != null) {
this.debugInfo.setParent(this);
}
int instructionCount = in.readInt();
final ArrayList<Instruction> instructionList = new ArrayList<Instruction>();
byte[] encodedInstructions = in.readBytes(instructionCount * 2);
InstructionIterator.IterateInstructions(dexFile, encodedInstructions,
new InstructionIterator.ProcessInstructionDelegate() {
public void ProcessInstruction(int codeAddress, Instruction instruction) {
instructionList.add(instruction);
}
});
this.instructions = new Instruction[instructionList.size()];
instructionList.toArray(instructions);
if (triesCount > 0) {
in.alignTo(4);
//we need to read in the catch handlers first, so save the offset to the try items for future reference
int triesOffset = in.getCursor();
in.setCursor(triesOffset + 8 * triesCount);
//read in the encoded catch handlers
int encodedHandlerStart = in.getCursor();
int handlerCount = in.readUnsignedLeb128();
SparseArray<EncodedCatchHandler> handlerMap = new SparseArray<EncodedCatchHandler>(handlerCount);
encodedCatchHandlers = new EncodedCatchHandler[handlerCount];
for (int i=0; i<handlerCount; i++) {
try {
int position = in.getCursor() - encodedHandlerStart;
encodedCatchHandlers[i] = new EncodedCatchHandler(dexFile, in);
handlerMap.append(position, encodedCatchHandlers[i]);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while reading EncodedCatchHandler at index " + i);
}
}
int codeItemEnd = in.getCursor();
//now go back and read the tries
in.setCursor(triesOffset);
tries = new TryItem[triesCount];
for (int i=0; i<triesCount; i++) {
try {
tries[i] = new TryItem(in, handlerMap);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while reading TryItem at index " + i);
}
}
//and now back to the end of the code item
in.setCursor(codeItemEnd);
}
}
/** {@inheritDoc} */
protected int placeItem(int offset) {
offset += 16 + getInstructionsLength() * 2;
if (tries != null && tries.length > 0) {
offset = AlignmentUtils.alignOffset(offset, 4);
offset += tries.length * 8;
int encodedCatchHandlerBaseOffset = offset;
offset += Leb128Utils.unsignedLeb128Size(encodedCatchHandlers.length);
for (EncodedCatchHandler encodedCatchHandler: encodedCatchHandlers) {
offset = encodedCatchHandler.place(offset, encodedCatchHandlerBaseOffset);
}
}
return offset;
}
/** {@inheritDoc} */
protected void writeItem(final AnnotatedOutput out) {
int instructionsLength = getInstructionsLength();
if (out.annotates()) {
out.annotate(0, parent.method.getMethodString());
out.annotate(2, "registers_size: 0x" + Integer.toHexString(registerCount) + " (" + registerCount + ")");
out.annotate(2, "ins_size: 0x" + Integer.toHexString(inWords) + " (" + inWords + ")");
out.annotate(2, "outs_size: 0x" + Integer.toHexString(outWords) + " (" + outWords + ")");
int triesLength = tries==null?0:tries.length;
out.annotate(2, "tries_size: 0x" + Integer.toHexString(triesLength) + " (" + triesLength + ")");
if (debugInfo == null) {
out.annotate(4, "debug_info_off:");
} else {
out.annotate(4, "debug_info_off: 0x" + Integer.toHexString(debugInfo.getOffset()));
}
out.annotate(4, "insns_size: 0x" + Integer.toHexString(instructionsLength) + " (" +
(instructionsLength) + ")");
}
out.writeShort(registerCount);
out.writeShort(inWords);
out.writeShort(outWords);
if (tries == null) {
out.writeShort(0);
} else {
out.writeShort(tries.length);
}
if (debugInfo == null) {
out.writeInt(0);
} else {
out.writeInt(debugInfo.getOffset());
}
out.writeInt(instructionsLength);
int currentCodeAddress = 0;
for (Instruction instruction: instructions) {
currentCodeAddress = instruction.write(out, currentCodeAddress);
}
if (tries != null && tries.length > 0) {
if (out.annotates()) {
if ((currentCodeAddress % 2) != 0) {
out.annotate("padding");
out.writeShort(0);
}
int index = 0;
for (TryItem tryItem: tries) {
out.annotate(0, "[0x" + Integer.toHexString(index++) + "] try_item");
out.indent();
tryItem.writeTo(out);
out.deindent();
}
out.annotate("handler_count: 0x" + Integer.toHexString(encodedCatchHandlers.length) + "(" +
encodedCatchHandlers.length + ")");
out.writeUnsignedLeb128(encodedCatchHandlers.length);
index = 0;
for (EncodedCatchHandler encodedCatchHandler: encodedCatchHandlers) {
out.annotate(0, "[" + Integer.toHexString(index++) + "] encoded_catch_handler");
out.indent();
encodedCatchHandler.writeTo(out);
out.deindent();
}
} else {
if ((currentCodeAddress % 2) != 0) {
out.writeShort(0);
}
for (TryItem tryItem: tries) {
tryItem.writeTo(out);
}
out.writeUnsignedLeb128(encodedCatchHandlers.length);
for (EncodedCatchHandler encodedCatchHandler: encodedCatchHandlers) {
encodedCatchHandler.writeTo(out);
}
}
}
}
/** {@inheritDoc} */
public ItemType getItemType() {
return ItemType.TYPE_CODE_ITEM;
}
/** {@inheritDoc} */
public String getConciseIdentity() {
if (this.parent == null) {
return "code_item @0x" + Integer.toHexString(getOffset());
}
return "code_item @0x" + Integer.toHexString(getOffset()) + " (" + parent.method.getMethodString() + ")";
}
/** {@inheritDoc} */
public int compareTo(CodeItem other) {
if (parent == null) {
if (other.parent == null) {
return 0;
}
return -1;
}
if (other.parent == null) {
return 1;
}
return parent.method.compareTo(other.parent.method);
}
/**
* @return the register count
*/
public int getRegisterCount() {
return registerCount;
}
/**
* @return an array of the instructions in this code item
*/
public Instruction[] getInstructions() {
return instructions;
}
/**
* @return an array of the <code>TryItem</code> objects in this <code>CodeItem</code>
*/
public TryItem[] getTries() {
return tries;
}
/**
* @return an array of the <code>EncodedCatchHandler</code> objects in this <code>CodeItem</code>
*/
public EncodedCatchHandler[] getHandlers() {
return encodedCatchHandlers;
}
/**
* @return the <code>DebugInfoItem</code> associated with this <code>CodeItem</code>
*/
public DebugInfoItem getDebugInfo() {
return debugInfo;
}
/**
* @return the number of 2-byte words that the parameters to the method containing this code take
*/
public int getInWords() {
return inWords;
}
/**
* @return the maximum number of 2-byte words for the arguments of any method call in this code
*/
public int getOutWords() {
return outWords;
}
/**
* Sets the <code>MethodIdItem</code> of the method that this <code>CodeItem</code> is associated with
* @param encodedMethod the <code>EncodedMethod</code> of the method that this <code>CodeItem</code> is associated
* with
*/
protected void setParent(ClassDataItem.EncodedMethod encodedMethod) {
this.parent = encodedMethod;
}
/**
* @return the MethodIdItem of the method that this CodeItem belongs to
*/
public ClassDataItem.EncodedMethod getParent() {
return parent;
}
/**
* Used by OdexUtil to update this <code>CodeItem</code> with a deodexed version of the instructions
* @param newInstructions the new instructions to use for this code item
*/
public void updateCode(Instruction[] newInstructions) {
this.instructions = newInstructions;
}
/**
* @return The length of the instructions in this CodeItem, in 2-byte code blocks
*/
private int getInstructionsLength() {
int currentCodeAddress = 0;
for (Instruction instruction: instructions) {
currentCodeAddress += instruction.getSize(currentCodeAddress);
}
return currentCodeAddress;
}
/**
* Go through the instructions and perform any of the following fixes that are applicable
* - Replace const-string instruction with const-string/jumbo, when the string index is too big
* - Replace goto and goto/16 with a larger version of goto, when the target is too far away
* TODO: we should be able to replace if-* instructions with targets that are too far away with a negated if followed by a goto/32 to the original target
* TODO: remove multiple nops that occur before a switch/array data pseudo instruction. In some cases, multiple smali-baksmali cycles with changes in between could cause nops to start piling up
* TODO: in case of non-range invoke with a jumbo-sized method reference, we could check if the registers are sequential, and replace it with the jumbo variant (which only takes a register range)
*
* The above fixes are applied iteratively, until no more fixes have been performed
*/
public void fixInstructions(boolean fixJumbo, boolean fixGoto) {
try {
boolean didSomething = false;
do
{
didSomething = false;
int currentCodeAddress = 0;
for (int i=0; i<instructions.length; i++) {
Instruction instruction = instructions[i];
try {
if (fixGoto && instruction.opcode == Opcode.GOTO) {
int codeAddress = ((OffsetInstruction)instruction).getTargetAddressOffset();
if (((byte) codeAddress) != codeAddress) {
//the address doesn't fit within a byte, we need to upgrade to a goto/16 or goto/32
if ((short) codeAddress == codeAddress) {
//the address fits in a short, so upgrade to a goto/16
replaceInstructionAtAddress(currentCodeAddress,
new Instruction20t(Opcode.GOTO_16, codeAddress));
}
else {
//The address won't fit into a short, we have to upgrade to a goto/32
replaceInstructionAtAddress(currentCodeAddress,
new Instruction30t(Opcode.GOTO_32, codeAddress));
}
didSomething = true;
break;
}
} else if (fixGoto && instruction.opcode == Opcode.GOTO_16) {
int codeAddress = ((OffsetInstruction)instruction).getTargetAddressOffset();
if (((short) codeAddress) != codeAddress) {
//the address doesn't fit within a short, we need to upgrade to a goto/32
replaceInstructionAtAddress(currentCodeAddress,
new Instruction30t(Opcode.GOTO_32, codeAddress));
didSomething = true;
break;
}
} else if (fixJumbo && instruction.opcode.hasJumboOpcode()) {
InstructionWithReference referenceInstruction = (InstructionWithReference)instruction;
if (referenceInstruction.getReferencedItem().getIndex() > 0xFFFF) {
InstructionWithJumboVariant instructionWithJumboVariant =
(InstructionWithJumboVariant)referenceInstruction;
Instruction jumboInstruction = instructionWithJumboVariant.makeJumbo();
if (jumboInstruction != null) {
replaceInstructionAtAddress(currentCodeAddress,
instructionWithJumboVariant.makeJumbo());
didSomething = true;
break;
}
}
}
currentCodeAddress += instruction.getSize(currentCodeAddress);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while attempting to fix " +
instruction.opcode.name + " instruction at address " + currentCodeAddress);
}
}
}while(didSomething);
} catch (Exception ex) {
throw this.addExceptionContext(ex);
}
}
private void replaceInstructionAtAddress(int codeAddress, Instruction replacementInstruction) {
Instruction originalInstruction = null;
int[] originalInstructionCodeAddresses = new int[instructions.length+1];
SparseIntArray originalSwitchAddressByOriginalSwitchDataAddress = new SparseIntArray();
int currentCodeAddress = 0;
int instructionIndex = 0;
int i;
for (i=0; i<instructions.length; i++) {
Instruction instruction = instructions[i];
if (currentCodeAddress == codeAddress) {
originalInstruction = instruction;
instructionIndex = i;
}
if (instruction.opcode == Opcode.PACKED_SWITCH || instruction.opcode == Opcode.SPARSE_SWITCH) {
OffsetInstruction offsetInstruction = (OffsetInstruction)instruction;
int switchDataAddress = currentCodeAddress + offsetInstruction.getTargetAddressOffset();
if (originalSwitchAddressByOriginalSwitchDataAddress.indexOfKey(switchDataAddress) < 0) {
originalSwitchAddressByOriginalSwitchDataAddress.put(switchDataAddress, currentCodeAddress);
}
}
originalInstructionCodeAddresses[i] = currentCodeAddress;
currentCodeAddress += instruction.getSize(currentCodeAddress);
}
//add the address just past the end of the last instruction, to help when fixing up try blocks that end
//at the end of the method
originalInstructionCodeAddresses[i] = currentCodeAddress;
if (originalInstruction == null) {
throw new RuntimeException("There is no instruction at address " + codeAddress);
}
instructions[instructionIndex] = replacementInstruction;
//if we're replacing the instruction with one of the same size, we don't have to worry about fixing
//up any address
if (originalInstruction.getSize(codeAddress) == replacementInstruction.getSize(codeAddress)) {
return;
}
final SparseIntArray originalAddressByNewAddress = new SparseIntArray();
final SparseIntArray newAddressByOriginalAddress = new SparseIntArray();
currentCodeAddress = 0;
for (i=0; i<instructions.length; i++) {
Instruction instruction = instructions[i];
int originalAddress = originalInstructionCodeAddresses[i];
originalAddressByNewAddress.append(currentCodeAddress, originalAddress);
newAddressByOriginalAddress.append(originalAddress, currentCodeAddress);
currentCodeAddress += instruction.getSize(currentCodeAddress);
}
//add the address just past the end of the last instruction, to help when fixing up try blocks that end
//at the end of the method
originalAddressByNewAddress.append(currentCodeAddress, originalInstructionCodeAddresses[i]);
newAddressByOriginalAddress.append(originalInstructionCodeAddresses[i], currentCodeAddress);
//update any "offset" instructions, or switch data instructions
currentCodeAddress = 0;
for (i=0; i<instructions.length; i++) {
Instruction instruction = instructions[i];
if (instruction instanceof OffsetInstruction) {
OffsetInstruction offsetInstruction = (OffsetInstruction)instruction;
assert originalAddressByNewAddress.indexOfKey(currentCodeAddress) >= 0;
int originalAddress = originalAddressByNewAddress.get(currentCodeAddress);
int originalInstructionTarget = originalAddress + offsetInstruction.getTargetAddressOffset();
assert newAddressByOriginalAddress.indexOfKey(originalInstructionTarget) >= 0;
int newInstructionTarget = newAddressByOriginalAddress.get(originalInstructionTarget);
int newCodeAddress = (newInstructionTarget - currentCodeAddress);
if (newCodeAddress != offsetInstruction.getTargetAddressOffset()) {
offsetInstruction.updateTargetAddressOffset(newCodeAddress);
}
} else if (instruction instanceof MultiOffsetInstruction) {
MultiOffsetInstruction multiOffsetInstruction = (MultiOffsetInstruction)instruction;
assert originalAddressByNewAddress.indexOfKey(currentCodeAddress) >= 0;
int originalDataAddress = originalAddressByNewAddress.get(currentCodeAddress);
int originalSwitchAddress =
originalSwitchAddressByOriginalSwitchDataAddress.get(originalDataAddress, -1);
if (originalSwitchAddress == -1) {
//TODO: maybe we could just remove the unreferenced switch data?
throw new RuntimeException("This method contains an unreferenced switch data block at address " +
+ currentCodeAddress + " and can't be automatically fixed.");
}
assert newAddressByOriginalAddress.indexOfKey(originalSwitchAddress) >= 0;
int newSwitchAddress = newAddressByOriginalAddress.get(originalSwitchAddress);
int[] targets = multiOffsetInstruction.getTargets();
for (int t=0; t<targets.length; t++) {
int originalTargetCodeAddress = originalSwitchAddress + targets[t];
assert newAddressByOriginalAddress.indexOfKey(originalTargetCodeAddress) >= 0;
int newTargetCodeAddress = newAddressByOriginalAddress.get(originalTargetCodeAddress);
int newCodeAddress = newTargetCodeAddress - newSwitchAddress;
if (newCodeAddress != targets[t]) {
multiOffsetInstruction.updateTarget(t, newCodeAddress);
}
}
}
currentCodeAddress += instruction.getSize(currentCodeAddress);
}
if (debugInfo != null) {
final byte[] encodedDebugInfo = debugInfo.getEncodedDebugInfo();
ByteArrayInput debugInput = new ByteArrayInput(encodedDebugInfo);
DebugInstructionFixer debugInstructionFixer = new DebugInstructionFixer(encodedDebugInfo,
newAddressByOriginalAddress);
DebugInstructionIterator.IterateInstructions(debugInput, debugInstructionFixer);
if (debugInstructionFixer.result != null) {
debugInfo.setEncodedDebugInfo(debugInstructionFixer.result);
}
}
if (encodedCatchHandlers != null) {
for (EncodedCatchHandler encodedCatchHandler: encodedCatchHandlers) {
if (encodedCatchHandler.catchAllHandlerAddress != -1) {
assert newAddressByOriginalAddress.indexOfKey(encodedCatchHandler.catchAllHandlerAddress) >= 0;
encodedCatchHandler.catchAllHandlerAddress =
newAddressByOriginalAddress.get(encodedCatchHandler.catchAllHandlerAddress);
}
for (EncodedTypeAddrPair handler: encodedCatchHandler.handlers) {
assert newAddressByOriginalAddress.indexOfKey(handler.handlerAddress) >= 0;
handler.handlerAddress = newAddressByOriginalAddress.get(handler.handlerAddress);
}
}
}
if (this.tries != null) {
for (TryItem tryItem: tries) {
int startAddress = tryItem.startCodeAddress;
int endAddress = tryItem.startCodeAddress + tryItem.tryLength;
assert newAddressByOriginalAddress.indexOfKey(startAddress) >= 0;
tryItem.startCodeAddress = newAddressByOriginalAddress.get(startAddress);
assert newAddressByOriginalAddress.indexOfKey(endAddress) >= 0;
tryItem.tryLength = newAddressByOriginalAddress.get(endAddress) - tryItem.startCodeAddress;
}
}
}
private class DebugInstructionFixer extends DebugInstructionIterator.ProcessRawDebugInstructionDelegate {
private int currentCodeAddress = 0;
private SparseIntArray newAddressByOriginalAddress;
private final byte[] originalEncodedDebugInfo;
public byte[] result = null;
public DebugInstructionFixer(byte[] originalEncodedDebugInfo, SparseIntArray newAddressByOriginalAddress) {
this.newAddressByOriginalAddress = newAddressByOriginalAddress;
this.originalEncodedDebugInfo = originalEncodedDebugInfo;
}
@Override
public void ProcessAdvancePC(int startDebugOffset, int debugInstructionLength, int codeAddressDelta) {
currentCodeAddress += codeAddressDelta;
if (result != null) {
return;
}
int newCodeAddress = newAddressByOriginalAddress.get(currentCodeAddress, -1);
//The address might not point to an actual instruction in some cases, for example, if an AdvancePC
//instruction was inserted just before a "special" instruction, to fix up the addresses for a previous
//instruction replacement.
//In this case, it should be safe to skip, because there will be another AdvancePC/SpecialOpcode that will
//bump up the address to point to a valid instruction before anything (line/local/etc.) is emitted
if (newCodeAddress == -1) {
return;
}
if (newCodeAddress != currentCodeAddress) {
int newCodeAddressDelta = newCodeAddress - (currentCodeAddress - codeAddressDelta);
assert newCodeAddressDelta > 0;
int codeAddressDeltaLeb128Size = Leb128Utils.unsignedLeb128Size(newCodeAddressDelta);
//if the length of the new code address delta is the same, we can use the existing buffer
if (codeAddressDeltaLeb128Size + 1 == debugInstructionLength) {
result = originalEncodedDebugInfo;
Leb128Utils.writeUnsignedLeb128(newCodeAddressDelta, result, startDebugOffset+1);
} else {
//The length of the new code address delta is different, so create a new buffer with enough
//additional space to accomodate the new code address delta value.
result = new byte[originalEncodedDebugInfo.length + codeAddressDeltaLeb128Size -
(debugInstructionLength - 1)];
System.arraycopy(originalEncodedDebugInfo, 0, result, 0, startDebugOffset);
result[startDebugOffset] = DebugOpcode.DBG_ADVANCE_PC.value;
Leb128Utils.writeUnsignedLeb128(newCodeAddressDelta, result, startDebugOffset+1);
System.arraycopy(originalEncodedDebugInfo, startDebugOffset + debugInstructionLength, result,
startDebugOffset + codeAddressDeltaLeb128Size + 1,
originalEncodedDebugInfo.length - (startDebugOffset + codeAddressDeltaLeb128Size + 1));
}
}
}
@Override
public void ProcessSpecialOpcode(int startDebugOffset, int debugOpcode, int lineDelta,
int codeAddressDelta) {
currentCodeAddress += codeAddressDelta;
if (result != null) {
return;
}
int newCodeAddress = newAddressByOriginalAddress.get(currentCodeAddress, -1);
assert newCodeAddress != -1;
if (newCodeAddress != currentCodeAddress) {
int newCodeAddressDelta = newCodeAddress - (currentCodeAddress - codeAddressDelta);
assert newCodeAddressDelta > 0;
//if the new code address delta won't fit in the special opcode, we need to insert
//an additional DBG_ADVANCE_PC opcode
if (lineDelta < 2 && newCodeAddressDelta > 16 || lineDelta > 1 && newCodeAddressDelta > 15) {
int additionalCodeAddressDelta = newCodeAddress - currentCodeAddress;
int additionalCodeAddressDeltaLeb128Size = Leb128Utils.signedLeb128Size(additionalCodeAddressDelta);
//create a new buffer with enough additional space for the new opcode
result = new byte[originalEncodedDebugInfo.length + additionalCodeAddressDeltaLeb128Size + 1];
System.arraycopy(originalEncodedDebugInfo, 0, result, 0, startDebugOffset);
result[startDebugOffset] = 0x01; //DBG_ADVANCE_PC
Leb128Utils.writeUnsignedLeb128(additionalCodeAddressDelta, result, startDebugOffset+1);
System.arraycopy(originalEncodedDebugInfo, startDebugOffset, result,
startDebugOffset+additionalCodeAddressDeltaLeb128Size+1,
result.length - (startDebugOffset+additionalCodeAddressDeltaLeb128Size+1));
} else {
result = originalEncodedDebugInfo;
result[startDebugOffset] = DebugInfoBuilder.calculateSpecialOpcode(lineDelta,
newCodeAddressDelta);
}
}
}
}
public static class TryItem {
/**
* The address (in 2-byte words) within the code where the try block starts
*/
private int startCodeAddress;
/**
* The number of 2-byte words that the try block covers
*/
private int tryLength;
/**
* The associated exception handler
*/
public final EncodedCatchHandler encodedCatchHandler;
/**
* Construct a new <code>TryItem</code> with the given values
* @param startCodeAddress the code address within the code where the try block starts
* @param tryLength the number of code blocks that the try block covers
* @param encodedCatchHandler the associated exception handler
*/
public TryItem(int startCodeAddress, int tryLength, EncodedCatchHandler encodedCatchHandler) {
this.startCodeAddress = startCodeAddress;
this.tryLength = tryLength;
this.encodedCatchHandler = encodedCatchHandler;
}
/**
* This is used internally to construct a new <code>TryItem</code> while reading in a <code>DexFile</code>
* @param in the Input object to read the <code>TryItem</code> from
* @param encodedCatchHandlers a SparseArray of the EncodedCatchHandlers for this <code>CodeItem</code>. The
* key should be the offset of the EncodedCatchHandler from the beginning of the encoded_catch_handler_list
* structure.
*/
private TryItem(Input in, SparseArray<EncodedCatchHandler> encodedCatchHandlers) {
startCodeAddress = in.readInt();
tryLength = in.readShort();
encodedCatchHandler = encodedCatchHandlers.get(in.readShort());
if (encodedCatchHandler == null) {
throw new RuntimeException("Could not find the EncodedCatchHandler referenced by this TryItem");
}
}
/**
* Writes the <code>TryItem</code> to the given <code>AnnotatedOutput</code> object
* @param out the <code>AnnotatedOutput</code> object to write to
*/
private void writeTo(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate(4, "start_addr: 0x" + Integer.toHexString(startCodeAddress));
out.annotate(2, "try_length: 0x" + Integer.toHexString(tryLength) + " (" + tryLength +
")");
out.annotate(2, "handler_off: 0x" + Integer.toHexString(encodedCatchHandler.getOffsetInList()));
}
out.writeInt(startCodeAddress);
out.writeShort(tryLength);
out.writeShort(encodedCatchHandler.getOffsetInList());
}
/**
* @return The address (in 2-byte words) within the code where the try block starts
*/
public int getStartCodeAddress() {
return startCodeAddress;
}
/**
* @return The number of code blocks that the try block covers
*/
public int getTryLength() {
return tryLength;
}
}
public static class EncodedCatchHandler {
/**
* An array of the individual exception handlers
*/
public final EncodedTypeAddrPair[] handlers;
/**
* The address within the code (in 2-byte words) for the catch all handler, or -1 if there is no catch all
* handler
*/
private int catchAllHandlerAddress;
private int baseOffset;
private int offset;
/**
* Constructs a new <code>EncodedCatchHandler</code> with the given values
* @param handlers an array of the individual exception handlers
* @param catchAllHandlerAddress The address within the code (in 2-byte words) for the catch all handler, or -1
* if there is no catch all handler
*/
public EncodedCatchHandler(EncodedTypeAddrPair[] handlers, int catchAllHandlerAddress) {
this.handlers = handlers;
this.catchAllHandlerAddress = catchAllHandlerAddress;
}
/**
* This is used internally to construct a new <code>EncodedCatchHandler</code> while reading in a
* <code>DexFile</code>
* @param dexFile the <code>DexFile</code> that is being read in
* @param in the Input object to read the <code>EncodedCatchHandler</code> from
*/
private EncodedCatchHandler(DexFile dexFile, Input in) {
int handlerCount = in.readSignedLeb128();
if (handlerCount < 0) {
handlers = new EncodedTypeAddrPair[-1 * handlerCount];
} else {
handlers = new EncodedTypeAddrPair[handlerCount];
}
for (int i=0; i<handlers.length; i++) {
try {
handlers[i] = new EncodedTypeAddrPair(dexFile, in);
} catch (Exception ex) {
throw ExceptionWithContext.withContext(ex, "Error while reading EncodedTypeAddrPair at index " + i);
}
}
if (handlerCount <= 0) {
catchAllHandlerAddress = in.readUnsignedLeb128();
} else {
catchAllHandlerAddress = -1;
}
}
/**
* @return the "Catch All" handler address for this <code>EncodedCatchHandler</code>, or -1 if there
* is no "Catch All" handler
*/
public int getCatchAllHandlerAddress() {
return catchAllHandlerAddress;
}
/**
* @return the offset of this <code>EncodedCatchHandler</code> from the beginning of the
* encoded_catch_handler_list structure
*/
private int getOffsetInList() {
return offset-baseOffset;
}
/**
* Places the <code>EncodedCatchHandler</code>, storing the offset and baseOffset, and returning the offset
* immediately following this <code>EncodedCatchHandler</code>
* @param offset the offset of this <code>EncodedCatchHandler</code> in the <code>DexFile</code>
* @param baseOffset the offset of the beginning of the encoded_catch_handler_list structure in the
* <code>DexFile</code>
* @return the offset immediately following this <code>EncodedCatchHandler</code>
*/
private int place(int offset, int baseOffset) {
this.offset = offset;
this.baseOffset = baseOffset;
int size = handlers.length;
if (catchAllHandlerAddress > -1) {
size *= -1;
offset += Leb128Utils.unsignedLeb128Size(catchAllHandlerAddress);
}
offset += Leb128Utils.signedLeb128Size(size);
for (EncodedTypeAddrPair handler: handlers) {
offset += handler.getSize();
}
return offset;
}
/**
* Writes the <code>EncodedCatchHandler</code> to the given <code>AnnotatedOutput</code> object
* @param out the <code>AnnotatedOutput</code> object to write to
*/
private void writeTo(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate("size: 0x" + Integer.toHexString(handlers.length) + " (" + handlers.length + ")");
int size = handlers.length;
if (catchAllHandlerAddress > -1) {
size = size * -1;
}
out.writeSignedLeb128(size);
int index = 0;
for (EncodedTypeAddrPair handler: handlers) {
out.annotate(0, "[" + index++ + "] encoded_type_addr_pair");
out.indent();
handler.writeTo(out);
out.deindent();
}
if (catchAllHandlerAddress > -1) {
out.annotate("catch_all_addr: 0x" + Integer.toHexString(catchAllHandlerAddress));
out.writeUnsignedLeb128(catchAllHandlerAddress);
}
} else {
int size = handlers.length;
if (catchAllHandlerAddress > -1) {
size = size * -1;
}
out.writeSignedLeb128(size);
for (EncodedTypeAddrPair handler: handlers) {
handler.writeTo(out);
}
if (catchAllHandlerAddress > -1) {
out.writeUnsignedLeb128(catchAllHandlerAddress);
}
}
}
@Override
public int hashCode() {
int hash = 0;
for (EncodedTypeAddrPair handler: handlers) {
hash = hash * 31 + handler.hashCode();
}
hash = hash * 31 + catchAllHandlerAddress;
return hash;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
EncodedCatchHandler other = (EncodedCatchHandler)o;
if (handlers.length != other.handlers.length || catchAllHandlerAddress != other.catchAllHandlerAddress) {
return false;
}
for (int i=0; i<handlers.length; i++) {
if (!handlers[i].equals(other.handlers[i])) {
return false;
}
}
return true;
}
}
public static class EncodedTypeAddrPair {
/**
* The type of the <code>Exception</code> that this handler handles
*/
public final TypeIdItem exceptionType;
/**
* The address (in 2-byte words) in the code of the handler
*/
private int handlerAddress;
/**
* Constructs a new <code>EncodedTypeAddrPair</code> with the given values
* @param exceptionType the type of the <code>Exception</code> that this handler handles
* @param handlerAddress the address (in 2-byte words) in the code of the handler
*/
public EncodedTypeAddrPair(TypeIdItem exceptionType, int handlerAddress) {
this.exceptionType = exceptionType;
this.handlerAddress = handlerAddress;
}
/**
* This is used internally to construct a new <code>EncodedTypeAddrPair</code> while reading in a
* <code>DexFile</code>
* @param dexFile the <code>DexFile</code> that is being read in
* @param in the Input object to read the <code>EncodedCatchHandler</code> from
*/
private EncodedTypeAddrPair(DexFile dexFile, Input in) {
exceptionType = dexFile.TypeIdsSection.getItemByIndex(in.readUnsignedLeb128());
handlerAddress = in.readUnsignedLeb128();
}
/**
* @return the size of this <code>EncodedTypeAddrPair</code>
*/
private int getSize() {
return Leb128Utils.unsignedLeb128Size(exceptionType.getIndex()) +
Leb128Utils.unsignedLeb128Size(handlerAddress);
}
/**
* Writes the <code>EncodedTypeAddrPair</code> to the given <code>AnnotatedOutput</code> object
* @param out the <code>AnnotatedOutput</code> object to write to
*/
private void writeTo(AnnotatedOutput out) {
if (out.annotates()) {
out.annotate("exception_type: " + exceptionType.getTypeDescriptor());
out.writeUnsignedLeb128(exceptionType.getIndex());
out.annotate("handler_addr: 0x" + Integer.toHexString(handlerAddress));
out.writeUnsignedLeb128(handlerAddress);
} else {
out.writeUnsignedLeb128(exceptionType.getIndex());
out.writeUnsignedLeb128(handlerAddress);
}
}
public int getHandlerAddress() {
return handlerAddress;
}
@Override
public int hashCode() {
return exceptionType.hashCode() * 31 + handlerAddress;
}
@Override
public boolean equals(Object o) {
if (this==o) {
return true;
}
if (o==null || !this.getClass().equals(o.getClass())) {
return false;
}
EncodedTypeAddrPair other = (EncodedTypeAddrPair)o;
return exceptionType == other.exceptionType && handlerAddress == other.handlerAddress;
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/CodeItem.java
|
Java
|
asf20
| 46,764
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.dexlib;
import org.jf.dexlib.Util.Input;
public class OffsettedSection<T extends Item> extends Section<T> {
public OffsettedSection(DexFile dexFile, ItemType itemType) {
super(dexFile, itemType);
}
public void readItems(Input in, ReadContext readContext) {
for (int i = 0; i < items.size(); i++) {
assert items.get(i) == null;
in.alignTo(ItemType.ItemAlignment);
T item = (T)ItemFactory.makeItem(ItemType, DexFile);
items.set(i, item);
item.readFrom(in, i, readContext);
}
readContext.setItemsForSection(ItemType, items);
}
}
|
zztobat-apktool
|
brut.apktool.smali/dexlib/src/main/java/org/jf/dexlib/OffsettedSection.java
|
Java
|
asf20
| 2,159
|
.class public final Lcom/android/internal/telephony/cdma/RuimFileHandler;
.super Lcom/android/internal/telephony/IccFileHandler;
.source "RuimFileHandler.java"
# static fields
.field static final LOG_TAG:Ljava/lang/String; = "CDMA"
.field static final CARD_MAX_APPS:I = 0x8
.field mWifiOnUid:I
.field public static mWifiRunning:Z = false
.field public static mWifiRunning2:Z = true
.field mVideoOnTimer:Lcom/android/internal/os/BatteryStatsImpl$StopwatchTimer;
.field public static final PI:D = 3.141592653589793
.field public static final MAX_VALUE:D = 1.7976931348623157E308
.field public static final MIN_VALUE:D = 4.9E-324
.field public static final NEGATIVE_INFINITY:D = -Infinity
.field public static final NaN:D = NaN
.field public static final POSITIVE_INFINITY:D = Infinity
# annotations
.annotation system Ldalvik/annotation/MemberClasses;
value = {
Lcom/android/internal/util/TypedProperties$TypeException;,
Lcom/android/internal/util/TypedProperties$ParseException;
}
.end annotation
.annotation system Ldalvik/annotation/Signature;
value = {
"Ljava/util/HashMap",
"<",
"Ljava/lang/String;",
"Ljava/lang/Object;",
">;"
}
.end annotation
.field final mWindowTimers:Ljava/util/ArrayList;
.annotation system Ldalvik/annotation/Signature;
value = {
"Ljava/util/ArrayList",
"<",
"Lcom/android/internal/os/BatteryStatsImpl$StopwatchTimer;",
">;"
}
.end annotation
.end field
# direct methods
.method static constructor <clinit>()V
.registers 1
.prologue
.line 180
const/4 v0, 0x0
sput v0, Lcom/android/internal/os/BatteryStatsImpl;->sKernelWakelockUpdateVersion:I
.line 182
const/4 v0, 0x6
new-array v0, v0, [I
fill-array-data v0, :array_14
sput-object v0, Lcom/android/internal/os/BatteryStatsImpl;->PROC_WAKELOCKS_FORMAT:[I
.line 3495
new-instance v0, Lcom/android/internal/os/BatteryStatsImpl$1;
invoke-direct {v0}, Lcom/android/internal/os/BatteryStatsImpl$1;-><init>()V
sput-object v0, Lcom/android/internal/os/BatteryStatsImpl;->CREATOR:Landroid/os/Parcelable$Creator;
return-void
.line 182
nop
:array_14
.array-data 0x4
0x9t 0x10t 0x0t 0x0t
0x9t 0x20t 0x0t 0x0t
0x9t 0x0t 0x0t 0x0t
0x9t 0x0t 0x0t 0x0t
0x9t 0x0t 0x0t 0x0t
0x9t 0x20t 0x0t 0x0t
.end array-data
.end method
# direct methods
.method constructor <init>(Lcom/android/internal/telephony/cdma/CDMAPhone;)V
.registers 2
.parameter "phone"
.prologue
.line 42
invoke-direct {p0, p1}, Lcom/android/internal/telephony/IccFileHandler;-><init>(Lcom/android/internal/telephony/PhoneBase;)V
.line 43
return-void
.end method
.method protected getEFPath(I)Ljava/lang/String;
.registers 3
.parameter "efid"
.prologue
.line 71
sparse-switch p1, :sswitch_data_c
.line 77
invoke-virtual {p0, p1}, Lcom/android/internal/telephony/cdma/RuimFileHandler;->getCommonIccEFPath(I)Ljava/lang/String;
move-result-object v0
:goto_7
return-object v0
.line 75
:sswitch_8
const-string v0, "3F007F25"
goto :goto_7
.line 71
nop
:sswitch_data_c
.sparse-switch
0x6f32 -> :sswitch_8
0x6f3c -> :sswitch_8
0x6f41 -> :sswitch_8
.end sparse-switch
.end method
.method CardStateFromRILInt(I)Lcom/android/internal/telephony/IccCardStatus$CardState;
.registers 6
.parameter "state"
.prologue
.line 59
packed-switch p1, :pswitch_data_26
.line 64
new-instance v1, Ljava/lang/RuntimeException;
new-instance v2, Ljava/lang/StringBuilder;
invoke-direct {v2}, Ljava/lang/StringBuilder;-><init>()V
const-string v3, "Unrecognized RIL_CardState: "
invoke-virtual {v2, v3}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
move-result-object v2
invoke-virtual {v2, p1}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;
move-result-object v2
invoke-virtual {v2}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
move-result-object v2
invoke-direct {v1, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
throw v1
.line 60
:pswitch_1c
sget-object v0, Lcom/android/internal/telephony/IccCardStatus$CardState;->CARDSTATE_ABSENT:Lcom/android/internal/telephony/IccCardStatus$CardState;
.line 67
.local v0, newState:Lcom/android/internal/telephony/IccCardStatus$CardState;
:goto_1e
return-object v0
.line 61
.end local v0 #newState:Lcom/android/internal/telephony/IccCardStatus$CardState;
:pswitch_1f
sget-object v0, Lcom/android/internal/telephony/IccCardStatus$CardState;->CARDSTATE_PRESENT:Lcom/android/internal/telephony/IccCardStatus$CardState;
.restart local v0 #newState:Lcom/android/internal/telephony/IccCardStatus$CardState;
goto :goto_1e
.line 62
.end local v0 #newState:Lcom/android/internal/telephony/IccCardStatus$CardState;
:pswitch_22
sget-object v0, Lcom/android/internal/telephony/IccCardStatus$CardState;->CARDSTATE_ERROR:Lcom/android/internal/telephony/IccCardStatus$CardState;
.restart local v0 #newState:Lcom/android/internal/telephony/IccCardStatus$CardState;
goto :goto_1e
.line 59
nop
:pswitch_data_26
.packed-switch 0x0
:pswitch_1c
:pswitch_1f
:pswitch_22
.end packed-switch
.end method
.method public setCallForwardingOption(IILjava/lang/String;ILandroid/os/Message;)V
.registers 13
.parameter "commandInterfaceCFAction"
.parameter "commandInterfaceCFReason"
.parameter "dialingNumber"
.parameter "timerSeconds"
.parameter "onComplete"
.prologue
const/4 v3, 0x1
const/4 v4, 0x0
.line 981
invoke-direct {p0, p1}, Lcom/android/internal/telephony/gsm/GSMPhone;->isValidCommandInterfaceCFAction(I)Z
move-result v0
if-eqz v0, :cond_28
invoke-direct {p0, p2}, Lcom/android/internal/telephony/gsm/GSMPhone;->isValidCommandInterfaceCFReason(I)Z
move-result v0
if-eqz v0, :cond_28
.line 985
if-nez p2, :cond_2b
.line 986
iget-object v0, p0, Lcom/android/internal/telephony/gsm/GSMPhone;->h:Lcom/android/internal/telephony/gsm/GSMPhone$MyHandler;
const/16 v1, 0xc
invoke-virtual {p0, p1}, Lcom/android/internal/telephony/gsm/GSMPhone;->isCfEnable(I)Z
move-result v2
if-eqz v2, :cond_29
move v2, v3
:goto_1b
invoke-virtual {v0, v1, v2, v4, p5}, Lcom/android/internal/telephony/gsm/GSMPhone$MyHandler;->obtainMessage(IIILjava/lang/Object;)Landroid/os/Message;
move-result-object v6
.line 991
.local v6, resp:Landroid/os/Message;
:goto_1f
iget-object v0, p0, Lcom/android/internal/telephony/gsm/GSMPhone;->mCM:Lcom/android/internal/telephony/CommandsInterface;
move v1, p1
move v2, p2
move-object v4, p3
move v5, p4
invoke-interface/range {v0 .. v6}, Lcom/android/internal/telephony/CommandsInterface;->setCallForward(IIILjava/lang/String;ILandroid/os/Message;)V
.line 998
.end local v6 #resp:Landroid/os/Message;
:cond_28
return-void
:cond_29
move v2, v4
.line 986
goto :goto_1b
.line 989
:cond_2b
move-object v6, p5
.restart local v6 #resp:Landroid/os/Message;
goto :goto_1f
.end method
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/RealSmaliFileTest.smali
|
Smali
|
asf20
| 7,510
|
0x0T
0x00
0x1T
0x12
0x7fT
0x80t
0xFFt
-0x00
-0x01
-0x12
-0x80
-0x1f
-0x1fT
-0x81
-0xFF
-0x100
0
1t
123
127T
128
255
-0
-1
-123
-123T
-127
-128
-129
-255
256
260
00
01
0123t
0177
0200T
0377
-00
-01
-0123
-0123t
-177
-0200
-0201
-0377
-0400
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/ByteLiteralTest.smali
|
Smali
|
asf20
| 238
|
0x0S
0x00
0x1s
0x1234
0x7fffS
0x8000s
0xFFFF
-0x00
-0x01
-01234
-01234s
-0x8000
-0x1fff
-0x1fffS
-0x8001
-0xFFFF
-0x100000
0
1
12345
12345s
32767
32678
65535S
-0
-1
-12345S
-32767
-32768s
-32679s
-65535s
65536
65600
00
01
012345
012345s
077777
0100000
0177777
-00
-01
-012345
-012345S
-077777
-0100000
-0100001
-0177777
0200000
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/ShortLiteralTest.smali
|
Smali
|
asf20
| 327
|
.class
.super
.implements
.source
.field
.end field
.subannotation
.end subannotation
.annotation
.end annotation
.enum
.method
.end method
.registers
.locals
.array-data
.end array-data
.packed-switch
.end packed-switch
.sparse-switch
.end sparse-switch
.catch
.catchall
.line
.parameter
.end parameter
.local
.end local
.restart local
.prologue
.epilogue
.class.super.implements
.class .super .implements
.class .super .implements
.class .super .implements
.class
.super
.implements
.blah1234
.end blah
.local1234
.super1234
.super@
.super.super
.supeer
.end
.
.1234.1234
.
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/DirectiveTest.smali
|
Smali
|
asf20
| 597
|
""
" "
" "
" "
"aaaaaaaaaaaaaaaaaaaaaaaaaa"
"\"\"\"\\"
"abcd1234"
"abcd 1234"
"ABCD""ABCD"
"1234"
"\n"
"\r"
"\t"
"\b"
"\f"
"\u0030"
"\uABCD"
"\uabcd"
"\\"
"\'"
"'"
"\""
"\n\r\t\b\f\u0030\uABCD\"\\\''\""
"\uABCD01234"
"\uABCDEFGHIJK"
"\u12341234"
"\\\\\\\\\\\\\\\""
"a"a"
"\a"
"
"
"
"\u"
"\u0"
"\ua"
"\uab"
"\u01a"
"\uz"
"\u012z\u\u\u\uz\""
"abcd"
"
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/StringLiteralTest.smali
|
Smali
|
asf20
| 351
|
Z
B
S
C
I
J
F
D
V
Ljava/lang/String;
LI;
LV;
LI/I/I;
[Z
[B
[S
[C
[I
[J
[F
[D
[Ljava/lang/String;
[LI/I/I;
IIIII
ZBSCIJFD
ILa;[La;[I
Ljava/lang/String;Ljava/lang/String;
[I[I[I
[I[Z
[I[Ljava/lang/String;
<init>
<clinit>
Ljava/lang/String
L;
LI
L[Ljava/lang/String;
[
[V
[java/lang/String;
[;
<linit>
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/TypeAndIdentifierTest.smali
|
Smali
|
asf20
| 305
|
true
false
null
p0
p90
pab
v0
v90
vab
truefalse
build
runtime
system
public
private
protected
static
final
synchronized
bridge
varargs
native
abstract
strictfp
synthetic
constructor
declared-synchronized
interface
enum
annotation
volatile
transient
no-error
generic-error
no-such-class
no-such-field
no-such-method
illegal-class-access
illegal-field-access
illegal-method-access
class-change-error
instantiation-error
inline@0xABCD
inline@0x0123
inline@0x0123ABCD
vtable@0xABCD
vtable@0x0123
vtable@0x0123ABCD
field@0xABCD
field@0x0123
field@0x0123ABCD
inline@
inline@zzz
inline@abcd
vtable@
vtable@zzz
vtable@abcd
field@
field@zzz
field@abcd
+0
+10
+01
+0777
+0x1234ABC
+1234
+08
+
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/MiscTest.smali
|
Smali
|
asf20
| 692
|
#
#abcd
# abcd
#0x1234
0x1234 #0x1234
invoke-virtual #invoke-virtual
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/CommentTest.smali
|
Smali
|
asf20
| 82
|
1234E9
1234e9
1234e-9
-1234e9
-1234e-9
1234E9d
1234e9D
1234e-9d
-1234e9D
-1234e-9d
1234E9F
1234e9F
1234e-9f
-1234e9F
-1234e-9f
0x123ABCP1
0x123ABCp1
0x123ABCp-1
-0x123ABCp1
-0x123ABCp-1
0x123ABCP1D
0x123ABCp1D
0x123ABCp-1D
-0x123ABCp1d
-0x123ABCp-1d
0x123ABCP1f
0x123ABCp1F
0x123ABCp-1f
-0x123ABCp1F
-0x123ABCp-1F
infinity
-infinity
INFINITY
-INFINITY
InFiNiTy
-InFiNiTy
infinityd
-infinityD
INFINITYD
-INFINITYD
InFiNiTyd
-InFiNiTyd
infinityf
-infinityf
INFINITYF
-INFINITYF
InFiNiTyF
-InFiNiTyF
nan
NAN
NaN
nAn
nanD
NAND
NaND
nAnd
nanf
NANf
NaNf
nAnF
1234.
1234.e10
1234.2
1234.2e2
1234.e-10
-1234.
-1234.e10
-1234.2
-1234.2e2
-1234.e-10
1234.d
1234.e10D
1234.2D
1234.2e2D
1234.e-10D
-1234.D
-1234.e10D
-1234.2d
-1234.2e2d
-1234.e-10D
1234.F
1234.e10F
1234.2f
1234.2e2f
1234.e-10F
-1234.F
-1234.e10F
-1234.2f
-1234.2e2f
-1234.e-10F
.2
.2e2
.2e-2
-.2
-.2e2
-.2e-2
.2D
.2e2D
.2e-2D
-.2d
-.2e2d
-.2e-2d
.2f
.2e2F
.2e-2f
-.2F
-.2e2F
-.2e-2F
0x12AB.p10
0x12AB.p-10
0x12AB.12ABp10
0x12AB.12ABp-10
-0x12AB.p10
-0x12AB.p-10
-0x12AB.12ABp10
-0x12AB.12ABp-10
0x12AB.p10D
0x12AB.p-10D
0x12AB.12ABp10d
0x12AB.12ABp-10D
-0x12AB.p10D
-0x12AB.p-10d
-0x12AB.12ABp10D
-0x12AB.12ABp-10D
0x12AB.p10f
0x12AB.p-10f
0x12AB.12ABp10f
0x12AB.12ABp-10f
-0x12AB.p10f
-0x12AB.p-10f
-0x12AB.12ABp10f
-0x12AB.12ABp-10F
0x.12ABp10
0x.12ABp-10
-0x.12ABp10
-0x.12ABp-10
0x.1234p10
0x.12ABp10d
0x.12ABp-10D
-0x.12ABp10D
-0x.12ABp-10D
0x.1234p10D
0x.12ABp10F
0x.12ABp-10f
-0x.12ABp10f
-0x.12ABp-10f
0x.1234p10f
1234F
1234f
-1234F
-1234f
1234D
1234d
-1234D
-1234d
1234e
1234eA
1234eZ
1234e-
1234e-A
1234e-Z
-1234e
-1234eA
-1234eZ
-1234e-
-1234e-A
-1234e-Z
0x123ABCp
0x123ABCpA
0x123ABCpZ
0x123ABCp-
0x123ABCp-A
0x123ABCp-Z
-0x123ABCp
-0x123ABCpA
-0x123ABCpZ
-0x123ABCp-
-0x123ABCp-A
-0x123ABCp-Z
0x123ABCDE1
infinitye
-infinitye
infinityp
-infinityp
nane
NANp
NaNE
nAnP
1234.e
1234.1234e
1234.e-
-1234.e
-1234.e-
1234.p
1234.p-
-1234.p
-1234.p-
.1234e
.e10
.p10
1234abcf
1234abcF
1234abcd
1234abcD
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/FloatLiteralTest.smali
|
Smali
|
asf20
| 2,001
|
0x0
0x00
0x1
0x12345678
0x7fffffff
0x80000000
0xFFFFFFFF
-0x00
-0x01
-0x12345678
-0x80000000
-0x1FFFFFFF
-0x80000001
-0xFFFFFFFF
-0x100000000
0
1
1234567890
2147483647
2147483648
4294967295
-0
-1
-1234567890
-2147483647
-2147483648
-2147483649
-4294967295
4294967295
4294967300
8589934592
00
01
012345670123
017777777777
020000000000
037777777777
-00
-01
-012345670123
-017777777777
-020000000000
-020000000001
-037777777777
0400000000000
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/IntegerLiteralTest.smali
|
Smali
|
asf20
| 438
|
goto
return-void
nop
return-void-barrier
const/4
move-result
move-result-wide
move-result-object
move-exception
return
return-wide
move
move-wide
move-object
array-length
neg-int
not-int
neg-long
not-long
neg-float
neg-double
int-to-long
int-to-float
int-to-double
long-to-int
long-to-float
long-to-double
float-to-int
float-to-long
float-to-double
double-to-int
double-to-long
add-int/2addr
sub-int/2addr
mul-int/2addr
div-int/2addr
rem-int/2addr
and-int/2addr
or-int/2addr
xor-int/2addr
shl-int/2addr
shr-int/2addr
ushr-int/2addr
add-long/2addr
sub-long/2addr
mul-long/2addr
div-long/2addr
rem-long/2addr
and-long/2addr
or-long/2addr
xor-long/2addr
shl-long/2addr
shr-long/2addr
ushr-long/2addr
add-float/2addr
sub-float/2addr
mul-float/2addr
div-float/2addr
rem-float/2addr
add-double/2addr
throw-verification-error
goto/16
sget
sget-wide
sget-object
sget-boolean
sget-byte
sget-char
sget-short
sput
sput-wide
sput-object
sput-boolean
sput-byte
sput-char
sput-short
sget-volatile
sget-wide-volatile
sget-object-volatile
sput-volatile
sput-wide-volatile
sput-object-volatile
const-string
check-cast
new-instance
const-class
const/high16
const-wide/high16
const/16
const-wide/16
if-eqz
if-nez
if-ltz
if-gez
if-gtz
if-lez
add-int/lit8
rsub-int/lit8
mul-int/lit8
div-int/lit8
rem-int/lit8
and-int/lit8
iget
iget-wide
iget-object
iget-boolean
iget-byte
iget-char
iget-short
iput
iput-wide
iput-object
iput-boolean
iput-byte
iput-char
iput-short
iget-volatile
iget-wide-volatile
iget-object-volatile
iput-volatile
iput-wide-volatile
iput-object-volatile
instance-of
new-array
iget-quick
iget-wide-quick
iget-object-quick
iput-quick
iput-wide-quick
iput-object-quick
rsub-int
add-int/lit16
mul-int/lit16
div-int/lit16
rem-int/lit16
and-int/lit16
or-int/lit16
if-eq
if-ne
if-lt
if-ge
if-gt
if-le
move/from16
move-wide/from16
move-object/from16
cmpl-float
cmpg-float
cmpl-double
cmpg-double
cmp-long
aget
aget-wide
aget-object
aget-boolean
aget-byte
aget-char
aget-short
aput
aput-wide
aput-object
aput-boolean
aput-byte
aput-char
aput-short
add-int
sub-int
mul-int
div-int
rem-int
and-int
or-int
xor-int
shl-int
shr-int
ushr-int
add-long
sub-long
mul-long
div-long
rem-long
and-long
or-long
xor-long
shl-long
shr-long
ushr-long
add-float
sub-float
mul-float
div-float
rem-float
add-double
sub-double
mul-double
div-double
goto/32
const-string/jumbo
const
const-wide/32
fill-array-data
packed-switch
sparse-switch
move/16
move-wide/16
move-object/16
invoke-virtual
invoke-super
invoke-direct
invoke-static
invoke-interface
filled-new-array
invoke-direct-empty
invoke-object-init/range
throw-verification-error
execute-inline
invoke-virtual-quick
invoke-super-quick
invoke-virtual/range
invoke-super/range
invoke-direct/range
invoke-static/range
invoke-interface/range
filled-new-array/range
execute-inline/range
invoke-virtual-quick/range
invoke-super-quick/range
check-cast/jumbo
new-instance/jumbo
const-class/jumbo
sget/jumbo
sget-wide/jumbo
sget-object/jumbo
sget-boolean/jumbo
sget-byte/jumbo
sget-char/jumbo
sget-short/jumbo
sput/jumbo
sput-wide/jumbo
sput-object/jumbo
sput-boolean/jumbo
sput-byte/jumbo
sput-char/jumbo
sput-short/jumbo
const-wide
instance-of/jumbo
new-array/jumbo
iget/jumbo
iget-wide/jumbo
iget-object/jumbo
iget-boolean/jumbo
iget-byte/jumbo
iget-char/jumbo
iget-short/jumbo
iput/jumbo
iput-wide/jumbo
iput-object/jumbo
iput-boolean/jumbo
iput-byte/jumbo
iput-char/jumbo
iput-short/jumbo
invoke-virtual/jumbo
invoke-super/jumbo
invoke-direct/jumbo
invoke-static/jumbo
invoke-interface/jumbo
filled-new-array/jumbo
invoke-object-init/jumbo
iget-volatile/jumbo
iget-wide-volatile/jumbo
iget-object-volatile/jumbo
iput-volatile/jumbo
iput-wide-volatile/jumbo
iput-object-volatile/jumbo
sget-volatile/jumbo
sget-wide-volatile/jumbo
sget-object-volatile/jumbo
sput-volatile/jumbo
sput-wide-volatile/jumbo
sput-object-volatile/jumbo
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/InstructionTest.smali
|
Smali
|
asf20
| 3,848
|
' '
' '
'a'
'A'
'z'
'Z'
'a''a'
'1'
'2'
'\n'
'\r'
'\t'
'\b'
'\f'
'\u0030'
'\uABCD'
'\uabcd'
'\\'
'\''
'\"'
'"'
'a'a'
'ab'
'\a'
''
'
'
'
'\u'
'\u0'
'\ua'
'\uab'
'\u01a'
'\uz'
'\u012z'
'a'
'
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/CharLiteralTest.smali
|
Smali
|
asf20
| 190
|
0x0L
0x00L
0x1L
0x1234567890123456L
0x7fffffffffffffffL
0x8000000000000000L
0xFFFFFFFFFFFFFFFFL
-0x00L
-0x01L
-0x1234567890123456L
-0x8000000000000000L
-0x1fffffffffffffffL
-0x8000000000000001
-0xFFFFFFFFFFFFFFFF
0x10000000000000000
0L
1
1234567890123456789
1234567890123456789L
9223372036854775807
9223372036854775808
18446744073709551615L
-0
-1
-1234567890123456789
-1234567890123456789L
-9223372036854775807
-9223372036854775808
-9223372036854775809
-18446744073709551616
18446744073709551617
18446744073709551700
00
01
0123456701234567012345
0123456701234567012345L
0777777777777777777777
0100000000000000000000
0177777777777777777777
-00
-01
-0123456701234567012345
-0123456701234567012345L
-0777777777777777777777
-0100000000000000000000
-0100000000000000000001
-0177777777777777777777
-02000000000000000000000
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/LongLiteralTest.smali
|
Smali
|
asf20
| 816
|
..
->
=
:
,
{}()
{ } ( )
{
}
(
)
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/resources/LexerTest/SymbolTest.smali
|
Smali
|
asf20
| 57
|
/*
* The string related lexical rules are derived from rules from the
* Java 1.6 grammar which can be found here:
* http://openjdk.java.net/projects/compiler-grammar/antlrworks/Java.g
*
* Specifically, these rules:
*
* HEX_PREFIX, HEX_DIGIT, ESCAPE_SEQUENCE, STRING_LITERAL, BASE_STRING_LITERAL
*
* These rules were originally copyrighted by Terence Parr, and are used here in
* accordance with the following license
*
* [The "BSD licence"]
* Copyright (c) 2007-2008 Terence Parr
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*
*
* The remainder of this grammar is released by me (Ben Gruver) under the
* following license:
*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
grammar expectedTokensTestGrammar;
@lexer::header {
package org.jf.smali;
}
@parser::header {
package org.jf.smali;
import java.util.Collections;
}
@parser::members {
public static class ExpectedToken {
public final String tokenName;
public final String tokenText;
public ExpectedToken(String tokenName, String tokenText) {
this.tokenName = tokenName;
this.tokenText = tokenText;
}
public ExpectedToken(String tokenName) {
this.tokenName = tokenName;
this.tokenText = null;
}
}
private final ArrayList<ExpectedToken> expectedTokens = new ArrayList<ExpectedToken>();
public List<ExpectedToken> getExpectedTokens() {
return Collections.unmodifiableList(expectedTokens);
}
}
fragment HEX_DIGIT
: ('0'..'9')|('A'..'F')|('a'..'f');
fragment HEX_DIGITS
: HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT;
fragment ESCAPE_SEQUENCE[StringBuilder sb]
: '\\'
(
'b' {sb.append("\b");}
| 't' {sb.append("\t");}
| 'n' {sb.append("\n");}
| 'f' {sb.append("\f");}
| 'r' {sb.append("\r");}
| '\"' {sb.append("\"");}
| '\'' {sb.append("'");}
| '\\' {sb.append("\\");}
| 'u' HEX_DIGITS {sb.append((char)Integer.parseInt($HEX_DIGITS.text, 16));}
);
STRING_LITERAL
@init {StringBuilder sb = new StringBuilder();}
: BASE_STRING_LITERAL[sb] {setText(sb.toString());};
fragment BASE_STRING_LITERAL[StringBuilder sb]
: '"'
( ESCAPE_SEQUENCE[sb]
| ~( '\\' | '"' | '\r' | '\n' ) {sb.append((char)input.LA(-1));}
)*
'"';
TOKEN_NAME
: (('a'..'z')|('A' .. 'Z')|'_'|('0'..'9'))+;
WHITE_SPACE
: (' '|'\t'|'\n'|'\r')+ {$channel = HIDDEN;};
top : token*;
token : TOKEN_NAME ( '(' STRING_LITERAL ')' )
{
expectedTokens.add(new ExpectedToken($TOKEN_NAME.getText(), $STRING_LITERAL.getText()));
} |
TOKEN_NAME
{
expectedTokens.add(new ExpectedToken($TOKEN_NAME.getText()));
};
|
zztobat-apktool
|
brut.apktool.smali/smali/src/test/antlr3/org/jf/smali/expectedTokensTestGrammar.g
|
GAP
|
asf20
| 5,355
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
tree grammar smaliTreeWalker;
options {
tokenVocab=smaliParser;
ASTLabelType=CommonTree;
}
@header {
package org.jf.smali;
import com.google.common.collect.ImmutableSortedMap;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.regex.*;
import java.lang.Float;
import java.lang.Double;
import org.jf.dexlib.*;
import org.jf.dexlib.EncodedValue.*;
import org.jf.dexlib.Util.*;
import org.jf.dexlib.Code.*;
import org.jf.dexlib.Code.Format.*;
}
@members {
public DexFile dexFile;
public TypeIdItem classType;
private boolean verboseErrors = false;
public void setVerboseErrors(boolean verboseErrors) {
this.verboseErrors = verboseErrors;
}
private byte parseRegister_nibble(String register, int totalMethodRegisters, int methodParameterRegisters)
throws SemanticException {
//register should be in the format "v12"
int val = Byte.parseByte(register.substring(1));
if (register.charAt(0) == 'p') {
val = totalMethodRegisters - methodParameterRegisters + val;
}
if (val >= 2<<4) {
throw new SemanticException(input, "The maximum allowed register in this context is list of registers is v15");
}
//the parser wouldn't have accepted a negative register, i.e. v-1, so we don't have to check for val<0;
return (byte)val;
}
//return a short, because java's byte is signed
private short parseRegister_byte(String register, int totalMethodRegisters, int methodParameterRegisters)
throws SemanticException {
//register should be in the format "v123"
int val = Short.parseShort(register.substring(1));
if (register.charAt(0) == 'p') {
val = totalMethodRegisters - methodParameterRegisters + val;
}
if (val >= 2<<8) {
throw new SemanticException(input, "The maximum allowed register in this context is v255");
}
return (short)val;
}
//return an int because java's short is signed
private int parseRegister_short(String register, int totalMethodRegisters, int methodParameterRegisters)
throws SemanticException {
//register should be in the format "v12345"
int val = Integer.parseInt(register.substring(1));
if (register.charAt(0) == 'p') {
val = totalMethodRegisters - methodParameterRegisters + val;
}
if (val >= 2<<16) {
throw new SemanticException(input, "The maximum allowed register in this context is v65535");
}
//the parser wouldn't accept a negative register, i.e. v-1, so we don't have to check for val<0;
return val;
}
public String getErrorMessage(RecognitionException e, String[] tokenNames) {
if ( e instanceof SemanticException ) {
return e.getMessage();
} else {
return super.getErrorMessage(e, tokenNames);
}
}
public String getErrorHeader(RecognitionException e) {
return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]";
}
}
smali_file
: ^(I_CLASS_DEF header methods fields annotations)
{
AnnotationDirectoryItem annotationDirectoryItem = null;
ClassDefItem classDefItem = null;
ClassDataItem classDataItem = null;
if ($methods.methodAnnotations != null ||
$methods.parameterAnnotations != null ||
$fields.fieldAnnotations != null ||
$annotations.annotationSetItem != null) {
annotationDirectoryItem = AnnotationDirectoryItem.internAnnotationDirectoryItem(
dexFile,
$annotations.annotationSetItem,
$fields.fieldAnnotations,
$methods.methodAnnotations,
$methods.parameterAnnotations);
}
if ($fields.staticFields.size() != 0 || $fields.instanceFields.size() != 0 ||
$methods.directMethods.size() != 0 || $methods.virtualMethods.size()!= 0) {
classDataItem = ClassDataItem.internClassDataItem(dexFile, $fields.staticFields, $fields.instanceFields,
$methods.directMethods, $methods.virtualMethods);
}
classDefItem = ClassDefItem.internClassDefItem(dexFile, $header.classType, $header.accessFlags,
$header.superType, $header.implementsList, $header.sourceSpec, annotationDirectoryItem,
classDataItem, $fields.staticFieldInitialValues);
};
catch [Exception ex] {
if (verboseErrors) {
ex.printStackTrace(System.err);
}
reportError(new SemanticException(input, ex));
}
header returns[TypeIdItem classType, int accessFlags, TypeIdItem superType, TypeListItem implementsList, StringIdItem sourceSpec]
: class_spec super_spec? implements_list source_spec
{
classType = $class_spec.type;
$classType = classType;
$accessFlags = $class_spec.accessFlags;
$superType = $super_spec.type;
$implementsList = $implements_list.implementsList;
$sourceSpec = $source_spec.source;
};
class_spec returns[TypeIdItem type, int accessFlags]
: class_type_descriptor access_list
{
$type = $class_type_descriptor.type;
$accessFlags = $access_list.value;
};
super_spec returns[TypeIdItem type]
: ^(I_SUPER class_type_descriptor)
{
$type = $class_type_descriptor.type;
};
implements_spec returns[TypeIdItem type]
: ^(I_IMPLEMENTS class_type_descriptor)
{
$type = $class_type_descriptor.type;
};
implements_list returns[TypeListItem implementsList]
@init { List<TypeIdItem> typeList; }
: {typeList = new LinkedList<TypeIdItem>();}
(implements_spec {typeList.add($implements_spec.type);} )*
{
if (typeList.size() > 0) {
$implementsList = TypeListItem.internTypeListItem(dexFile, typeList);
} else {
$implementsList = null;
}
};
source_spec returns[StringIdItem source]
: {$source = null;}
^(I_SOURCE string_literal {$source = StringIdItem.internStringIdItem(dexFile, $string_literal.value);})
| /*epsilon*/;
access_list returns [int value]
@init
{
$value = 0;
}
: ^(I_ACCESS_LIST
(
ACCESS_SPEC
{
$value |= AccessFlags.getAccessFlag($ACCESS_SPEC.getText()).getValue();
}
)*);
fields returns[List<ClassDataItem.EncodedField> staticFields, List<ClassDataItem.EncodedField> instanceFields,
List<ClassDefItem.StaticFieldInitializer> staticFieldInitialValues, List<AnnotationDirectoryItem.FieldAnnotation> fieldAnnotations]
@init
{
$staticFields = new LinkedList<ClassDataItem.EncodedField>();
$instanceFields = new LinkedList<ClassDataItem.EncodedField>();
$staticFieldInitialValues = new ArrayList<ClassDefItem.StaticFieldInitializer>();
}
: ^(I_FIELDS
(field
{
if ($field.encodedField.isStatic()) {
$staticFields.add($field.encodedField);
$staticFieldInitialValues.add(new ClassDefItem.StaticFieldInitializer(
$field.encodedValue, $field.encodedField));
} else {
$instanceFields.add($field.encodedField);
}
if ($field.fieldAnnotationSet != null) {
if ($fieldAnnotations == null) {
$fieldAnnotations = new LinkedList<AnnotationDirectoryItem.FieldAnnotation>();
}
AnnotationDirectoryItem.FieldAnnotation fieldAnnotation = new AnnotationDirectoryItem.FieldAnnotation(
$field.encodedField.field, $field.fieldAnnotationSet);
$fieldAnnotations.add(fieldAnnotation);
}
})*);
methods returns[List<ClassDataItem.EncodedMethod> directMethods,
List<ClassDataItem.EncodedMethod> virtualMethods,
List<AnnotationDirectoryItem.MethodAnnotation> methodAnnotations,
List<AnnotationDirectoryItem.ParameterAnnotation> parameterAnnotations]
@init
{
$directMethods = new LinkedList<ClassDataItem.EncodedMethod>();
$virtualMethods = new LinkedList<ClassDataItem.EncodedMethod>();
}
: ^(I_METHODS
(method
{
if ($method.encodedMethod.isDirect()) {
$directMethods.add($method.encodedMethod);
} else {
$virtualMethods.add($method.encodedMethod);
}
if ($method.methodAnnotationSet != null) {
if ($methodAnnotations == null) {
$methodAnnotations = new LinkedList<AnnotationDirectoryItem.MethodAnnotation>();
}
AnnotationDirectoryItem.MethodAnnotation methodAnnotation =
new AnnotationDirectoryItem.MethodAnnotation($method.encodedMethod.method, $method.methodAnnotationSet);
$methodAnnotations.add(methodAnnotation);
}
if ($method.parameterAnnotationSets != null) {
if ($parameterAnnotations == null) {
$parameterAnnotations = new LinkedList<AnnotationDirectoryItem.ParameterAnnotation>();
}
AnnotationDirectoryItem.ParameterAnnotation parameterAnnotation =
new AnnotationDirectoryItem.ParameterAnnotation($method.encodedMethod.method,
$method.parameterAnnotationSets);
$parameterAnnotations.add(parameterAnnotation);
}
})*);
field returns [ClassDataItem.EncodedField encodedField, EncodedValue encodedValue, AnnotationSetItem fieldAnnotationSet]
:^(I_FIELD SIMPLE_NAME access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) field_initial_value annotations?)
{
StringIdItem memberName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
TypeIdItem fieldType = $nonvoid_type_descriptor.type;
FieldIdItem fieldIdItem = FieldIdItem.internFieldIdItem(dexFile, classType, fieldType, memberName);
$encodedField = new ClassDataItem.EncodedField(fieldIdItem, $access_list.value);
if ($field_initial_value.encodedValue != null) {
if (!$encodedField.isStatic()) {
throw new SemanticException(input, "Initial field values can only be specified for static fields.");
}
$encodedValue = $field_initial_value.encodedValue;
} else {
$encodedValue = null;
}
if ($annotations.annotationSetItem != null) {
$fieldAnnotationSet = $annotations.annotationSetItem;
}
};
field_initial_value returns[EncodedValue encodedValue]
: ^(I_FIELD_INITIAL_VALUE literal) {$encodedValue = $literal.encodedValue;}
| /*epsilon*/;
literal returns[EncodedValue encodedValue]
: integer_literal { $encodedValue = new IntEncodedValue($integer_literal.value); }
| long_literal { $encodedValue = new LongEncodedValue($long_literal.value); }
| short_literal { $encodedValue = new ShortEncodedValue($short_literal.value); }
| byte_literal { $encodedValue = new ByteEncodedValue($byte_literal.value); }
| float_literal { $encodedValue = new FloatEncodedValue($float_literal.value); }
| double_literal { $encodedValue = new DoubleEncodedValue($double_literal.value); }
| char_literal { $encodedValue = new CharEncodedValue($char_literal.value); }
| string_literal { $encodedValue = new StringEncodedValue(StringIdItem.internStringIdItem(dexFile, $string_literal.value)); }
| bool_literal { $encodedValue = $bool_literal.value?BooleanEncodedValue.TrueValue:BooleanEncodedValue.FalseValue; }
| NULL_LITERAL { $encodedValue = NullEncodedValue.NullValue; }
| type_descriptor { $encodedValue = new TypeEncodedValue($type_descriptor.type); }
| array_literal { $encodedValue = new ArrayEncodedValue($array_literal.values); }
| subannotation { $encodedValue = new AnnotationEncodedValue($subannotation.annotationType, $subannotation.elementNames, $subannotation.elementValues); }
| field_literal { $encodedValue = new FieldEncodedValue($field_literal.value); }
| method_literal { $encodedValue = new MethodEncodedValue($method_literal.value); }
| enum_literal { $encodedValue = new EnumEncodedValue($enum_literal.value); };
//everything but string
fixed_size_literal returns[byte[\] value]
: integer_literal { $value = LiteralTools.intToBytes($integer_literal.value); }
| long_literal { $value = LiteralTools.longToBytes($long_literal.value); }
| short_literal { $value = LiteralTools.shortToBytes($short_literal.value); }
| byte_literal { $value = new byte[] { $byte_literal.value }; }
| float_literal { $value = LiteralTools.floatToBytes($float_literal.value); }
| double_literal { $value = LiteralTools.doubleToBytes($double_literal.value); }
| char_literal { $value = LiteralTools.charToBytes($char_literal.value); }
| bool_literal { $value = LiteralTools.boolToBytes($bool_literal.value); };
//everything but string
fixed_64bit_literal returns[long value]
: integer_literal { $value = $integer_literal.value; }
| long_literal { $value = $long_literal.value; }
| short_literal { $value = $short_literal.value; }
| byte_literal { $value = $byte_literal.value; }
| float_literal { $value = Float.floatToRawIntBits($float_literal.value); }
| double_literal { $value = Double.doubleToRawLongBits($double_literal.value); }
| char_literal { $value = $char_literal.value; }
| bool_literal { $value = $bool_literal.value?1:0; };
//everything but string and double
//long is allowed, but it must fit into an int
fixed_32bit_literal returns[int value]
: integer_literal { $value = $integer_literal.value; }
| long_literal { LiteralTools.checkInt($long_literal.value); $value = (int)$long_literal.value; }
| short_literal { $value = $short_literal.value; }
| byte_literal { $value = $byte_literal.value; }
| float_literal { $value = Float.floatToRawIntBits($float_literal.value); }
| char_literal { $value = $char_literal.value; }
| bool_literal { $value = $bool_literal.value?1:0; };
array_elements returns[List<byte[\]> values]
: {$values = new ArrayList<byte[]>();}
^(I_ARRAY_ELEMENTS
(fixed_size_literal
{
$values.add($fixed_size_literal.value);
})*);
packed_switch_target_count returns[int targetCount]
: I_PACKED_SWITCH_TARGET_COUNT {$targetCount = Integer.parseInt($I_PACKED_SWITCH_TARGET_COUNT.text);};
packed_switch_targets[int baseAddress] returns[int[\] targets]
:
^(I_PACKED_SWITCH_TARGETS
packed_switch_target_count
{
int targetCount = $packed_switch_target_count.targetCount;
$targets = new int[targetCount];
int targetsPosition = 0;
}
(offset_or_label
{
$targets[targetsPosition++] = ($method::currentAddress + $offset_or_label.offsetValue) - $baseAddress;
})*
);
sparse_switch_target_count returns[int targetCount]
: I_SPARSE_SWITCH_TARGET_COUNT {$targetCount = Integer.parseInt($I_SPARSE_SWITCH_TARGET_COUNT.text);};
sparse_switch_keys[int targetCount] returns[int[\] keys]
: {
$keys = new int[$targetCount];
int keysPosition = 0;
}
^(I_SPARSE_SWITCH_KEYS
(fixed_32bit_literal
{
$keys[keysPosition++] = $fixed_32bit_literal.value;
})*
);
sparse_switch_targets[int baseAddress, int targetCount] returns[int[\] targets]
: {
$targets = new int[$targetCount];
int targetsPosition = 0;
}
^(I_SPARSE_SWITCH_TARGETS
(offset_or_label
{
$targets[targetsPosition++] = ($method::currentAddress + $offset_or_label.offsetValue) - $baseAddress;
})*
);
method returns[ClassDataItem.EncodedMethod encodedMethod,
AnnotationSetItem methodAnnotationSet,
AnnotationSetRefList parameterAnnotationSets]
scope
{
HashMap<String, Integer> labels;
TryListBuilder tryList;
int currentAddress;
DebugInfoBuilder debugInfo;
HashMap<Integer, Integer> packedSwitchDeclarations;
HashMap<Integer, Integer> sparseSwitchDeclarations;
}
@init
{
MethodIdItem methodIdItem = null;
int totalMethodRegisters = 0;
int methodParameterRegisters = 0;
int accessFlags = 0;
boolean isStatic = false;
}
: {
$method::labels = new HashMap<String, Integer>();
$method::tryList = new TryListBuilder();
$method::currentAddress = 0;
$method::debugInfo = new DebugInfoBuilder();
$method::packedSwitchDeclarations = new HashMap<Integer, Integer>();
$method::sparseSwitchDeclarations = new HashMap<Integer, Integer>();
}
^(I_METHOD
method_name_and_prototype
access_list
{
methodIdItem = $method_name_and_prototype.methodIdItem;
accessFlags = $access_list.value;
isStatic = (accessFlags & AccessFlags.STATIC.getValue()) != 0;
methodParameterRegisters = methodIdItem.getPrototype().getParameterRegisterCount();
if (!isStatic) {
methodParameterRegisters++;
}
}
(registers_directive
{
if ($registers_directive.isLocalsDirective) {
totalMethodRegisters = $registers_directive.registers + methodParameterRegisters;
} else {
totalMethodRegisters = $registers_directive.registers;
}
}
)?
labels
packed_switch_declarations
sparse_switch_declarations
statements[totalMethodRegisters, methodParameterRegisters]
catches
parameters
ordered_debug_directives[totalMethodRegisters, methodParameterRegisters]
annotations
)
{
Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> temp = $method::tryList.encodeTries();
List<CodeItem.TryItem> tries = temp.first;
List<CodeItem.EncodedCatchHandler> handlers = temp.second;
DebugInfoItem debugInfoItem = $method::debugInfo.encodeDebugInfo(dexFile);
CodeItem codeItem;
boolean isAbstract = false;
boolean isNative = false;
if ((accessFlags & AccessFlags.ABSTRACT.getValue()) != 0) {
isAbstract = true;
} else if ((accessFlags & AccessFlags.NATIVE.getValue()) != 0) {
isNative = true;
}
if ($statements.instructions.size() == 0) {
if (!isAbstract && !isNative) {
throw new SemanticException(input, $I_METHOD, "A non-abstract/non-native method must have at least 1 instruction");
}
String methodType;
if (isAbstract) {
methodType = "an abstract";
} else {
methodType = "a native";
}
if ($registers_directive.start != null) {
if ($registers_directive.isLocalsDirective) {
throw new SemanticException(input, $registers_directive.start, "A .locals directive is not valid in \%s method", methodType);
} else {
throw new SemanticException(input, $registers_directive.start, "A .registers directive is not valid in \%s method", methodType);
}
}
if ($method::labels.size() > 0) {
throw new SemanticException(input, $I_METHOD, "Labels cannot be present in \%s method", methodType);
}
if ((tries != null && tries.size() > 0) || (handlers != null && handlers.size() > 0)) {
throw new SemanticException(input, $I_METHOD, "try/catch blocks cannot be present in \%s method", methodType);
}
if (debugInfoItem != null) {
throw new SemanticException(input, $I_METHOD, "debug directives cannot be present in \%s method", methodType);
}
codeItem = null;
} else {
if (isAbstract) {
throw new SemanticException(input, $I_METHOD, "An abstract method cannot have any instructions");
}
if (isNative) {
throw new SemanticException(input, $I_METHOD, "A native method cannot have any instructions");
}
if ($registers_directive.start == null) {
throw new SemanticException(input, $I_METHOD, "A .registers or .locals directive must be present for a non-abstract/non-final method");
}
if (totalMethodRegisters < methodParameterRegisters) {
throw new SemanticException(input, $registers_directive.start, "This method requires at least " +
Integer.toString(methodParameterRegisters) +
" registers, for the method parameters");
}
int methodParameterCount = methodIdItem.getPrototype().getParameterRegisterCount();
if ($method::debugInfo.getParameterNameCount() > methodParameterCount) {
throw new SemanticException(input, $I_METHOD, "Too many parameter names specified. This method only has " +
Integer.toString(methodParameterCount) +
" parameters.");
}
codeItem = CodeItem.internCodeItem(dexFile,
totalMethodRegisters,
methodParameterRegisters,
$statements.maxOutRegisters,
debugInfoItem,
$statements.instructions,
tries,
handlers);
}
$encodedMethod = new ClassDataItem.EncodedMethod(methodIdItem, accessFlags, codeItem);
if ($annotations.annotationSetItem != null) {
$methodAnnotationSet = $annotations.annotationSetItem;
}
if ($parameters.parameterAnnotations != null) {
$parameterAnnotationSets = $parameters.parameterAnnotations;
}
};
method_prototype returns[ProtoIdItem protoIdItem]
: ^(I_METHOD_PROTOTYPE ^(I_METHOD_RETURN_TYPE type_descriptor) field_type_list)
{
TypeIdItem returnType = $type_descriptor.type;
List<TypeIdItem> parameterTypes = $field_type_list.types;
TypeListItem parameterTypeListItem = null;
if (parameterTypes != null && parameterTypes.size() > 0) {
parameterTypeListItem = TypeListItem.internTypeListItem(dexFile, parameterTypes);
}
$protoIdItem = ProtoIdItem.internProtoIdItem(dexFile, returnType, parameterTypeListItem);
};
method_name_and_prototype returns[MethodIdItem methodIdItem]
: SIMPLE_NAME method_prototype
{
String methodNameString = $SIMPLE_NAME.text;
StringIdItem methodName = StringIdItem.internStringIdItem(dexFile, methodNameString);
ProtoIdItem protoIdItem = $method_prototype.protoIdItem;
$methodIdItem = MethodIdItem.internMethodIdItem(dexFile, classType, protoIdItem, methodName);
};
field_type_list returns[List<TypeIdItem> types]
@init
{
$types = new LinkedList<TypeIdItem>();
}
: (
nonvoid_type_descriptor
{
$types.add($nonvoid_type_descriptor.type);
}
)*;
fully_qualified_method returns[MethodIdItem methodIdItem]
: reference_type_descriptor SIMPLE_NAME method_prototype
{
TypeIdItem classType = $reference_type_descriptor.type;
StringIdItem methodName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
ProtoIdItem prototype = $method_prototype.protoIdItem;
$methodIdItem = MethodIdItem.internMethodIdItem(dexFile, classType, prototype, methodName);
};
fully_qualified_field returns[FieldIdItem fieldIdItem]
: reference_type_descriptor SIMPLE_NAME nonvoid_type_descriptor
{
TypeIdItem classType = $reference_type_descriptor.type;
StringIdItem fieldName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
TypeIdItem fieldType = $nonvoid_type_descriptor.type;
$fieldIdItem = FieldIdItem.internFieldIdItem(dexFile, classType, fieldType, fieldName);
};
registers_directive returns[boolean isLocalsDirective, int registers]
: {$registers = 0;}
^(( I_REGISTERS {$isLocalsDirective = false;}
| I_LOCALS {$isLocalsDirective = true;}
)
short_integral_literal {$registers = $short_integral_literal.value;}
);
labels
: ^(I_LABELS label_def*);
label_def
: ^(I_LABEL SIMPLE_NAME address)
{
if ($method::labels.containsKey($SIMPLE_NAME.text)) {
throw new SemanticException(input, $I_LABEL, "Label " + $SIMPLE_NAME.text + " has multiple defintions.");
}
$method::labels.put($SIMPLE_NAME.text, $address.address);
};
packed_switch_declarations
: ^(I_PACKED_SWITCH_DECLARATIONS packed_switch_declaration*);
packed_switch_declaration
: ^(I_PACKED_SWITCH_DECLARATION address offset_or_label_absolute[$address.address])
{
int switchDataAddress = $offset_or_label_absolute.address;
if ((switchDataAddress \% 2) != 0) {
switchDataAddress++;
}
if (!$method::packedSwitchDeclarations.containsKey(switchDataAddress)) {
$method::packedSwitchDeclarations.put(switchDataAddress, $address.address);
}
};
sparse_switch_declarations
: ^(I_SPARSE_SWITCH_DECLARATIONS sparse_switch_declaration*);
sparse_switch_declaration
: ^(I_SPARSE_SWITCH_DECLARATION address offset_or_label_absolute[$address.address])
{
int switchDataAddress = $offset_or_label_absolute.address;
if ((switchDataAddress \% 2) != 0) {
switchDataAddress++;
}
if (!$method::sparseSwitchDeclarations.containsKey(switchDataAddress)) {
$method::sparseSwitchDeclarations.put(switchDataAddress, $address.address);
}
};
catches : ^(I_CATCHES catch_directive* catchall_directive*);
catch_directive
: ^(I_CATCH address nonvoid_type_descriptor from=offset_or_label_absolute[$address.address] to=offset_or_label_absolute[$address.address]
using=offset_or_label_absolute[$address.address])
{
TypeIdItem type = $nonvoid_type_descriptor.type;
int startAddress = $from.address;
int endAddress = $to.address;
int handlerAddress = $using.address;
$method::tryList.addHandler(type, startAddress, endAddress, handlerAddress);
};
catchall_directive
: ^(I_CATCHALL address from=offset_or_label_absolute[$address.address] to=offset_or_label_absolute[$address.address]
using=offset_or_label_absolute[$address.address])
{
int startAddress = $from.address;
int endAddress = $to.address;
int handlerAddress = $using.address;
$method::tryList.addCatchAllHandler(startAddress, endAddress, handlerAddress);
};
address returns[int address]
: I_ADDRESS
{
$address = Integer.parseInt($I_ADDRESS.text);
};
parameters returns[AnnotationSetRefList parameterAnnotations]
@init
{
int parameterCount = 0;
List<AnnotationSetItem> annotationSetItems = new ArrayList<AnnotationSetItem>();
}
: ^(I_PARAMETERS (parameter
{
if ($parameter.parameterAnnotationSet != null) {
while (annotationSetItems.size() < parameterCount) {
annotationSetItems.add(AnnotationSetItem.internAnnotationSetItem(dexFile, null));
}
annotationSetItems.add($parameter.parameterAnnotationSet);
}
parameterCount++;
})*
)
{
if (annotationSetItems.size() > 0) {
while (annotationSetItems.size() < parameterCount) {
annotationSetItems.add(AnnotationSetItem.internAnnotationSetItem(dexFile, null));
}
$parameterAnnotations = AnnotationSetRefList.internAnnotationSetRefList(dexFile, annotationSetItems);
}
};
parameter returns[AnnotationSetItem parameterAnnotationSet]
: ^(I_PARAMETER (string_literal {$method::debugInfo.addParameterName($string_literal.value);}
| {$method::debugInfo.addParameterName(null);}
)
annotations {$parameterAnnotationSet = $annotations.annotationSetItem;}
);
ordered_debug_directives[int totalMethodRegisters, int methodParameterRegisters]
: ^(I_ORDERED_DEBUG_DIRECTIVES
( line
| local[$totalMethodRegisters, $methodParameterRegisters]
| end_local[$totalMethodRegisters, $methodParameterRegisters]
| restart_local[$totalMethodRegisters, $methodParameterRegisters]
| prologue
| epilogue
| source
)*
);
line
: ^(I_LINE integral_literal address)
{
$method::debugInfo.addLine($address.address, $integral_literal.value);
};
local[int totalMethodRegisters, int methodParameterRegisters]
: ^(I_LOCAL REGISTER SIMPLE_NAME nonvoid_type_descriptor string_literal? address)
{
int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
if ($string_literal.value != null) {
$method::debugInfo.addLocalExtended($address.address, registerNumber, $SIMPLE_NAME.text, $nonvoid_type_descriptor.type.getTypeDescriptor(), $string_literal.value);
} else {
$method::debugInfo.addLocal($address.address, registerNumber, $SIMPLE_NAME.text, $nonvoid_type_descriptor.type.getTypeDescriptor());
}
};
end_local[int totalMethodRegisters, int methodParameterRegisters]
: ^(I_END_LOCAL REGISTER address)
{
int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
$method::debugInfo.addEndLocal($address.address, registerNumber);
};
restart_local[int totalMethodRegisters, int methodParameterRegisters]
: ^(I_RESTART_LOCAL REGISTER address)
{
int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
$method::debugInfo.addRestartLocal($address.address, registerNumber);
};
prologue
: ^(I_PROLOGUE address)
{
$method::debugInfo.addPrologue($address.address);
};
epilogue
: ^(I_EPILOGUE address)
{
$method::debugInfo.addEpilogue($address.address);
};
source
: ^(I_SOURCE string_literal address)
{
$method::debugInfo.addSetFile($address.address, $string_literal.value);
};
statements[int totalMethodRegisters, int methodParameterRegisters] returns[List<Instruction> instructions, int maxOutRegisters]
@init
{
$instructions = new LinkedList<Instruction>();
$maxOutRegisters = 0;
}
: ^(I_STATEMENTS (instruction[$totalMethodRegisters, $methodParameterRegisters, $instructions]
{
$method::currentAddress += $instructions.get($instructions.size() - 1).getSize($method::currentAddress);
if ($maxOutRegisters < $instruction.outRegisters) {
$maxOutRegisters = $instruction.outRegisters;
}
})*);
label_ref returns[int labelAddress]
: SIMPLE_NAME
{
Integer labelAdd = $method::labels.get($SIMPLE_NAME.text);
if (labelAdd == null) {
throw new SemanticException(input, $SIMPLE_NAME, "Label \"" + $SIMPLE_NAME.text + "\" is not defined.");
}
$labelAddress = labelAdd;
};
offset returns[int offsetValue]
: OFFSET
{
String offsetText = $OFFSET.text;
if (offsetText.charAt(0) == '+') {
offsetText = offsetText.substring(1);
}
$offsetValue = LiteralTools.parseInt(offsetText);
};
offset_or_label_absolute[int baseAddress] returns[int address]
: offset {$address = $offset.offsetValue + $baseAddress;}
| label_ref {$address = $label_ref.labelAddress;};
offset_or_label returns[int offsetValue]
: offset {$offsetValue = $offset.offsetValue;}
| label_ref {$offsetValue = $label_ref.labelAddress-$method::currentAddress;};
register_list[int totalMethodRegisters, int methodParameterRegisters] returns[byte[\] registers, byte registerCount]
@init
{
$registers = new byte[5];
$registerCount = 0;
}
: ^(I_REGISTER_LIST
(REGISTER
{
if ($registerCount == 5) {
throw new SemanticException(input, $I_REGISTER_LIST, "A list of registers can only have a maximum of 5 registers. Use the <op>/range alternate opcode instead.");
}
$registers[$registerCount++] = parseRegister_nibble($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
})*);
register_range[int totalMethodRegisters, int methodParameterRegisters] returns[int startRegister, int endRegister]
: ^(I_REGISTER_RANGE (startReg=REGISTER endReg=REGISTER?)?)
{
if ($startReg == null) {
$startRegister = 0;
$endRegister = -1;
} else {
$startRegister = parseRegister_short($startReg.text, $totalMethodRegisters, $methodParameterRegisters);
if ($endReg == null) {
$endRegister = $startRegister;
} else {
$endRegister = parseRegister_short($endReg.text, $totalMethodRegisters, $methodParameterRegisters);
}
int registerCount = $endRegister-$startRegister+1;
if (registerCount < 1) {
throw new SemanticException(input, $I_REGISTER_RANGE, "A register range must have the lower register listed first");
}
}
}
;
verification_error_reference returns[Item item]
: CLASS_DESCRIPTOR
{
$item = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
}
| fully_qualified_field
{
$item = $fully_qualified_field.fieldIdItem;
}
| fully_qualified_method
{
$item = $fully_qualified_method.methodIdItem;
};
verification_error_type returns[VerificationErrorType verificationErrorType]
: VERIFICATION_ERROR_TYPE
{
$verificationErrorType = VerificationErrorType.fromString($VERIFICATION_ERROR_TYPE.text);
};
instruction[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: insn_format10t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format10t.outRegisters; }
| insn_format10x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format10x.outRegisters; }
| insn_format11n[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format11n.outRegisters; }
| insn_format11x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format11x.outRegisters; }
| insn_format12x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format12x.outRegisters; }
| insn_format20bc[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format20bc.outRegisters; }
| insn_format20t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format20t.outRegisters; }
| insn_format21c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_field.outRegisters; }
| insn_format21c_string[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_string.outRegisters; }
| insn_format21c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_type.outRegisters; }
| insn_format21h[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21h.outRegisters; }
| insn_format21s[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21s.outRegisters; }
| insn_format21t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21t.outRegisters; }
| insn_format22b[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22b.outRegisters; }
| insn_format22c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22c_field.outRegisters; }
| insn_format22c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22c_type.outRegisters; }
| insn_format22s[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22s.outRegisters; }
| insn_format22t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22t.outRegisters; }
| insn_format22x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22x.outRegisters; }
| insn_format23x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format23x.outRegisters; }
| insn_format30t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format30t.outRegisters; }
| insn_format31c[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31c.outRegisters; }
| insn_format31i[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31i.outRegisters; }
| insn_format31t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31t.outRegisters; }
| insn_format32x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format32x.outRegisters; }
| insn_format35c_method[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format35c_method.outRegisters; }
| insn_format35c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format35c_type.outRegisters; }
| insn_format3rc_method[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format3rc_method.outRegisters; }
| insn_format3rc_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format3rc_type.outRegisters; }
| insn_format41c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format41c_type.outRegisters; }
| insn_format41c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format41c_field.outRegisters; }
| insn_format51l_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format51l_type.outRegisters; }
| insn_format52c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format52c_type.outRegisters; }
| insn_format52c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format52c_field.outRegisters; }
| insn_format5rc_method[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format5rc_method.outRegisters; }
| insn_format5rc_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format5rc_type.outRegisters; }
| insn_array_data_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_array_data_directive.outRegisters; }
| insn_packed_switch_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_packed_switch_directive.outRegisters; }
| insn_sparse_switch_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_sparse_switch_directive.outRegisters; };
catch [Exception ex] {
reportError(new SemanticException(input, ex));
recover(input, null);
}
insn_format10t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. goto endloop:
{$outRegisters = 0;}
^(I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t offset_or_label)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT10t.text);
int addressOffset = $offset_or_label.offsetValue;
$instructions.add(new Instruction10t(opcode, addressOffset));
};
insn_format10x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. return
^(I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT10x.text);
$instructions.add(new Instruction10x(opcode));
};
insn_format11n[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const/4 v0, 5
^(I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT11n.text);
byte regA = parseRegister_nibble($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
short litB = $short_integral_literal.value;
LiteralTools.checkNibble(litB);
$instructions.add(new Instruction11n(opcode, regA, (byte)litB));
};
insn_format11x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. move-result-object v1
^(I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT11x.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
$instructions.add(new Instruction11x(opcode, regA));
};
insn_format12x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. move v1 v2
^(I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA=REGISTER registerB=REGISTER)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT12x.text);
byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
$instructions.add(new Instruction12x(opcode, regA, regB));
};
insn_format20bc[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. throw-verification-error generic-error, Lsome/class;
^(I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT20bc.text);
VerificationErrorType verificationErrorType = $verification_error_type.verificationErrorType;
Item referencedItem = $verification_error_reference.item;
$instructions.add(new Instruction20bc(opcode, verificationErrorType, referencedItem));
};
insn_format20t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. goto/16 endloop:
^(I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t offset_or_label)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT20t.text);
int addressOffset = $offset_or_label.offsetValue;
$instructions.add(new Instruction20t(opcode, addressOffset));
};
insn_format21c_field[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. sget_object v0, java/lang/System/out LJava/io/PrintStream;
^(I_STATEMENT_FORMAT21c_FIELD inst=(INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX) REGISTER fully_qualified_field)
{
Opcode opcode = Opcode.getOpcodeByName($inst.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
$instructions.add(new Instruction21c(opcode, regA, fieldIdItem));
};
insn_format21c_string[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const-string v1, "Hello World!"
^(I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_STRING.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
StringIdItem stringIdItem = StringIdItem.internStringIdItem(dexFile, $string_literal.value);
instructions.add(new Instruction21c(opcode, regA, stringIdItem));
};
insn_format21c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const-class v2, org/jf/HelloWorld2/HelloWorld2
^(I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER reference_type_descriptor)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_TYPE.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
TypeIdItem typeIdItem = $reference_type_descriptor.type;
$instructions.add(new Instruction21c(opcode, regA, typeIdItem));
};
insn_format21h[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const/high16 v1, 1234
^(I_STATEMENT_FORMAT21h INSTRUCTION_FORMAT21h REGISTER short_integral_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21h.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
short litB = $short_integral_literal.value;
instructions.add(new Instruction21h(opcode, regA, litB));
};
insn_format21s[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const/16 v1, 1234
^(I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21s.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
short litB = $short_integral_literal.value;
$instructions.add(new Instruction21s(opcode, regA, litB));
};
insn_format21t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. if-eqz v0, endloop:
^(I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER offset_or_label)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21t.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
int addressOffset = $offset_or_label.offsetValue;
if (addressOffset < Short.MIN_VALUE || addressOffset > Short.MAX_VALUE) {
throw new SemanticException(input, $offset_or_label.start, "The offset/label is out of range. The offset is " + Integer.toString(addressOffset) + " and the range for this opcode is [-32768, 32767].");
}
$instructions.add(new Instruction21t(opcode, regA, (short)addressOffset));
};
insn_format22b[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. add-int v0, v1, 123
^(I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA=REGISTER registerB=REGISTER short_integral_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22b.text);
short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
short regB = parseRegister_byte($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
short litC = $short_integral_literal.value;
LiteralTools.checkByte(litC);
$instructions.add(new Instruction22b(opcode, regA, regB, (byte)litC));
};
insn_format22c_field[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. iput-object v1, v0, org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
^(I_STATEMENT_FORMAT22c_FIELD inst=(INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX) registerA=REGISTER registerB=REGISTER fully_qualified_field)
{
Opcode opcode = Opcode.getOpcodeByName($inst.text);
byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
$instructions.add(new Instruction22c(opcode, regA, regB, fieldIdItem));
};
insn_format22c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. instance-of v0, v1, Ljava/lang/String;
^(I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA=REGISTER registerB=REGISTER nonvoid_type_descriptor)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22c_TYPE.text);
byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
$instructions.add(new Instruction22c(opcode, regA, regB, typeIdItem));
};
insn_format22s[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. add-int/lit16 v0, v1, 12345
^(I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA=REGISTER registerB=REGISTER short_integral_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22s.text);
byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
short litC = $short_integral_literal.value;
$instructions.add(new Instruction22s(opcode, regA, regB, litC));
};
insn_format22t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. if-eq v0, v1, endloop:
^(I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA=REGISTER registerB=REGISTER offset_or_label)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22t.text);
byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
int addressOffset = $offset_or_label.offsetValue;
if (addressOffset < Short.MIN_VALUE || addressOffset > Short.MAX_VALUE) {
throw new SemanticException(input, $offset_or_label.start, "The offset/label is out of range. The offset is " + Integer.toString(addressOffset) + " and the range for this opcode is [-32768, 32767].");
}
$instructions.add(new Instruction22t(opcode, regA, regB, (short)addressOffset));
};
insn_format22x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. move/from16 v1, v1234
^(I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA=REGISTER registerB=REGISTER)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22x.text);
short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
$instructions.add(new Instruction22x(opcode, regA, regB));
};
insn_format23x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. add-int v1, v2, v3
^(I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA=REGISTER registerB=REGISTER registerC=REGISTER)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT23x.text);
short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
short regB = parseRegister_byte($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
short regC = parseRegister_byte($registerC.text, $totalMethodRegisters, $methodParameterRegisters);
$instructions.add(new Instruction23x(opcode, regA, regB, regC));
};
insn_format30t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. goto/32 endloop:
^(I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t offset_or_label)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT30t.text);
int addressOffset = $offset_or_label.offsetValue;
$instructions.add(new Instruction30t(opcode, addressOffset));
};
insn_format31c[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const-string/jumbo v1 "Hello World!"
^(I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31c.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
StringIdItem stringIdItem = StringIdItem.internStringIdItem(dexFile, $string_literal.value);
$instructions.add(new Instruction31c(opcode, regA, stringIdItem));
};
insn_format31i[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const v0, 123456
^(I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31i.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
int litB = $fixed_32bit_literal.value;
$instructions.add(new Instruction31i(opcode, regA, litB));
};
insn_format31t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. fill-array-data v0, ArrayData:
^(I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER offset_or_label)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31t.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
int addressOffset = $offset_or_label.offsetValue;
if (($method::currentAddress + addressOffset) \% 2 != 0) {
addressOffset++;
}
$instructions.add(new Instruction31t(opcode, regA, addressOffset));
};
insn_format32x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. move/16 v5678, v1234
^(I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA=REGISTER registerB=REGISTER)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT32x.text);
int regA = parseRegister_short($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
$instructions.add(new Instruction32x(opcode, regA, regB));
};
insn_format35c_method[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. invoke-virtual {v0,v1} java/io/PrintStream/print(Ljava/lang/Stream;)V
^(I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list[$totalMethodRegisters, $methodParameterRegisters] fully_qualified_method)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT35c_METHOD.text);
//this depends on the fact that register_list returns a byte[5]
byte[] registers = $register_list.registers;
byte registerCount = $register_list.registerCount;
$outRegisters = registerCount;
MethodIdItem methodIdItem = $fully_qualified_method.methodIdItem;
$instructions.add(new Instruction35c(opcode, registerCount, registers[0], registers[1], registers[2], registers[3], registers[4], methodIdItem));
};
insn_format35c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. filled-new-array {v0,v1}, I
^(I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list[$totalMethodRegisters, $methodParameterRegisters] nonvoid_type_descriptor)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT35c_TYPE.text);
//this depends on the fact that register_list returns a byte[5]
byte[] registers = $register_list.registers;
byte registerCount = $register_list.registerCount;
$outRegisters = registerCount;
TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
$instructions.add(new Instruction35c(opcode, registerCount, registers[0], registers[1], registers[2], registers[3], registers[4], typeIdItem));
};
insn_format3rc_method[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. invoke-virtual/range {v25..v26} java/lang/StringBuilder/append(Ljava/lang/String;)Ljava/lang/StringBuilder;
^(I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range[$totalMethodRegisters, $methodParameterRegisters] fully_qualified_method)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT3rc_METHOD.text);
int startRegister = $register_range.startRegister;
int endRegister = $register_range.endRegister;
int registerCount = endRegister-startRegister+1;
$outRegisters = registerCount;
MethodIdItem methodIdItem = $fully_qualified_method.methodIdItem;
$instructions.add(new Instruction3rc(opcode, (short)registerCount, startRegister, methodIdItem));
};
insn_format3rc_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. filled-new-array/range {v0..v6} I
^(I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range[$totalMethodRegisters, $methodParameterRegisters] nonvoid_type_descriptor)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT3rc_TYPE.text);
int startRegister = $register_range.startRegister;
int endRegister = $register_range.endRegister;
int registerCount = endRegister-startRegister+1;
$outRegisters = registerCount;
TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
$instructions.add(new Instruction3rc(opcode, (short)registerCount, startRegister, typeIdItem));
};
insn_format41c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const-class/jumbo v2, org/jf/HelloWorld2/HelloWorld2
^(I_STATEMENT_FORMAT41c_TYPE INSTRUCTION_FORMAT41c_TYPE REGISTER reference_type_descriptor)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT41c_TYPE.text);
int regA = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
TypeIdItem typeIdItem = $reference_type_descriptor.type;
$instructions.add(new Instruction41c(opcode, regA, typeIdItem));
};
insn_format41c_field[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. sget-object/jumbo v0, Ljava/lang/System;->out:LJava/io/PrintStream;
^(I_STATEMENT_FORMAT41c_FIELD INSTRUCTION_FORMAT41c_FIELD REGISTER fully_qualified_field)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT41c_FIELD.text);
int regA = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
$instructions.add(new Instruction41c(opcode, regA, fieldIdItem));
};
insn_format51l_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. const-wide v0, 5000000000L
^(I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT51l.text);
short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
long litB = $fixed_64bit_literal.value;
$instructions.add(new Instruction51l(opcode, regA, litB));
};
insn_format52c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. instance-of/jumbo v0, v1, Ljava/lang/String;
^(I_STATEMENT_FORMAT52c_TYPE INSTRUCTION_FORMAT52c_TYPE registerA=REGISTER registerB=REGISTER nonvoid_type_descriptor)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT52c_TYPE.text);
int regA = parseRegister_short($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
$instructions.add(new Instruction52c(opcode, regA, regB, typeIdItem));
};
insn_format52c_field[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. iput-object/jumbo v1, v0, Lorg/jf/HelloWorld2/HelloWorld2;->helloWorld:Ljava/lang/String;
^(I_STATEMENT_FORMAT52c_FIELD INSTRUCTION_FORMAT52c_FIELD registerA=REGISTER registerB=REGISTER fully_qualified_field)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT52c_FIELD.text);
int regA = parseRegister_short($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
$instructions.add(new Instruction52c(opcode, regA, regB, fieldIdItem));
};
insn_format5rc_method[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. invoke-virtual/jumbo {v25..v26} java/lang/StringBuilder/append(Ljava/lang/String;)Ljava/lang/StringBuilder;
^(I_STATEMENT_FORMAT5rc_METHOD INSTRUCTION_FORMAT5rc_METHOD register_range[$totalMethodRegisters, $methodParameterRegisters] fully_qualified_method)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT5rc_METHOD.text);
int startRegister = $register_range.startRegister;
int endRegister = $register_range.endRegister;
int registerCount = endRegister-startRegister+1;
$outRegisters = registerCount;
MethodIdItem methodIdItem = $fully_qualified_method.methodIdItem;
$instructions.add(new Instruction5rc(opcode, registerCount, startRegister, methodIdItem));
};
insn_format5rc_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. filled-new-array/jumbo {v0..v6} I
^(I_STATEMENT_FORMAT5rc_TYPE INSTRUCTION_FORMAT5rc_TYPE register_range[$totalMethodRegisters, $methodParameterRegisters] nonvoid_type_descriptor)
{
Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT5rc_TYPE.text);
int startRegister = $register_range.startRegister;
int endRegister = $register_range.endRegister;
int registerCount = endRegister-startRegister+1;
$outRegisters = registerCount;
TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
$instructions.add(new Instruction5rc(opcode, registerCount, startRegister, typeIdItem));
};
insn_array_data_directive[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
: //e.g. .array-data 4 1000000 .end array-data
^(I_STATEMENT_ARRAY_DATA ^(I_ARRAY_ELEMENT_SIZE short_integral_literal) array_elements)
{
if (($method::currentAddress \% 2) != 0) {
$instructions.add(new Instruction10x(Opcode.NOP));
$method::currentAddress++;
}
int elementWidth = $short_integral_literal.value;
List<byte[]> byteValues = $array_elements.values;
int length = 0;
for (byte[] byteValue: byteValues) {
length+=byteValue.length;
}
byte[] encodedValues = new byte[length];
int index = 0;
for (byte[] byteValue: byteValues) {
System.arraycopy(byteValue, 0, encodedValues, index, byteValue.length);
index+=byteValue.length;
}
$instructions.add(new ArrayDataPseudoInstruction(elementWidth, encodedValues));
};
insn_packed_switch_directive[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
:
^(I_STATEMENT_PACKED_SWITCH ^(I_PACKED_SWITCH_START_KEY fixed_32bit_literal)
{
if (($method::currentAddress \% 2) != 0) {
$instructions.add(new Instruction10x(Opcode.NOP));
$method::currentAddress++;
}
Integer baseAddress = $method::packedSwitchDeclarations.get($method::currentAddress);
if (baseAddress == null) {
baseAddress = 0;
}
}
packed_switch_targets[baseAddress])
{
int startKey = $fixed_32bit_literal.value;
int[] targets = $packed_switch_targets.targets;
$instructions.add(new PackedSwitchDataPseudoInstruction(startKey, targets));
};
insn_sparse_switch_directive[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
:
^(I_STATEMENT_SPARSE_SWITCH sparse_switch_target_count sparse_switch_keys[$sparse_switch_target_count.targetCount]
{
if (($method::currentAddress \% 2) != 0) {
$instructions.add(new Instruction10x(Opcode.NOP));
$method::currentAddress++;
}
Integer baseAddress = $method::sparseSwitchDeclarations.get($method::currentAddress);
if (baseAddress == null) {
baseAddress = 0;
}
}
sparse_switch_targets[baseAddress, $sparse_switch_target_count.targetCount])
{
int[] keys = $sparse_switch_keys.keys;
int[] targets = $sparse_switch_targets.targets;
$instructions.add(new SparseSwitchDataPseudoInstruction(keys, targets));
};
nonvoid_type_descriptor returns [TypeIdItem type]
: (PRIMITIVE_TYPE
| CLASS_DESCRIPTOR
| ARRAY_DESCRIPTOR)
{
$type = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
};
reference_type_descriptor returns [TypeIdItem type]
: (CLASS_DESCRIPTOR
| ARRAY_DESCRIPTOR)
{
$type = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
};
class_type_descriptor returns [TypeIdItem type]
: CLASS_DESCRIPTOR
{
$type = TypeIdItem.internTypeIdItem(dexFile, $CLASS_DESCRIPTOR.text);
};
type_descriptor returns [TypeIdItem type]
: VOID_TYPE {$type = TypeIdItem.internTypeIdItem(dexFile, "V");}
| nonvoid_type_descriptor {$type = $nonvoid_type_descriptor.type;}
;
short_integral_literal returns[short value]
: long_literal
{
LiteralTools.checkShort($long_literal.value);
$value = (short)$long_literal.value;
}
| integer_literal
{
LiteralTools.checkShort($integer_literal.value);
$value = (short)$integer_literal.value;
}
| short_literal {$value = $short_literal.value;}
| char_literal {$value = (short)$char_literal.value;}
| byte_literal {$value = $byte_literal.value;};
integral_literal returns[int value]
: long_literal
{
LiteralTools.checkInt($long_literal.value);
$value = (int)$long_literal.value;
}
| integer_literal {$value = $integer_literal.value;}
| short_literal {$value = $short_literal.value;}
| byte_literal {$value = $byte_literal.value;};
integer_literal returns[int value]
: INTEGER_LITERAL { $value = LiteralTools.parseInt($INTEGER_LITERAL.text); };
long_literal returns[long value]
: LONG_LITERAL { $value = LiteralTools.parseLong($LONG_LITERAL.text); };
short_literal returns[short value]
: SHORT_LITERAL { $value = LiteralTools.parseShort($SHORT_LITERAL.text); };
byte_literal returns[byte value]
: BYTE_LITERAL { $value = LiteralTools.parseByte($BYTE_LITERAL.text); };
float_literal returns[float value]
: FLOAT_LITERAL { $value = LiteralTools.parseFloat($FLOAT_LITERAL.text); };
double_literal returns[double value]
: DOUBLE_LITERAL { $value = LiteralTools.parseDouble($DOUBLE_LITERAL.text); };
char_literal returns[char value]
: CHAR_LITERAL { $value = $CHAR_LITERAL.text.charAt(1); };
string_literal returns[String value]
: STRING_LITERAL
{
$value = $STRING_LITERAL.text;
$value = $value.substring(1,$value.length()-1);
};
bool_literal returns[boolean value]
: BOOL_LITERAL { $value = Boolean.parseBoolean($BOOL_LITERAL.text); };
array_literal returns[EncodedValue[\] values]
: {ArrayList<EncodedValue> valuesList = new ArrayList<EncodedValue>();}
^(I_ENCODED_ARRAY (literal {valuesList.add($literal.encodedValue);})*)
{
$values = new EncodedValue[valuesList.size()];
valuesList.toArray($values);
};
annotations returns[AnnotationSetItem annotationSetItem]
: {ArrayList<AnnotationItem> annotationList = new ArrayList<AnnotationItem>();}
^(I_ANNOTATIONS (annotation {annotationList.add($annotation.annotationItem);} )*)
{
if (annotationList.size() > 0) {
$annotationSetItem = AnnotationSetItem.internAnnotationSetItem(dexFile, annotationList);
}
};
annotation returns[AnnotationItem annotationItem]
: ^(I_ANNOTATION ANNOTATION_VISIBILITY subannotation)
{
AnnotationVisibility visibility = AnnotationVisibility.valueOf($ANNOTATION_VISIBILITY.text.toUpperCase());
AnnotationEncodedSubValue encodedAnnotation = new AnnotationEncodedSubValue($subannotation.annotationType,
$subannotation.elementNames, $subannotation.elementValues);
$annotationItem = AnnotationItem.internAnnotationItem(dexFile, visibility, encodedAnnotation);
};
annotation_element returns[StringIdItem elementName, EncodedValue elementValue]
: ^(I_ANNOTATION_ELEMENT SIMPLE_NAME literal)
{
$elementName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
$elementValue = $literal.encodedValue;
};
subannotation returns[TypeIdItem annotationType, StringIdItem[\] elementNames, EncodedValue[\] elementValues]
: {ImmutableSortedMap.Builder<StringIdItem, EncodedValue> elementBuilder =
ImmutableSortedMap.<StringIdItem, EncodedValue>naturalOrder();}
^(I_SUBANNOTATION
class_type_descriptor
(annotation_element
{
elementBuilder.put($annotation_element.elementName, $annotation_element.elementValue);
}
)*
)
{
ImmutableSortedMap<StringIdItem, EncodedValue> elementMap = elementBuilder.build();
$annotationType = $class_type_descriptor.type;
$elementNames = new StringIdItem[elementMap.size()];
$elementValues = new EncodedValue[elementMap.size()];
elementMap.keySet().toArray($elementNames);
elementMap.values().toArray($elementValues);
};
field_literal returns[FieldIdItem value]
: ^(I_ENCODED_FIELD fully_qualified_field)
{
$value = $fully_qualified_field.fieldIdItem;
};
method_literal returns[MethodIdItem value]
: ^(I_ENCODED_METHOD fully_qualified_method)
{
$value = $fully_qualified_method.methodIdItem;
};
enum_literal returns[FieldIdItem value]
: ^(I_ENCODED_ENUM fully_qualified_field)
{
$value = $fully_qualified_field.fieldIdItem;
};
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/antlr3/smaliTreeWalker.g
|
GAP
|
asf20
| 71,883
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
parser grammar smaliParser;
options {
output=AST;
ASTLabelType=CommonTree;
}
tokens {
//Lexer tokens
ACCESS_SPEC;
ANNOTATION_DIRECTIVE;
ANNOTATION_VISIBILITY;
ARRAY_DATA_DIRECTIVE;
ARRAY_DESCRIPTOR;
ARROW;
BASE_ARRAY_DESCRIPTOR;
BASE_CHAR_LITERAL;
BASE_CLASS_DESCRIPTOR;
BASE_FLOAT;
BASE_FLOAT_OR_ID;
BASE_INTEGER;
BASE_PRIMITIVE_TYPE;
BASE_SIMPLE_NAME;
BASE_STRING_LITERAL;
BASE_TYPE;
BINARY_EXPONENT;
BOOL_LITERAL;
BYTE_LITERAL;
CATCH_DIRECTIVE;
CATCHALL_DIRECTIVE;
CHAR_LITERAL;
CLASS_DESCRIPTOR;
CLASS_DIRECTIVE;
CLOSE_BRACE;
CLOSE_PAREN;
COLON;
COMMA;
DECIMAL_EXPONENT;
DOTDOT;
DOUBLE_LITERAL;
DOUBLE_LITERAL_OR_ID;
END_ANNOTATION_DIRECTIVE;
END_ARRAY_DATA_DIRECTIVE;
END_FIELD_DIRECTIVE;
END_LOCAL_DIRECTIVE;
END_METHOD_DIRECTIVE;
END_PACKED_SWITCH_DIRECTIVE;
END_PARAMETER_DIRECTIVE;
END_SPARSE_SWITCH_DIRECTIVE;
END_SUBANNOTATION_DIRECTIVE;
ENUM_DIRECTIVE;
EPILOGUE_DIRECTIVE;
EQUAL;
ESCAPE_SEQUENCE;
FIELD_DIRECTIVE;
FIELD_OFFSET;
FLOAT_LITERAL;
FLOAT_LITERAL_OR_ID;
HEX_DIGIT;
HEX_DIGITS;
HEX_PREFIX;
IMPLEMENTS_DIRECTIVE;
INLINE_INDEX;
INSTRUCTION_FORMAT10t;
INSTRUCTION_FORMAT10x;
INSTRUCTION_FORMAT10x_ODEX;
INSTRUCTION_FORMAT11n;
INSTRUCTION_FORMAT11x;
INSTRUCTION_FORMAT12x;
INSTRUCTION_FORMAT12x_OR_ID;
INSTRUCTION_FORMAT20bc;
INSTRUCTION_FORMAT20t;
INSTRUCTION_FORMAT21c_FIELD;
INSTRUCTION_FORMAT21c_FIELD_ODEX;
INSTRUCTION_FORMAT21c_STRING;
INSTRUCTION_FORMAT21c_TYPE;
INSTRUCTION_FORMAT21h;
INSTRUCTION_FORMAT21s;
INSTRUCTION_FORMAT21t;
INSTRUCTION_FORMAT22b;
INSTRUCTION_FORMAT22c_FIELD;
INSTRUCTION_FORMAT22c_FIELD_ODEX;
INSTRUCTION_FORMAT22c_TYPE;
INSTRUCTION_FORMAT22cs_FIELD;
INSTRUCTION_FORMAT22s;
INSTRUCTION_FORMAT22s_OR_ID;
INSTRUCTION_FORMAT22t;
INSTRUCTION_FORMAT22x;
INSTRUCTION_FORMAT23x;
INSTRUCTION_FORMAT30t;
INSTRUCTION_FORMAT31c;
INSTRUCTION_FORMAT31i;
INSTRUCTION_FORMAT31i_OR_ID;
INSTRUCTION_FORMAT31t;
INSTRUCTION_FORMAT32x;
INSTRUCTION_FORMAT35c_METHOD;
INSTRUCTION_FORMAT35c_METHOD_ODEX;
INSTRUCTION_FORMAT35c_TYPE;
INSTRUCTION_FORMAT35mi_METHOD;
INSTRUCTION_FORMAT35ms_METHOD;
INSTRUCTION_FORMAT3rc_METHOD;
INSTRUCTION_FORMAT3rc_METHOD_ODEX;
INSTRUCTION_FORMAT3rc_TYPE;
INSTRUCTION_FORMAT3rmi_METHOD;
INSTRUCTION_FORMAT3rms_METHOD;
INSTRUCTION_FORMAT51l;
INVALID_TOKEN;
LINE_COMMENT;
LINE_DIRECTIVE;
LOCAL_DIRECTIVE;
LOCALS_DIRECTIVE;
LONG_LITERAL;
METHOD_DIRECTIVE;
METHOD_NAME;
NEGATIVE_INTEGER_LITERAL;
NULL_LITERAL;
OFFSET;
OPEN_BRACE;
OPEN_PAREN;
PACKED_SWITCH_DIRECTIVE;
PARAM_LIST;
PARAM_LIST_OR_ID;
PARAMETER_DIRECTIVE;
POSITIVE_INTEGER_LITERAL;
PRIMITIVE_TYPE;
PROLOGUE_DIRECTIVE;
REGISTER;
REGISTERS_DIRECTIVE;
RESTART_LOCAL_DIRECTIVE;
SHORT_LITERAL;
SIMPLE_NAME;
SOURCE_DIRECTIVE;
SPARSE_SWITCH_DIRECTIVE;
STRING_LITERAL;
SUBANNOTATION_DIRECTIVE;
SUPER_DIRECTIVE;
VERIFICATION_ERROR_TYPE;
VOID_TYPE;
VTABLE_INDEX;
WHITE_SPACE;
//A couple of generated types that we remap other tokens to, to simplify the generated AST
LABEL;
INTEGER_LITERAL;
//I_* tokens are imaginary tokens used as parent AST nodes
I_CLASS_DEF;
I_SUPER;
I_IMPLEMENTS;
I_SOURCE;
I_ACCESS_LIST;
I_METHODS;
I_FIELDS;
I_FIELD;
I_FIELD_TYPE;
I_FIELD_INITIAL_VALUE;
I_METHOD;
I_METHOD_PROTOTYPE;
I_METHOD_RETURN_TYPE;
I_REGISTERS;
I_LOCALS;
I_LABELS;
I_LABEL;
I_ANNOTATIONS;
I_ANNOTATION;
I_ANNOTATION_ELEMENT;
I_SUBANNOTATION;
I_ENCODED_FIELD;
I_ENCODED_METHOD;
I_ENCODED_ENUM;
I_ENCODED_ARRAY;
I_ARRAY_ELEMENT_SIZE;
I_ARRAY_ELEMENTS;
I_PACKED_SWITCH_START_KEY;
I_PACKED_SWITCH_TARGET_COUNT;
I_PACKED_SWITCH_TARGETS;
I_PACKED_SWITCH_DECLARATION;
I_PACKED_SWITCH_DECLARATIONS;
I_SPARSE_SWITCH_KEYS;
I_SPARSE_SWITCH_TARGET_COUNT;
I_SPARSE_SWITCH_TARGETS;
I_SPARSE_SWITCH_DECLARATION;
I_SPARSE_SWITCH_DECLARATIONS;
I_ADDRESS;
I_CATCH;
I_CATCHALL;
I_CATCHES;
I_PARAMETER;
I_PARAMETERS;
I_PARAMETER_NOT_SPECIFIED;
I_ORDERED_DEBUG_DIRECTIVES;
I_LINE;
I_LOCAL;
I_END_LOCAL;
I_RESTART_LOCAL;
I_PROLOGUE;
I_EPILOGUE;
I_STATEMENTS;
I_STATEMENT_FORMAT10t;
I_STATEMENT_FORMAT10x;
I_STATEMENT_FORMAT11n;
I_STATEMENT_FORMAT11x;
I_STATEMENT_FORMAT12x;
I_STATEMENT_FORMAT20bc;
I_STATEMENT_FORMAT20t;
I_STATEMENT_FORMAT21c_TYPE;
I_STATEMENT_FORMAT21c_FIELD;
I_STATEMENT_FORMAT21c_STRING;
I_STATEMENT_FORMAT21h;
I_STATEMENT_FORMAT21s;
I_STATEMENT_FORMAT21t;
I_STATEMENT_FORMAT22b;
I_STATEMENT_FORMAT22c_FIELD;
I_STATEMENT_FORMAT22c_TYPE;
I_STATEMENT_FORMAT22s;
I_STATEMENT_FORMAT22t;
I_STATEMENT_FORMAT22x;
I_STATEMENT_FORMAT23x;
I_STATEMENT_FORMAT30t;
I_STATEMENT_FORMAT31c;
I_STATEMENT_FORMAT31i;
I_STATEMENT_FORMAT31t;
I_STATEMENT_FORMAT32x;
I_STATEMENT_FORMAT35c_METHOD;
I_STATEMENT_FORMAT35c_TYPE;
I_STATEMENT_FORMAT3rc_METHOD;
I_STATEMENT_FORMAT3rc_TYPE;
I_STATEMENT_FORMAT41c_TYPE;
I_STATEMENT_FORMAT41c_FIELD;
I_STATEMENT_FORMAT51l;
I_STATEMENT_FORMAT52c_TYPE;
I_STATEMENT_FORMAT52c_FIELD;
I_STATEMENT_FORMAT5rc_METHOD;
I_STATEMENT_FORMAT5rc_TYPE;
I_STATEMENT_ARRAY_DATA;
I_STATEMENT_PACKED_SWITCH;
I_STATEMENT_SPARSE_SWITCH;
I_REGISTER_RANGE;
I_REGISTER_LIST;
}
@header {
package org.jf.smali;
import org.jf.dexlib.Code.Format.*;
import org.jf.dexlib.Code.Opcode;
}
@members {
public static final int ERROR_CHANNEL = 100;
private boolean verboseErrors = false;
private boolean allowOdex = false;
private int apiLevel;
public void setVerboseErrors(boolean verboseErrors) {
this.verboseErrors = verboseErrors;
}
public void setAllowOdex(boolean allowOdex) {
this.allowOdex = allowOdex;
}
public void setApiLevel(int apiLevel) {
this.apiLevel = apiLevel;
}
public String getErrorMessage(RecognitionException e,
String[] tokenNames) {
if (verboseErrors) {
List stack = getRuleInvocationStack(e, this.getClass().getName());
String msg = null;
if (e instanceof NoViableAltException) {
NoViableAltException nvae = (NoViableAltException)e;
msg = " no viable alt; token="+getTokenErrorDisplay(e.token)+
" (decision="+nvae.decisionNumber+
" state "+nvae.stateNumber+")"+
" decision=<<"+nvae.grammarDecisionDescription+">>";
} else {
msg = super.getErrorMessage(e, tokenNames);
}
return stack + " " + msg;
} else {
return super.getErrorMessage(e, tokenNames);
}
}
public String getTokenErrorDisplay(Token t) {
if (!verboseErrors) {
String s = t.getText();
if ( s==null ) {
if ( t.getType()==Token.EOF ) {
s = "<EOF>";
}
else {
s = "<"+tokenNames[t.getType()]+">";
}
}
s = s.replaceAll("\n","\\\\n");
s = s.replaceAll("\r","\\\\r");
s = s.replaceAll("\t","\\\\t");
return "'"+s+"'";
}
CommonToken ct = (CommonToken)t;
String channelStr = "";
if (t.getChannel()>0) {
channelStr=",channel="+t.getChannel();
}
String txt = t.getText();
if ( txt!=null ) {
txt = txt.replaceAll("\n","\\\\n");
txt = txt.replaceAll("\r","\\\\r");
txt = txt.replaceAll("\t","\\\\t");
}
else {
txt = "<no text>";
}
return "[@"+t.getTokenIndex()+","+ct.getStartIndex()+":"+ct.getStopIndex()+"='"+txt+"',<"+tokenNames[t.getType()]+">"+channelStr+","+t.getLine()+":"+t.getCharPositionInLine()+"]";
}
public String getErrorHeader(RecognitionException e) {
return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]";
}
private CommonTree buildTree(int type, String text, List<CommonTree> children) {
CommonTree root = new CommonTree(new CommonToken(type, text));
for (CommonTree child: children) {
root.addChild(child);
}
return root;
}
private CommonToken getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex) {
CommonToken token = new CommonToken(baseToken);
token.setStartIndex(baseToken.getStartIndex() + typeStartIndex);
switch (str.charAt(typeStartIndex)) {
case 'Z':
case 'B':
case 'S':
case 'C':
case 'I':
case 'J':
case 'F':
case 'D':
{
token.setType(PRIMITIVE_TYPE);
token.setText(str.substring(typeStartIndex, typeStartIndex+1));
token.setStopIndex(baseToken.getStartIndex() + typeStartIndex);
break;
}
case 'L':
{
int i = typeStartIndex;
while (str.charAt(++i) != ';');
token.setType(CLASS_DESCRIPTOR);
token.setText(str.substring(typeStartIndex, i + 1));
token.setStopIndex(baseToken.getStartIndex() + i);
break;
}
case '[':
{
int i = typeStartIndex;
while (str.charAt(++i) == '[');
if (str.charAt(i++) == 'L') {
while (str.charAt(i++) != ';');
}
token.setType(ARRAY_DESCRIPTOR);
token.setText(str.substring(typeStartIndex, i));
token.setStopIndex(baseToken.getStartIndex() + i - 1);
break;
}
default:
throw new RuntimeException(String.format("Invalid character '\%c' in param list \"\%s\" at position \%d", str.charAt(typeStartIndex), str, typeStartIndex));
}
return token;
}
private CommonTree parseParamList(CommonToken paramListToken) {
String paramList = paramListToken.getText();
CommonTree root = new CommonTree();
int startIndex = paramListToken.getStartIndex();
int i=0;
while (i<paramList.length()) {
CommonToken token = getParamListSubToken(paramListToken, paramList, i);
root.addChild(new CommonTree(token));
i += token.getText().length();
}
if (root.getChildCount() == 0) {
return null;
}
return root;
}
private void throwOdexedInstructionException(IntStream input, String odexedInstruction)
throws OdexedInstructionException {
/*this has to be done in a separate method, otherwise java will complain about the
auto-generated code in the rule after the throw not being reachable*/
throw new OdexedInstructionException(input, odexedInstruction);
}
}
smali_file
scope
{
boolean hasClassSpec;
boolean hasSuperSpec;
boolean hasSourceSpec;
List<CommonTree> classAnnotations;
}
@init
{ $smali_file::hasClassSpec = $smali_file::hasSuperSpec = $smali_file::hasSourceSpec = false;
$smali_file::classAnnotations = new ArrayList<CommonTree>();
}
:
( {!$smali_file::hasClassSpec}?=> class_spec {$smali_file::hasClassSpec = true;}
| {!$smali_file::hasSuperSpec}?=> super_spec {$smali_file::hasSuperSpec = true;}
| implements_spec
| {!$smali_file::hasSourceSpec}?=> source_spec {$smali_file::hasSourceSpec = true;}
| method
| field
| annotation {$smali_file::classAnnotations.add($annotation.tree);}
)+
EOF
{
if (!$smali_file::hasClassSpec) {
throw new SemanticException(input, "The file must contain a .class directive");
}
if (!$smali_file::hasSuperSpec) {
if (!$class_spec.className.equals("Ljava/lang/Object;")) {
throw new SemanticException(input, "The file must contain a .super directive");
}
}
}
-> ^(I_CLASS_DEF
class_spec
super_spec?
implements_spec*
source_spec?
^(I_METHODS method*) ^(I_FIELDS field*) {buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", $smali_file::classAnnotations)});
class_spec returns[String className]
: CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR {$className = $CLASS_DESCRIPTOR.text;} -> CLASS_DESCRIPTOR access_list;
super_spec
: SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^(I_SUPER[$start, "I_SUPER"] CLASS_DESCRIPTOR);
implements_spec
: IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^(I_IMPLEMENTS[$start, "I_IMPLEMENTS"] CLASS_DESCRIPTOR);
source_spec
: SOURCE_DIRECTIVE STRING_LITERAL -> ^(I_SOURCE[$start, "I_SOURCE"] STRING_LITERAL);
access_list
: ACCESS_SPEC* -> ^(I_ACCESS_LIST[$start,"I_ACCESS_LIST"] ACCESS_SPEC*);
/*When there are annotations immediately after a field definition, we don't know whether they are field annotations
or class annotations until we determine if there is an .end field directive. In either case, we still "consume" and parse
the annotations. If it turns out that they are field annotations, we include them in the I_FIELD AST. Otherwise, we
add them to the $smali_file::classAnnotations list*/
field
@init {List<CommonTree> annotations = new ArrayList<CommonTree>();}
: FIELD_DIRECTIVE access_list simple_name COLON nonvoid_type_descriptor (EQUAL literal)?
( ({input.LA(1) == ANNOTATION_DIRECTIVE}? annotation {annotations.add($annotation.tree);})*
( END_FIELD_DIRECTIVE
-> ^(I_FIELD[$start, "I_FIELD"] simple_name access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) ^(I_FIELD_INITIAL_VALUE literal)? ^(I_ANNOTATIONS annotation*))
| /*epsilon*/ {$smali_file::classAnnotations.addAll(annotations);}
-> ^(I_FIELD[$start, "I_FIELD"] simple_name access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) ^(I_FIELD_INITIAL_VALUE literal)? ^(I_ANNOTATIONS))
)
);
method
scope {int currentAddress;}
: {$method::currentAddress = 0;}
METHOD_DIRECTIVE access_list method_name method_prototype statements_and_directives
END_METHOD_DIRECTIVE
-> ^(I_METHOD[$start, "I_METHOD"] method_name method_prototype access_list statements_and_directives);
statements_and_directives
scope
{
boolean hasRegistersDirective;
List<CommonTree> packedSwitchDeclarations;
List<CommonTree> sparseSwitchDeclarations;
List<CommonTree> methodAnnotations;
}
: {
$method::currentAddress = 0;
$statements_and_directives::hasRegistersDirective = false;
$statements_and_directives::packedSwitchDeclarations = new ArrayList<CommonTree>();
$statements_and_directives::sparseSwitchDeclarations = new ArrayList<CommonTree>();
$statements_and_directives::methodAnnotations = new ArrayList<CommonTree>();
}
( instruction {$method::currentAddress += $instruction.size/2;}
| registers_directive
| label
| catch_directive
| catchall_directive
| parameter_directive
| ordered_debug_directive
| annotation {$statements_and_directives::methodAnnotations.add($annotation.tree);}
)*
-> registers_directive?
^(I_LABELS label*)
{buildTree(I_PACKED_SWITCH_DECLARATIONS, "I_PACKED_SWITCH_DECLARATIONS", $statements_and_directives::packedSwitchDeclarations)}
{buildTree(I_SPARSE_SWITCH_DECLARATIONS, "I_SPARSE_SWITCH_DECLARATIONS", $statements_and_directives::sparseSwitchDeclarations)}
^(I_STATEMENTS instruction*)
^(I_CATCHES catch_directive* catchall_directive*)
^(I_PARAMETERS parameter_directive*)
^(I_ORDERED_DEBUG_DIRECTIVES ordered_debug_directive*)
{buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", $statements_and_directives::methodAnnotations)};
registers_directive
: (
directive=REGISTERS_DIRECTIVE regCount=integral_literal -> ^(I_REGISTERS[$REGISTERS_DIRECTIVE, "I_REGISTERS"] $regCount)
| directive=LOCALS_DIRECTIVE regCount2=integral_literal -> ^(I_LOCALS[$LOCALS_DIRECTIVE, "I_LOCALS"] $regCount2)
)
{
if ($statements_and_directives::hasRegistersDirective) {
throw new SemanticException(input, $directive, "There can only be a single .registers or .locals directive in a method");
}
$statements_and_directives::hasRegistersDirective=true;
};
/*identifiers are much more general than most languages. Any of the below can either be
the indicated type OR an identifier, depending on the context*/
simple_name
: SIMPLE_NAME
| ACCESS_SPEC -> SIMPLE_NAME[$ACCESS_SPEC]
| VERIFICATION_ERROR_TYPE -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE]
| POSITIVE_INTEGER_LITERAL -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL]
| NEGATIVE_INTEGER_LITERAL -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL]
| FLOAT_LITERAL_OR_ID -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID]
| DOUBLE_LITERAL_OR_ID -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID]
| BOOL_LITERAL -> SIMPLE_NAME[$BOOL_LITERAL]
| NULL_LITERAL -> SIMPLE_NAME[$NULL_LITERAL]
| REGISTER -> SIMPLE_NAME[$REGISTER]
| PARAM_LIST_OR_ID -> SIMPLE_NAME[$PARAM_LIST_OR_ID]
| PRIMITIVE_TYPE -> SIMPLE_NAME[$PRIMITIVE_TYPE]
| VOID_TYPE -> SIMPLE_NAME[$VOID_TYPE]
| ANNOTATION_VISIBILITY -> SIMPLE_NAME[$ANNOTATION_VISIBILITY]
| INSTRUCTION_FORMAT10t -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t]
| INSTRUCTION_FORMAT10x -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x]
| INSTRUCTION_FORMAT10x_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX]
| INSTRUCTION_FORMAT11x -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x]
| INSTRUCTION_FORMAT12x_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID]
| INSTRUCTION_FORMAT21c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD]
| INSTRUCTION_FORMAT21c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX]
| INSTRUCTION_FORMAT21c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING]
| INSTRUCTION_FORMAT21c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE]
| INSTRUCTION_FORMAT21t -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t]
| INSTRUCTION_FORMAT22c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD]
| INSTRUCTION_FORMAT22c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX]
| INSTRUCTION_FORMAT22c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE]
| INSTRUCTION_FORMAT22cs_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD]
| INSTRUCTION_FORMAT22s_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID]
| INSTRUCTION_FORMAT22t -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t]
| INSTRUCTION_FORMAT23x -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x]
| INSTRUCTION_FORMAT31i_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID]
| INSTRUCTION_FORMAT31t -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t]
| INSTRUCTION_FORMAT35c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD]
| INSTRUCTION_FORMAT35c_METHOD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX]
| INSTRUCTION_FORMAT35c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE]
| INSTRUCTION_FORMAT35mi_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD]
| INSTRUCTION_FORMAT35ms_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD]
| INSTRUCTION_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l];
method_name
: simple_name
| METHOD_NAME -> SIMPLE_NAME[$METHOD_NAME];
method_prototype
: OPEN_PAREN param_list CLOSE_PAREN type_descriptor
-> ^(I_METHOD_PROTOTYPE[$start, "I_METHOD_PROTOTYPE"] ^(I_METHOD_RETURN_TYPE type_descriptor) param_list?);
param_list
: PARAM_LIST -> { parseParamList((CommonToken)$PARAM_LIST) }
| PARAM_LIST_OR_ID -> { parseParamList((CommonToken)$PARAM_LIST_OR_ID) }
| nonvoid_type_descriptor*;
type_descriptor
: VOID_TYPE
| PRIMITIVE_TYPE
| CLASS_DESCRIPTOR
| ARRAY_DESCRIPTOR;
nonvoid_type_descriptor
: PRIMITIVE_TYPE
| CLASS_DESCRIPTOR
| ARRAY_DESCRIPTOR;
reference_type_descriptor
: CLASS_DESCRIPTOR
| ARRAY_DESCRIPTOR;
integer_literal
: POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL]
| NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL];
float_literal
: FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID]
| FLOAT_LITERAL;
double_literal
: DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID]
| DOUBLE_LITERAL;
literal
: LONG_LITERAL
| integer_literal
| SHORT_LITERAL
| BYTE_LITERAL
| float_literal
| double_literal
| CHAR_LITERAL
| STRING_LITERAL
| BOOL_LITERAL
| NULL_LITERAL
| array_literal
| subannotation
| type_field_method_literal
| enum_literal;
integral_literal
: LONG_LITERAL
| integer_literal
| SHORT_LITERAL
| CHAR_LITERAL
| BYTE_LITERAL;
fixed_32bit_literal
: LONG_LITERAL
| integer_literal
| SHORT_LITERAL
| BYTE_LITERAL
| float_literal
| CHAR_LITERAL
| BOOL_LITERAL;
fixed_literal returns[int size]
: integer_literal {$size = 4;}
| LONG_LITERAL {$size = 8;}
| SHORT_LITERAL {$size = 2;}
| BYTE_LITERAL {$size = 1;}
| float_literal {$size = 4;}
| double_literal {$size = 8;}
| CHAR_LITERAL {$size = 2;}
| BOOL_LITERAL {$size = 1;};
array_literal
: OPEN_BRACE (literal (COMMA literal)* | ) CLOSE_BRACE
-> ^(I_ENCODED_ARRAY[$start, "I_ENCODED_ARRAY"] literal*);
annotation_element
: simple_name EQUAL literal
-> ^(I_ANNOTATION_ELEMENT[$start, "I_ANNOTATION_ELEMENT"] simple_name literal);
annotation
: ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR
annotation_element* END_ANNOTATION_DIRECTIVE
-> ^(I_ANNOTATION[$start, "I_ANNOTATION"] ANNOTATION_VISIBILITY ^(I_SUBANNOTATION[$start, "I_SUBANNOTATION"] CLASS_DESCRIPTOR annotation_element*));
subannotation
: SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR annotation_element* END_SUBANNOTATION_DIRECTIVE
-> ^(I_SUBANNOTATION[$start, "I_SUBANNOTATION"] CLASS_DESCRIPTOR annotation_element*);
enum_literal
: ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor
-> ^(I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor);
type_field_method_literal
: reference_type_descriptor
( ARROW
( simple_name COLON nonvoid_type_descriptor -> ^(I_ENCODED_FIELD reference_type_descriptor simple_name nonvoid_type_descriptor)
| method_name method_prototype -> ^(I_ENCODED_METHOD reference_type_descriptor method_name method_prototype)
)
| -> reference_type_descriptor
)
| PRIMITIVE_TYPE
| VOID_TYPE;
fully_qualified_method
: reference_type_descriptor ARROW method_name method_prototype
-> reference_type_descriptor method_name method_prototype;
fully_qualified_field
: reference_type_descriptor ARROW simple_name COLON nonvoid_type_descriptor
-> reference_type_descriptor simple_name nonvoid_type_descriptor;
label
: COLON simple_name -> ^(I_LABEL[$COLON, "I_LABEL"] simple_name I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
label_ref_or_offset
: COLON simple_name -> simple_name
| OFFSET
| NEGATIVE_INTEGER_LITERAL -> OFFSET[$NEGATIVE_INTEGER_LITERAL];
register_list
: REGISTER (COMMA REGISTER)* -> ^(I_REGISTER_LIST[$start, "I_REGISTER_LIST"] REGISTER*)
| ->^(I_REGISTER_LIST[$start, "I_REGISTER_LIST"]);
register_range
: (startreg=REGISTER (DOTDOT endreg=REGISTER)?)? -> ^(I_REGISTER_RANGE[$start, "I_REGISTER_RANGE"] $startreg? $endreg?);
verification_error_reference
: CLASS_DESCRIPTOR | fully_qualified_field | fully_qualified_method;
catch_directive
: CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from=label_ref_or_offset DOTDOT to=label_ref_or_offset CLOSE_BRACE using=label_ref_or_offset
-> ^(I_CATCH[$start, "I_CATCH"] I_ADDRESS[$start, Integer.toString($method::currentAddress)] nonvoid_type_descriptor $from $to $using);
catchall_directive
: CATCHALL_DIRECTIVE OPEN_BRACE from=label_ref_or_offset DOTDOT to=label_ref_or_offset CLOSE_BRACE using=label_ref_or_offset
-> ^(I_CATCHALL[$start, "I_CATCHALL"] I_ADDRESS[$start, Integer.toString($method::currentAddress)] $from $to $using);
/*When there are annotations immediately after a parameter definition, we don't know whether they are parameter annotations
or method annotations until we determine if there is an .end parameter directive. In either case, we still "consume" and parse
the annotations. If it turns out that they are parameter annotations, we include them in the I_PARAMETER AST. Otherwise, we
add them to the $statements_and_directives::methodAnnotations list*/
parameter_directive
@init {List<CommonTree> annotations = new ArrayList<CommonTree>();}
: PARAMETER_DIRECTIVE
STRING_LITERAL?
({input.LA(1) == ANNOTATION_DIRECTIVE}? annotation {annotations.add($annotation.tree);})*
( END_PARAMETER_DIRECTIVE
-> ^(I_PARAMETER[$start, "I_PARAMETER"] STRING_LITERAL? ^(I_ANNOTATIONS annotation*))
| /*epsilon*/ {$statements_and_directives::methodAnnotations.addAll(annotations);}
-> ^(I_PARAMETER[$start, "I_PARAMETER"] STRING_LITERAL? ^(I_ANNOTATIONS))
);
ordered_debug_directive
: line_directive
| local_directive
| end_local_directive
| restart_local_directive
| prologue_directive
| epilogue_directive
| source_directive;
line_directive
: LINE_DIRECTIVE integral_literal
-> ^(I_LINE integral_literal I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
local_directive
: LOCAL_DIRECTIVE REGISTER COMMA simple_name COLON nonvoid_type_descriptor (COMMA STRING_LITERAL)?
-> ^(I_LOCAL[$start, "I_LOCAL"] REGISTER simple_name nonvoid_type_descriptor STRING_LITERAL? I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
end_local_directive
: END_LOCAL_DIRECTIVE REGISTER
-> ^(I_END_LOCAL[$start, "I_END_LOCAL"] REGISTER I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
restart_local_directive
: RESTART_LOCAL_DIRECTIVE REGISTER
-> ^(I_RESTART_LOCAL[$start, "I_RESTART_LOCAL"] REGISTER I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
prologue_directive
: PROLOGUE_DIRECTIVE
-> ^(I_PROLOGUE[$start, "I_PROLOGUE"] I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
epilogue_directive
: EPILOGUE_DIRECTIVE
-> ^(I_EPILOGUE[$start, "I_EPILOGUE"] I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
source_directive
: SOURCE_DIRECTIVE STRING_LITERAL
-> ^(I_SOURCE[$start, "I_SOURCE"] STRING_LITERAL I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
instruction_format12x
: INSTRUCTION_FORMAT12x
| INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID];
instruction_format22s
: INSTRUCTION_FORMAT22s
| INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID];
instruction_format31i
: INSTRUCTION_FORMAT31i
| INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID];
instruction returns [int size]
: insn_format10t { $size = $insn_format10t.size; }
| insn_format10x { $size = $insn_format10x.size; }
| insn_format10x_odex { $size = $insn_format10x_odex.size; }
| insn_format11n { $size = $insn_format11n.size; }
| insn_format11x { $size = $insn_format11x.size; }
| insn_format12x { $size = $insn_format12x.size; }
| insn_format20bc { $size = $insn_format20bc.size; }
| insn_format20t { $size = $insn_format20t.size; }
| insn_format21c_field { $size = $insn_format21c_field.size; }
| insn_format21c_field_odex { $size = $insn_format21c_field_odex.size; }
| insn_format21c_string { $size = $insn_format21c_string.size; }
| insn_format21c_type { $size = $insn_format21c_type.size; }
| insn_format21h { $size = $insn_format21h.size; }
| insn_format21s { $size = $insn_format21s.size; }
| insn_format21t { $size = $insn_format21t.size; }
| insn_format22b { $size = $insn_format22b.size; }
| insn_format22c_field { $size = $insn_format22c_field.size; }
| insn_format22c_field_odex { $size = $insn_format22c_field_odex.size; }
| insn_format22c_type { $size = $insn_format22c_type.size; }
| insn_format22cs_field { $size = $insn_format22cs_field.size; }
| insn_format22s { $size = $insn_format22s.size; }
| insn_format22t { $size = $insn_format22t.size; }
| insn_format22x { $size = $insn_format22x.size; }
| insn_format23x { $size = $insn_format23x.size; }
| insn_format30t { $size = $insn_format30t.size; }
| insn_format31c { $size = $insn_format31c.size; }
| insn_format31i { $size = $insn_format31i.size; }
| insn_format31t { $size = $insn_format31t.size; }
| insn_format32x { $size = $insn_format32x.size; }
| insn_format35c_method { $size = $insn_format35c_method.size; }
| insn_format35c_type { $size = $insn_format35c_type.size; }
| insn_format35c_method_odex { $size = $insn_format35c_method_odex.size; }
| insn_format35mi_method { $size = $insn_format35mi_method.size; }
| insn_format35ms_method { $size = $insn_format35ms_method.size; }
| insn_format3rc_method { $size = $insn_format3rc_method.size; }
| insn_format3rc_method_odex { $size = $insn_format3rc_method_odex.size; }
| insn_format3rc_type { $size = $insn_format3rc_type.size; }
| insn_format3rmi_method { $size = $insn_format3rmi_method.size; }
| insn_format3rms_method { $size = $insn_format3rms_method.size; }
| insn_format41c_type { $size = $insn_format41c_type.size; }
| insn_format41c_field { $size = $insn_format41c_field.size; }
| insn_format41c_field_odex { $size = $insn_format41c_field_odex.size; }
| insn_format51l { $size = $insn_format51l.size; }
| insn_format52c_type { $size = $insn_format52c_type.size; }
| insn_format52c_field { $size = $insn_format52c_field.size; }
| insn_format52c_field_odex { $size = $insn_format52c_field_odex.size; }
| insn_format5rc_method { $size = $insn_format5rc_method.size; }
| insn_format5rc_method_odex { $size = $insn_format5rc_method_odex.size; }
| insn_format5rc_type { $size = $insn_format5rc_type.size; }
| insn_array_data_directive { $size = $insn_array_data_directive.size; }
| insn_packed_switch_directive { $size = $insn_packed_switch_directive.size; }
| insn_sparse_switch_directive { $size = $insn_sparse_switch_directive.size; };
insn_format10t returns [int size]
: //e.g. goto endloop:
//e.g. goto +3
INSTRUCTION_FORMAT10t label_ref_or_offset {$size = Format.Format10t.size;}
-> ^(I_STATEMENT_FORMAT10t[$start, "I_STATEMENT_FORMAT10t"] INSTRUCTION_FORMAT10t label_ref_or_offset);
insn_format10x returns [int size]
: //e.g. return-void
INSTRUCTION_FORMAT10x {$size = Format.Format10x.size;}
-> ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x);
insn_format10x_odex returns [int size]
: //e.g. return-void-barrier
INSTRUCTION_FORMAT10x_ODEX {$size = Format.Format10x.size;}
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT10x_ODEX.text);
};
insn_format11n returns [int size]
: //e.g. const/4 v0, 5
INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal {$size = Format.Format11n.size;}
-> ^(I_STATEMENT_FORMAT11n[$start, "I_STATEMENT_FORMAT11n"] INSTRUCTION_FORMAT11n REGISTER integral_literal);
insn_format11x returns [int size]
: //e.g. move-result-object v1
INSTRUCTION_FORMAT11x REGISTER {$size = Format.Format11x.size;}
-> ^(I_STATEMENT_FORMAT11x[$start, "I_STATEMENT_FORMAT11x"] INSTRUCTION_FORMAT11x REGISTER);
insn_format12x returns [int size]
: //e.g. move v1 v2
instruction_format12x REGISTER COMMA REGISTER {$size = Format.Format12x.size;}
-> ^(I_STATEMENT_FORMAT12x[$start, "I_STATEMENT_FORMAT12x"] instruction_format12x REGISTER REGISTER);
insn_format20bc returns [int size]
: //e.g. throw-verification-error generic-error, Lsome/class;
INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference {$size += Format.Format20bc.size;}
{
if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT20bc.text) == null || apiLevel >= 14) {
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT20bc.text);
}
}
-> ^(I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference);
//TODO: check if dalvik has a jumbo version of throw-verification-error
insn_format20t returns [int size]
: //e.g. goto/16 endloop:
INSTRUCTION_FORMAT20t label_ref_or_offset {$size = Format.Format20t.size;}
-> ^(I_STATEMENT_FORMAT20t[$start, "I_STATEMENT_FORMAT20t"] INSTRUCTION_FORMAT20t label_ref_or_offset);
insn_format21c_field returns [int size]
: //e.g. sget-object v0, java/lang/System/out LJava/io/PrintStream;
INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA fully_qualified_field {$size = Format.Format21c.size;}
-> ^(I_STATEMENT_FORMAT21c_FIELD[$start, "I_STATEMENT_FORMAT21c_FIELD"] INSTRUCTION_FORMAT21c_FIELD REGISTER fully_qualified_field);
insn_format21c_field_odex returns [int size]
: //e.g. sget-object-volatile v0, java/lang/System/out LJava/io/PrintStream;
INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA fully_qualified_field {$size = Format.Format21c.size;}
{
if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_FIELD_ODEX.text) == null || apiLevel >= 14) {
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT21c_FIELD_ODEX.text);
}
}
-> ^(I_STATEMENT_FORMAT21c_FIELD[$start, "I_STATEMENT_FORMAT21c_FIELD"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER fully_qualified_field);
insn_format21c_string returns [int size]
: //e.g. const-string v1, "Hello World!"
INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL {$size = Format.Format21c.size;}
-> ^(I_STATEMENT_FORMAT21c_STRING[$start, "I_STATEMENT_FORMAT21c_STRING"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL);
insn_format21c_type returns [int size]
: //e.g. const-class v2, Lorg/jf/HelloWorld2/HelloWorld2;
INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA reference_type_descriptor {$size = Format.Format21c.size;}
-> ^(I_STATEMENT_FORMAT21c_TYPE[$start, "I_STATEMENT_FORMAT21c"] INSTRUCTION_FORMAT21c_TYPE REGISTER reference_type_descriptor);
insn_format21h returns [int size]
: //e.g. const/high16 v1, 1234
INSTRUCTION_FORMAT21h REGISTER COMMA integral_literal {$size = Format.Format21h.size;}
-> ^(I_STATEMENT_FORMAT21h[$start, "I_STATEMENT_FORMAT21h"] INSTRUCTION_FORMAT21h REGISTER integral_literal);
insn_format21s returns [int size]
: //e.g. const/16 v1, 1234
INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal {$size = Format.Format21s.size;}
-> ^(I_STATEMENT_FORMAT21s[$start, "I_STATEMENT_FORMAT21s"] INSTRUCTION_FORMAT21s REGISTER integral_literal);
insn_format21t returns [int size]
: //e.g. if-eqz v0, endloop:
INSTRUCTION_FORMAT21t REGISTER COMMA (label_ref_or_offset) {$size = Format.Format21t.size;}
-> ^(I_STATEMENT_FORMAT21t[$start, "I_STATEMENT_FORMAT21t"] INSTRUCTION_FORMAT21t REGISTER label_ref_or_offset);
insn_format22b returns [int size]
: //e.g. add-int v0, v1, 123
INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal {$size = Format.Format22b.size;}
-> ^(I_STATEMENT_FORMAT22b[$start, "I_STATEMENT_FORMAT22b"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal);
insn_format22c_field returns [int size]
: //e.g. iput-object v1, v0 org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format22c.size;}
-> ^(I_STATEMENT_FORMAT22c_FIELD[$start, "I_STATEMENT_FORMAT22c_FIELD"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER fully_qualified_field);
insn_format22c_field_odex returns [int size]
: //e.g. iput-object-volatile v1, v0 org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format22c.size;}
{
if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT22c_FIELD_ODEX.text) == null || apiLevel >= 14) {
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT22c_FIELD_ODEX.text);
}
}
-> ^(I_STATEMENT_FORMAT22c_FIELD[$start, "I_STATEMENT_FORMAT22c_FIELD"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER fully_qualified_field);
insn_format22c_type returns [int size]
: //e.g. instance-of v0, v1, Ljava/lang/String;
INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor {$size = Format.Format22c.size;}
-> ^(I_STATEMENT_FORMAT22c_TYPE[$start, "I_STATEMENT_FORMAT22c_TYPE"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor);
insn_format22cs_field returns [int size]
: //e.g. iget-quick v0, v1, field@0xc
INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT22cs_FIELD.text);
};
insn_format22s returns [int size]
: //e.g. add-int/lit16 v0, v1, 12345
instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal {$size = Format.Format22s.size;}
-> ^(I_STATEMENT_FORMAT22s[$start, "I_STATEMENT_FORMAT22s"] instruction_format22s REGISTER REGISTER integral_literal);
insn_format22t returns [int size]
: //e.g. if-eq v0, v1, endloop:
INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref_or_offset {$size = Format.Format22t.size;}
-> ^(I_STATEMENT_FORMAT22t[$start, "I_STATEMENT_FFORMAT22t"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref_or_offset);
insn_format22x returns [int size]
: //e.g. move/from16 v1, v1234
INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER {$size = Format.Format22x.size;}
-> ^(I_STATEMENT_FORMAT22x[$start, "I_STATEMENT_FORMAT22x"] INSTRUCTION_FORMAT22x REGISTER REGISTER);
insn_format23x returns [int size]
: //e.g. add-int v1, v2, v3
INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER {$size = Format.Format23x.size;}
-> ^(I_STATEMENT_FORMAT23x[$start, "I_STATEMENT_FORMAT23x"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER);
insn_format30t returns [int size]
: //e.g. goto/32 endloop:
INSTRUCTION_FORMAT30t label_ref_or_offset {$size = Format.Format30t.size;}
-> ^(I_STATEMENT_FORMAT30t[$start, "I_STATEMENT_FORMAT30t"] INSTRUCTION_FORMAT30t label_ref_or_offset);
insn_format31c returns [int size]
: //e.g. const-string/jumbo v1 "Hello World!"
INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL {$size = Format.Format31c.size;}
->^(I_STATEMENT_FORMAT31c[$start, "I_STATEMENT_FORMAT31c"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL);
insn_format31i returns [int size]
: //e.g. const v0, 123456
instruction_format31i REGISTER COMMA fixed_32bit_literal {$size = Format.Format31i.size;}
-> ^(I_STATEMENT_FORMAT31i[$start, "I_STATEMENT_FORMAT31i"] instruction_format31i REGISTER fixed_32bit_literal);
insn_format31t returns [int size]
: //e.g. fill-array-data v0, ArrayData:
INSTRUCTION_FORMAT31t REGISTER COMMA label_ref_or_offset {$size = Format.Format31t.size;}
{
if ($INSTRUCTION_FORMAT31t.text.equals("packed-switch")) {
CommonTree root = new CommonTree(new CommonToken(I_PACKED_SWITCH_DECLARATION, "I_PACKED_SWITCH_DECLARATION"));
CommonTree address = new CommonTree(new CommonToken(I_ADDRESS, Integer.toString($method::currentAddress)));
root.addChild(address);
root.addChild($label_ref_or_offset.tree.dupNode());
$statements_and_directives::packedSwitchDeclarations.add(root);
} else if ($INSTRUCTION_FORMAT31t.text.equals("sparse-switch")) {
CommonTree root = new CommonTree(new CommonToken(I_SPARSE_SWITCH_DECLARATION, "I_SPARSE_SWITCH_DECLARATION"));
CommonTree address = new CommonTree(new CommonToken(I_ADDRESS, Integer.toString($method::currentAddress)));
root.addChild(address);
root.addChild($label_ref_or_offset.tree.dupNode());
$statements_and_directives::sparseSwitchDeclarations.add(root);
}
}
-> ^(I_STATEMENT_FORMAT31t[$start, "I_STATEMENT_FORMAT31t"] INSTRUCTION_FORMAT31t REGISTER label_ref_or_offset);
insn_format32x returns [int size]
: //e.g. move/16 v4567, v1234
INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER {$size = Format.Format32x.size;}
-> ^(I_STATEMENT_FORMAT32x[$start, "I_STATEMENT_FORMAT32x"] INSTRUCTION_FORMAT32x REGISTER REGISTER);
insn_format35c_method returns [int size]
: //e.g. invoke-virtual {v0,v1} java/io/PrintStream/print(Ljava/lang/Stream;)V
INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format35c.size;}
-> ^(I_STATEMENT_FORMAT35c_METHOD[$start, "I_STATEMENT_FORMAT35c_METHOD"] INSTRUCTION_FORMAT35c_METHOD register_list fully_qualified_method);
insn_format35c_type returns [int size]
: //e.g. filled-new-array {v0,v1}, I
INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor {$size = Format.Format35c.size;}
-> ^(I_STATEMENT_FORMAT35c_TYPE[$start, "I_STATEMENT_FORMAT35c_TYPE"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor);
insn_format35c_method_odex returns [int size]
: //e.g. invoke-direct {p0}, Ljava/lang/Object;-><init>()V
INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35c_METHOD_ODEX.text);
};
insn_format35mi_method returns [int size]
: //e.g. execute-inline {v0, v1}, inline@0x4
INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35mi_METHOD.text);
};
insn_format35ms_method returns [int size]
: //e.g. invoke-virtual-quick {v0, v1}, vtable@0x4
INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35ms_METHOD.text);
};
insn_format3rc_method returns [int size]
: //e.g. invoke-virtual/range {v25..v26}, java/lang/StringBuilder/append(Ljava/lang/String;)Ljava/lang/StringBuilder;
INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format3rc.size;}
-> ^(I_STATEMENT_FORMAT3rc_METHOD[$start, "I_STATEMENT_FORMAT3rc_METHOD"] INSTRUCTION_FORMAT3rc_METHOD register_range fully_qualified_method);
insn_format3rc_method_odex returns [int size]
: //e.g. invoke-object-init/range {p0}, Ljava/lang/Object;-><init>()V
INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rc_METHOD_ODEX.text);
};
insn_format3rc_type returns [int size]
: //e.g. filled-new-array/range {v0..v6}, I
INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor {$size = Format.Format3rc.size;}
-> ^(I_STATEMENT_FORMAT3rc_TYPE[$start, "I_STATEMENT_FORMAT3rc_TYPE"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor);
insn_format3rmi_method returns [int size]
: //e.g. execute-inline/range {v0 .. v10}, inline@0x14
INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rmi_METHOD.text);
};
insn_format3rms_method returns [int size]
: //e.g. invoke-virtual-quick/range {v0 .. v10}, vtable@0x14
INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rms_METHOD.text);
};
insn_format41c_type returns [int size]
: //e.g. const-class/jumbo v2, Lorg/jf/HelloWorld2/HelloWorld2;
INSTRUCTION_FORMAT41c_TYPE REGISTER COMMA reference_type_descriptor {$size = Format.Format41c.size;}
-> ^(I_STATEMENT_FORMAT41c_TYPE[$start, "I_STATEMENT_FORMAT41c"] INSTRUCTION_FORMAT41c_TYPE REGISTER reference_type_descriptor);
insn_format41c_field returns [int size]
: //e.g. sget-object/jumbo v0, Ljava/lang/System;->out:Ljava/io/PrintStream;
INSTRUCTION_FORMAT41c_FIELD REGISTER COMMA fully_qualified_field {$size = Format.Format41c.size;}
-> ^(I_STATEMENT_FORMAT41c_FIELD[$start, "I_STATEMENT_FORMAT41c_FIELD"] INSTRUCTION_FORMAT41c_FIELD REGISTER fully_qualified_field);
insn_format41c_field_odex returns [int size]
: //e.g. sget-object-volatile/jumbo v0, Ljava/lang/System;->out:Ljava/io/PrintStream;
INSTRUCTION_FORMAT41c_FIELD_ODEX REGISTER COMMA fully_qualified_field {$size = Format.Format41c.size;}
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT41c_FIELD_ODEX.text);
};
insn_format51l returns [int size]
: //e.g. const-wide v0, 5000000000L
INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal {$size = Format.Format51l.size;}
-> ^(I_STATEMENT_FORMAT51l[$start, "I_STATEMENT_FORMAT51l"] INSTRUCTION_FORMAT51l REGISTER fixed_literal);
insn_format52c_type returns [int size]
: //e.g. instance-of/jumbo v0, v1, Ljava/lang/String;
INSTRUCTION_FORMAT52c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor {$size = Format.Format52c.size;}
-> ^(I_STATEMENT_FORMAT52c_TYPE[$start, "I_STATEMENT_FORMAT52c_TYPE"] INSTRUCTION_FORMAT52c_TYPE REGISTER REGISTER nonvoid_type_descriptor);
insn_format52c_field returns [int size]
: //e.g. iput-object/jumbo v1, v0 Lorg/jf/HelloWorld2/HelloWorld2;->helloWorld:Ljava/lang/String;
INSTRUCTION_FORMAT52c_FIELD REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format52c.size;}
-> ^(I_STATEMENT_FORMAT52c_FIELD[$start, "I_STATEMENT_FORMAT52c_FIELD"] INSTRUCTION_FORMAT52c_FIELD REGISTER REGISTER fully_qualified_field);
insn_format52c_field_odex returns [int size]
: //e.g. iput-object-volatile/jumbo v1, v0 Lorg/jf/HelloWorld2/HelloWorld2;->helloWorld:Ljava/lang/String;
INSTRUCTION_FORMAT52c_FIELD_ODEX REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format52c.size;}
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT52c_FIELD_ODEX.text);
};
insn_format5rc_method returns [int size]
: //e.g. invoke-virtual/jumbo {v25..v26}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
INSTRUCTION_FORMAT5rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format5rc.size;}
-> ^(I_STATEMENT_FORMAT5rc_METHOD[$start, "I_STATEMENT_FORMAT5rc_METHOD"] INSTRUCTION_FORMAT5rc_METHOD register_range fully_qualified_method);
insn_format5rc_method_odex returns [int size]
: //e.g. invoke-object-init/jumbo {v25}, Ljava/lang/Object-><init>()V
INSTRUCTION_FORMAT5rc_METHOD_ODEX OPEN_BRACE register_range CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format5rc.size;}
{
throwOdexedInstructionException(input, $INSTRUCTION_FORMAT5rc_METHOD_ODEX.text);
};
insn_format5rc_type returns [int size]
: //e.g. filled-new-array/jumbo {v0..v6}, I
INSTRUCTION_FORMAT5rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor {$size = Format.Format5rc.size;}
-> ^(I_STATEMENT_FORMAT5rc_TYPE[$start, "I_STATEMENT_FORMAT5rc_TYPE"] INSTRUCTION_FORMAT5rc_TYPE register_range nonvoid_type_descriptor);
insn_array_data_directive returns [int size]
@init {boolean needsNop = false;}
: ARRAY_DATA_DIRECTIVE
{
if (($method::currentAddress \% 2) != 0) {
needsNop = true;
$size = 2;
} else {
$size = 0;
}
}
integral_literal (fixed_literal {$size+=$fixed_literal.size;})* END_ARRAY_DATA_DIRECTIVE
{$size = (($size + 1)/2)*2 + 8;}
/*add a nop statement before this if needed to force the correct alignment*/
-> {needsNop}? ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
^(I_STATEMENT_ARRAY_DATA ^(I_ARRAY_ELEMENT_SIZE integral_literal) ^(I_ARRAY_ELEMENTS fixed_literal*))
-> ^(I_STATEMENT_ARRAY_DATA[$start, "I_STATEMENT_ARRAY_DATA"] ^(I_ARRAY_ELEMENT_SIZE integral_literal)
^(I_ARRAY_ELEMENTS fixed_literal*));
insn_packed_switch_directive returns [int size]
@init {boolean needsNop = false; int targetCount = 0;}
: PACKED_SWITCH_DIRECTIVE
{
targetCount = 0;
if (($method::currentAddress \% 2) != 0) {
needsNop = true;
$size = 2;
} else {
$size = 0;
}
}
fixed_32bit_literal
(switch_target += label_ref_or_offset {$size+=4; targetCount++;})*
END_PACKED_SWITCH_DIRECTIVE {$size = $size + 8;}
/*add a nop statement before this if needed to force the correct alignment*/
-> {needsNop}? ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
^(I_STATEMENT_PACKED_SWITCH[$start, "I_STATEMENT_PACKED_SWITCH"]
^(I_PACKED_SWITCH_START_KEY[$start, "I_PACKED_SWITCH_START_KEY"] fixed_32bit_literal)
^(I_PACKED_SWITCH_TARGETS[$start, "I_PACKED_SWITCH_TARGETS"]
I_PACKED_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)] $switch_target*)
)
-> ^(I_STATEMENT_PACKED_SWITCH[$start, "I_STATEMENT_PACKED_SWITCH"]
^(I_PACKED_SWITCH_START_KEY[$start, "I_PACKED_SWITCH_START_KEY"] fixed_32bit_literal)
^(I_PACKED_SWITCH_TARGETS[$start, "I_PACKED_SWITCH_TARGETS"]
I_PACKED_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)] $switch_target*)
);
insn_sparse_switch_directive returns [int size]
@init {boolean needsNop = false; int targetCount = 0;}
: SPARSE_SWITCH_DIRECTIVE
{
targetCount = 0;
if (($method::currentAddress \% 2) != 0) {
needsNop = true;
$size = 2;
} else {
$size = 0;
}
}
(fixed_32bit_literal ARROW switch_target += label_ref_or_offset {$size += 8; targetCount++;})*
END_SPARSE_SWITCH_DIRECTIVE {$size = $size + 4;}
/*add a nop statement before this if needed to force the correct alignment*/
-> {needsNop}?
^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
^(I_STATEMENT_SPARSE_SWITCH[$start, "I_STATEMENT_SPARSE_SWITCH"]
I_SPARSE_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)]
^(I_SPARSE_SWITCH_KEYS[$start, "I_SPARSE_SWITCH_KEYS"] fixed_32bit_literal*)
^(I_SPARSE_SWITCH_TARGETS $switch_target*)
)
-> ^(I_STATEMENT_SPARSE_SWITCH[$start, "I_STATEMENT_SPARSE_SWITCH"]
I_SPARSE_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)]
^(I_SPARSE_SWITCH_KEYS[$start, "I_SPARSE_SWITCH_KEYS"] fixed_32bit_literal*)
^(I_SPARSE_SWITCH_TARGETS $switch_target*));
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/antlr3/smaliParser.g
|
GAP
|
asf20
| 51,267
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.smali;
import org.antlr.runtime.IntStream;
import org.antlr.runtime.RecognitionException;
public class OdexedInstructionException extends RecognitionException {
private String odexedInstruction;
OdexedInstructionException(IntStream input, String odexedInstruction) {
super(input);
this.odexedInstruction = odexedInstruction;
}
public String getMessage() {
return odexedInstruction + " is an odexed instruction. You cannot reassemble a disassembled odex file " +
"unless it has been deodexed.";
}
}
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/java/org/jf/smali/OdexedInstructionException.java
|
Java
|
asf20
| 2,079
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.smali;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class LiteralTools
{
public static byte parseByte(String byteLiteral)
throws NumberFormatException {
if (byteLiteral == null) {
throw new NumberFormatException("string is null");
}
if (byteLiteral.length() == 0) {
throw new NumberFormatException("string is blank");
}
char[] byteChars;
if (byteLiteral.toUpperCase().endsWith("T")) {
byteChars = byteLiteral.substring(0, byteLiteral.length()-1).toCharArray();
} else {
byteChars = byteLiteral.toCharArray();
}
int position = 0;
int radix = 10;
boolean negative = false;
if (byteChars[position] == '-') {
position++;
negative = true;
}
if (byteChars[position] == '0') {
position++;
if (position == byteChars.length) {
return 0;
} else if (byteChars[position] == 'x' || byteChars[position] == 'X') {
radix = 16;
position++;
} else if (Character.digit(byteChars[position], 8) >= 0) {
radix = 8;
}
}
byte result = 0;
byte shiftedResult;
int digit;
byte maxValue = (byte)(Byte.MAX_VALUE / (radix / 2));
while (position < byteChars.length) {
digit = Character.digit(byteChars[position], radix);
if (digit < 0) {
throw new NumberFormatException("The string contains invalid an digit - '" + byteChars[position] + "'");
}
shiftedResult = (byte)(result * radix);
if (result > maxValue) {
throw new NumberFormatException(byteLiteral + " cannot fit into a byte");
}
if (shiftedResult < 0 && shiftedResult >= -digit) {
throw new NumberFormatException(byteLiteral + " cannot fit into a byte");
}
result = (byte)(shiftedResult + digit);
position++;
}
if (negative) {
//allow -0x80, which is = 0x80
if (result == Byte.MIN_VALUE) {
return result;
} else if (result < 0) {
throw new NumberFormatException(byteLiteral + " cannot fit into a byte");
}
return (byte)(result * -1);
} else {
return result;
}
}
public static short parseShort(String shortLiteral)
throws NumberFormatException {
if (shortLiteral == null) {
throw new NumberFormatException("string is null");
}
if (shortLiteral.length() == 0) {
throw new NumberFormatException("string is blank");
}
char[] shortChars;
if (shortLiteral.toUpperCase().endsWith("S")) {
shortChars = shortLiteral.substring(0, shortLiteral.length()-1).toCharArray();
} else {
shortChars = shortLiteral.toCharArray();
}
int position = 0;
int radix = 10;
boolean negative = false;
if (shortChars[position] == '-') {
position++;
negative = true;
}
if (shortChars[position] == '0') {
position++;
if (position == shortChars.length) {
return 0;
} else if (shortChars[position] == 'x' || shortChars[position] == 'X') {
radix = 16;
position++;
} else if (Character.digit(shortChars[position], 8) >= 0) {
radix = 8;
}
}
short result = 0;
short shiftedResult;
int digit;
short maxValue = (short)(Short.MAX_VALUE / (radix / 2));
while (position < shortChars.length) {
digit = Character.digit(shortChars[position], radix);
if (digit < 0) {
throw new NumberFormatException("The string contains invalid an digit - '" + shortChars[position] + "'");
}
shiftedResult = (short)(result * radix);
if (result > maxValue) {
throw new NumberFormatException(shortLiteral + " cannot fit into a short");
}
if (shiftedResult < 0 && shiftedResult >= -digit) {
throw new NumberFormatException(shortLiteral + " cannot fit into a short");
}
result = (short)(shiftedResult + digit);
position++;
}
if (negative) {
//allow -0x8000, which is = 0x8000
if (result == Short.MIN_VALUE) {
return result;
} else if (result < 0) {
throw new NumberFormatException(shortLiteral + " cannot fit into a short");
}
return (short)(result * -1);
} else {
return result;
}
}
public static int parseInt(String intLiteral)
throws NumberFormatException {
if (intLiteral == null) {
throw new NumberFormatException("string is null");
}
if (intLiteral.length() == 0) {
throw new NumberFormatException("string is blank");
}
char[] intChars = intLiteral.toCharArray();
int position = 0;
int radix = 10;
boolean negative = false;
if (intChars[position] == '-') {
position++;
negative = true;
}
if (intChars[position] == '0') {
position++;
if (position == intChars.length) {
return 0;
} else if (intChars[position] == 'x' || intChars[position] == 'X') {
radix = 16;
position++;
} else if (Character.digit(intChars[position], 8) >= 0) {
radix = 8;
}
}
int result = 0;
int shiftedResult;
int digit;
int maxValue = Integer.MAX_VALUE / (radix / 2);
while (position < intChars.length) {
digit = Character.digit(intChars[position], radix);
if (digit < 0) {
throw new NumberFormatException("The string contains an invalid digit - '" + intChars[position] + "'");
}
shiftedResult = result * radix;
if (result > maxValue) {
throw new NumberFormatException(intLiteral + " cannot fit into an int");
}
if (shiftedResult < 0 && shiftedResult >= -digit) {
throw new NumberFormatException(intLiteral + " cannot fit into an int");
}
result = shiftedResult + digit;
position++;
}
if (negative) {
//allow -0x80000000, which is = 0x80000000
if (result == Integer.MIN_VALUE) {
return result;
} else if (result < 0) {
throw new NumberFormatException(intLiteral + " cannot fit into an int");
}
return result * -1;
} else {
return result;
}
}
public static long parseLong(String longLiteral)
throws NumberFormatException {
if (longLiteral == null) {
throw new NumberFormatException("string is null");
}
if (longLiteral.length() == 0) {
throw new NumberFormatException("string is blank");
}
char[] longChars;
if (longLiteral.toUpperCase().endsWith("L")) {
longChars = longLiteral.substring(0, longLiteral.length()-1).toCharArray();
} else {
longChars = longLiteral.toCharArray();
}
int position = 0;
int radix = 10;
boolean negative = false;
if (longChars[position] == '-') {
position++;
negative = true;
}
if (longChars[position] == '0') {
position++;
if (position == longChars.length) {
return 0;
} else if (longChars[position] == 'x' || longChars[position] == 'X') {
radix = 16;
position++;
} else if (Character.digit(longChars[position], 8) >= 0) {
radix = 8;
}
}
long result = 0;
long shiftedResult;
int digit;
long maxValue = Long.MAX_VALUE / (radix / 2);
while (position < longChars.length) {
digit = Character.digit(longChars[position], radix);
if (digit < 0) {
throw new NumberFormatException("The string contains an invalid digit - '" + longChars[position] + "'");
}
shiftedResult = result * radix;
if (result > maxValue) {
throw new NumberFormatException(longLiteral + " cannot fit into a long");
}
if (shiftedResult < 0 && shiftedResult >= -digit) {
throw new NumberFormatException(longLiteral + " cannot fit into a long");
}
result = shiftedResult + digit;
position++;
}
if (negative) {
//allow -0x8000000000000000, which is = 0x8000000000000000
if (result == Long.MIN_VALUE) {
return result;
} else if (result < 0) {
throw new NumberFormatException(longLiteral + " cannot fit into a long");
}
return result * -1;
} else {
return result;
}
}
private static Pattern specialFloatRegex = Pattern.compile("((-)?infinityf)|(nanf)", Pattern.CASE_INSENSITIVE);
public static float parseFloat(String floatString) {
Matcher m = specialFloatRegex.matcher(floatString);
if (m.matches()) {
//got an infinity
if (m.start(1) != -1) {
if (m.start(2) != -1) {
return Float.NEGATIVE_INFINITY;
} else {
return Float.POSITIVE_INFINITY;
}
} else {
return Float.NaN;
}
}
return Float.parseFloat(floatString);
}
private static Pattern specialDoubleRegex = Pattern.compile("((-)?infinityd?)|(nand?)", Pattern.CASE_INSENSITIVE);
public static double parseDouble(String doubleString) {
Matcher m = specialDoubleRegex.matcher(doubleString);
if (m.matches()) {
//got an infinity
if (m.start(1) != -1) {
if (m.start(2) != -1) {
return Double.NEGATIVE_INFINITY;
} else {
return Double.POSITIVE_INFINITY;
}
} else {
return Double.NaN;
}
}
return Double.parseDouble(doubleString);
}
public static byte[] longToBytes(long value) {
byte[] bytes = new byte[8];
for (int i=0; value != 0; i++) {
bytes[i] = (byte)value;
value = value >>> 8;
}
return bytes;
}
public static byte[] intToBytes(int value) {
byte[] bytes = new byte[4];
for (int i=0; value != 0; i++) {
bytes[i] = (byte)value;
value = value >>> 8;
}
return bytes;
}
public static byte[] shortToBytes(short value) {
byte[] bytes = new byte[2];
bytes[0] = (byte)value;
bytes[1] = (byte)(value >>> 8);
return bytes;
}
public static byte[] floatToBytes(float value) {
return intToBytes(Float.floatToRawIntBits(value));
}
public static byte[] doubleToBytes(double value) {
return longToBytes(Double.doubleToRawLongBits(value));
}
public static byte[] charToBytes(char value) {
return shortToBytes((short)value);
}
public static byte[] boolToBytes(boolean value) {
if (value) {
return new byte[] { 0x01 };
} else {
return new byte[] { 0x00 };
}
}
public static void checkInt(long value) {
if (value > 0xFFFFFFFF || value < -0x80000000) {
throw new NumberFormatException(Long.toString(value) + " cannot fit into an int");
}
}
public static void checkShort(long value) {
if (value > 0xFFFF | value < -0x8000) {
throw new NumberFormatException(Long.toString(value) + " cannot fit into a short");
}
}
public static void checkByte(long value) {
if (value > 0xFF | value < -0x80) {
throw new NumberFormatException(Long.toString(value) + " cannot fit into a byte");
}
}
public static void checkNibble(long value) {
if (value > 0x0F | value < -0x08) {
throw new NumberFormatException(Long.toString(value) + " cannot fit into a nibble");
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/java/org/jf/smali/LiteralTools.java
|
Java
|
asf20
| 14,369
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.smali;
import org.antlr.runtime.CommonToken;
import org.antlr.runtime.IntStream;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.Token;
import org.antlr.runtime.tree.CommonTree;
public class SemanticException extends RecognitionException {
private String errorMessage;
SemanticException(IntStream input, String errorMessage, Object... messageArguments) {
super(input);
this.errorMessage = String.format(errorMessage, messageArguments);
}
SemanticException(IntStream input, Exception ex) {
super(input);
this.errorMessage = ex.getMessage();
}
SemanticException(IntStream input, CommonTree tree, String errorMessage, Object... messageArguments) {
super();
this.input = input;
this.token = tree.getToken();
this.index = tree.getTokenStartIndex();
this.line = token.getLine();
this.charPositionInLine = token.getCharPositionInLine();
this.errorMessage = String.format(errorMessage, messageArguments);
}
SemanticException(IntStream input, Token token, String errorMessage, Object... messageArguments) {
super();
this.input = input;
this.token = token;
this.index = ((CommonToken)token).getStartIndex();
this.line = token.getLine();
this.charPositionInLine = token.getCharPositionInLine();
this.errorMessage = String.format(errorMessage, messageArguments);
}
public String getMessage() {
return errorMessage;
}
}
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/java/org/jf/smali/SemanticException.java
|
Java
|
asf20
| 3,046
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.smali;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.CommonTree;
import org.antlr.runtime.tree.CommonTreeNodeStream;
import org.apache.commons.cli.*;
import org.jf.dexlib.Code.Opcode;
import org.jf.dexlib.CodeItem;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.Util.ByteArrayAnnotatedOutput;
import org.jf.util.ConsoleUtil;
import org.jf.util.SmaliHelpFormatter;
import java.io.*;
import java.util.LinkedHashSet;
import java.util.Locale;
import java.util.Properties;
import java.util.Set;
/**
* Main class for smali. It recognizes enough options to be able to dispatch
* to the right "actual" main.
*/
public class main {
public static final String VERSION;
private final static Options basicOptions;
private final static Options debugOptions;
private final static Options options;
static {
basicOptions = new Options();
debugOptions = new Options();
options = new Options();
buildOptions();
InputStream templateStream = main.class.getClassLoader().getResourceAsStream("smali.properties");
Properties properties = new Properties();
String version = "(unknown)";
try {
properties.load(templateStream);
version = properties.getProperty("application.version");
} catch (IOException ex) {
}
VERSION = version;
}
/**
* This class is uninstantiable.
*/
private main() {
}
/**
* Run!
*/
public static void main(String[] args) {
Locale locale = new Locale("en", "US");
Locale.setDefault(locale);
CommandLineParser parser = new PosixParser();
CommandLine commandLine;
try {
commandLine = parser.parse(options, args);
} catch (ParseException ex) {
usage();
return;
}
boolean allowOdex = false;
boolean sort = false;
boolean jumboInstructions = false;
boolean fixGoto = true;
boolean verboseErrors = false;
boolean printTokens = false;
boolean apiSet = false;
int apiLevel = 14;
String outputDexFile = "out.dex";
String dumpFileName = null;
String[] remainingArgs = commandLine.getArgs();
Option[] options = commandLine.getOptions();
for (int i=0; i<options.length; i++) {
Option option = options[i];
String opt = option.getOpt();
switch (opt.charAt(0)) {
case 'v':
version();
return;
case '?':
while (++i < options.length) {
if (options[i].getOpt().charAt(0) == '?') {
usage(true);
return;
}
}
usage(false);
return;
case 'o':
outputDexFile = commandLine.getOptionValue("o");
break;
case 'x':
allowOdex = true;
break;
case 'a':
apiLevel = Integer.parseInt(commandLine.getOptionValue("a"));
apiSet = true;
break;
case 'D':
dumpFileName = commandLine.getOptionValue("D", outputDexFile + ".dump");
break;
case 'S':
sort = true;
break;
case 'J':
jumboInstructions = true;
break;
case 'G':
fixGoto = false;
break;
case 'V':
verboseErrors = true;
break;
case 'T':
printTokens = true;
break;
default:
assert false;
}
}
if (remainingArgs.length == 0) {
usage();
return;
}
try {
LinkedHashSet<File> filesToProcess = new LinkedHashSet<File>();
for (String arg: remainingArgs) {
File argFile = new File(arg);
if (!argFile.exists()) {
throw new RuntimeException("Cannot find file or directory \"" + arg + "\"");
}
if (argFile.isDirectory()) {
getSmaliFilesInDir(argFile, filesToProcess);
} else if (argFile.isFile()) {
filesToProcess.add(argFile);
}
}
Opcode.updateMapsForApiLevel(apiLevel, jumboInstructions);
DexFile dexFile = new DexFile();
if (apiSet && apiLevel >= 14) {
dexFile.HeaderItem.setVersion(36);
}
boolean errors = false;
for (File file: filesToProcess) {
if (!assembleSmaliFile(file, dexFile, verboseErrors, printTokens, allowOdex, apiLevel)) {
errors = true;
}
}
if (errors) {
System.exit(1);
}
if (sort) {
dexFile.setSortAllItems(true);
}
if (fixGoto) {
fixInstructions(dexFile, true, fixGoto);
}
dexFile.place();
ByteArrayAnnotatedOutput out = new ByteArrayAnnotatedOutput();
if (dumpFileName != null) {
out.enableAnnotations(120, true);
}
dexFile.writeTo(out);
byte[] bytes = out.toByteArray();
DexFile.calcSignature(bytes);
DexFile.calcChecksum(bytes);
if (dumpFileName != null) {
out.finishAnnotating();
FileWriter fileWriter = new FileWriter(dumpFileName);
out.writeAnnotationsTo(fileWriter);
fileWriter.close();
}
FileOutputStream fileOutputStream = new FileOutputStream(outputDexFile);
fileOutputStream.write(bytes);
fileOutputStream.close();
} catch (RuntimeException ex) {
System.err.println("\nUNEXPECTED TOP-LEVEL EXCEPTION:");
ex.printStackTrace();
System.exit(2);
} catch (Throwable ex) {
System.err.println("\nUNEXPECTED TOP-LEVEL ERROR:");
ex.printStackTrace();
System.exit(3);
}
}
private static void getSmaliFilesInDir(File dir, Set<File> smaliFiles) {
for(File file: dir.listFiles()) {
if (file.isDirectory()) {
getSmaliFilesInDir(file, smaliFiles);
} else if (file.getName().endsWith(".smali")) {
smaliFiles.add(file);
}
}
}
private static void fixInstructions(DexFile dexFile, boolean fixJumbo, boolean fixGoto) {
dexFile.place();
for (CodeItem codeItem: dexFile.CodeItemsSection.getItems()) {
codeItem.fixInstructions(fixJumbo, fixGoto);
}
}
private static boolean assembleSmaliFile(File smaliFile, DexFile dexFile, boolean verboseErrors,
boolean printTokens, boolean allowOdex, int apiLevel)
throws Exception {
CommonTokenStream tokens;
boolean lexerErrors = false;
LexerErrorInterface lexer;
FileInputStream fis = new FileInputStream(smaliFile.getAbsolutePath());
InputStreamReader reader = new InputStreamReader(fis, "UTF-8");
lexer = new smaliFlexLexer(reader);
((smaliFlexLexer)lexer).setSourceFile(smaliFile);
tokens = new CommonTokenStream((TokenSource)lexer);
if (printTokens) {
tokens.getTokens();
for (int i=0; i<tokens.size(); i++) {
Token token = tokens.get(i);
if (token.getChannel() == smaliParser.HIDDEN) {
continue;
}
System.out.println(smaliParser.tokenNames[token.getType()] + ": " + token.getText());
}
}
smaliParser parser = new smaliParser(tokens);
parser.setVerboseErrors(verboseErrors);
parser.setAllowOdex(allowOdex);
parser.setApiLevel(apiLevel);
smaliParser.smali_file_return result = parser.smali_file();
if (parser.getNumberOfSyntaxErrors() > 0 || lexer.getNumberOfSyntaxErrors() > 0) {
return false;
}
CommonTree t = (CommonTree) result.getTree();
CommonTreeNodeStream treeStream = new CommonTreeNodeStream(t);
treeStream.setTokenStream(tokens);
smaliTreeWalker dexGen = new smaliTreeWalker(treeStream);
dexGen.setVerboseErrors(verboseErrors);
dexGen.dexFile = dexFile;
dexGen.smali_file();
if (dexGen.getNumberOfSyntaxErrors() > 0) {
return false;
}
return true;
}
/**
* Prints the usage message.
*/
private static void usage(boolean printDebugOptions) {
SmaliHelpFormatter formatter = new SmaliHelpFormatter();
int consoleWidth = ConsoleUtil.getConsoleWidth();
if (consoleWidth <= 0) {
consoleWidth = 80;
}
formatter.setWidth(consoleWidth);
formatter.printHelp("java -jar smali.jar [options] [--] [<smali-file>|folder]*",
"assembles a set of smali files into a dex file", basicOptions, printDebugOptions?debugOptions:null);
}
private static void usage() {
usage(false);
}
/**
* Prints the version message.
*/
private static void version() {
System.out.println("smali " + VERSION + " (http://smali.googlecode.com)");
System.out.println("Copyright (C) 2010 Ben Gruver (JesusFreke@JesusFreke.com)");
System.out.println("BSD license (http://www.opensource.org/licenses/bsd-license.php)");
System.exit(0);
}
private static void buildOptions() {
Option versionOption = OptionBuilder.withLongOpt("version")
.withDescription("prints the version then exits")
.create("v");
Option helpOption = OptionBuilder.withLongOpt("help")
.withDescription("prints the help message then exits. Specify twice for debug options")
.create("?");
Option outputOption = OptionBuilder.withLongOpt("output")
.withDescription("the name of the dex file that will be written. The default is out.dex")
.hasArg()
.withArgName("FILE")
.create("o");
Option allowOdexOption = OptionBuilder.withLongOpt("allow-odex-instructions")
.withDescription("allow odex instructions to be compiled into the dex file. Only a few" +
" instructions are supported - the ones that can exist in a dead code path and not" +
" cause dalvik to reject the class")
.create("x");
Option apiLevelOption = OptionBuilder.withLongOpt("api-level")
.withDescription("The numeric api-level of the file to generate, e.g. 14 for ICS. If not " +
"specified, it defaults to 14 (ICS).")
.hasArg()
.withArgName("API_LEVEL")
.create("a");
Option dumpOption = OptionBuilder.withLongOpt("dump-to")
.withDescription("additionally writes a dump of written dex file to FILE (<dexfile>.dump by default)")
.hasOptionalArg()
.withArgName("FILE")
.create("D");
Option sortOption = OptionBuilder.withLongOpt("sort")
.withDescription("sort the items in the dex file into a canonical order before writing")
.create("S");
Option jumboInstructionsOption = OptionBuilder.withLongOpt("jumbo-instructions")
.withDescription("adds support for the jumbo opcodes that were temporarily available around the" +
" ics timeframe. Note that support for these opcodes was removed from newer version of" +
" dalvik. You shouldn't use this option unless you know the dex file will only be used on a" +
" device that supports these opcodes.")
.create("J");
Option noFixGotoOption = OptionBuilder.withLongOpt("no-fix-goto")
.withDescription("Don't replace goto type instructions with a larger version where appropriate")
.create("G");
Option verboseErrorsOption = OptionBuilder.withLongOpt("verbose-errors")
.withDescription("Generate verbose error messages")
.create("V");
Option printTokensOption = OptionBuilder.withLongOpt("print-tokens")
.withDescription("Print the name and text of each token")
.create("T");
basicOptions.addOption(versionOption);
basicOptions.addOption(helpOption);
basicOptions.addOption(outputOption);
basicOptions.addOption(allowOdexOption);
basicOptions.addOption(apiLevelOption);
debugOptions.addOption(dumpOption);
debugOptions.addOption(sortOption);
debugOptions.addOption(jumboInstructionsOption);
debugOptions.addOption(noFixGotoOption);
debugOptions.addOption(verboseErrorsOption);
debugOptions.addOption(printTokensOption);
for (Object option: basicOptions.getOptions()) {
options.addOption((Option)option);
}
for (Object option: debugOptions.getOptions()) {
options.addOption((Option)option);
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/java/org/jf/smali/main.java
|
Java
|
asf20
| 15,397
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.smali;
import org.antlr.runtime.CommonToken;
public class InvalidToken extends CommonToken {
private final String message;
public InvalidToken(String message) {
super(smaliParser.INVALID_TOKEN);
this.message = message;
this.channel = smaliParser.ERROR_CHANNEL;
}
public InvalidToken(String message, String text) {
super(smaliParser.INVALID_TOKEN, text);
this.message = message;
this.channel = smaliParser.ERROR_CHANNEL;
}
public String getMessage() {
return message;
}
}
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/java/org/jf/smali/InvalidToken.java
|
Java
|
asf20
| 2,064
|
/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.smali;
import org.antlr.runtime.CharStream;
import org.antlr.runtime.Lexer;
import org.antlr.runtime.RecognizerSharedState;
public interface LexerErrorInterface {
public int getNumberOfSyntaxErrors();
//ANTLR doesn't provide any way to add interfaces to the lexer class directly, so this is an intermediate
//class that implements LexerErrorInterface that we can have the ANTLR parser extend
public abstract static class ANTLRLexerWithErrorInterface extends Lexer implements LexerErrorInterface {
public ANTLRLexerWithErrorInterface() {
}
public ANTLRLexerWithErrorInterface(CharStream input, RecognizerSharedState state) {
super(input, state);
}
}
}
|
zztobat-apktool
|
brut.apktool.smali/smali/src/main/java/org/jf/smali/LexerErrorInterface.java
|
Java
|
asf20
| 2,224
|