diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/AnnotationAdaptor.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/AnnotationAdaptor.java index 5a47d43e..2a0a775b 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/AnnotationAdaptor.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/AnnotationAdaptor.java @@ -31,27 +31,21 @@ package org.jf.baksmali.Adaptors; import org.jf.dexlib.AnnotationItem; import org.jf.baksmali.Adaptors.EncodedValue.AnnotationEncodedValueAdaptor; import org.jf.baksmali.Adaptors.Reference.TypeReference; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; import java.util.List; public class AnnotationAdaptor { - private AnnotationItem annotationItem; - private AnnotationEncodedValueAdaptor encodedAnnotationAdaptor; + public static StringTemplate makeTemplate(StringTemplateGroup stg, AnnotationItem annotationItem) { + StringTemplate template = stg.getInstanceOf("annotation"); - public AnnotationAdaptor(AnnotationItem annotationItem) { - this.annotationItem = annotationItem; - this.encodedAnnotationAdaptor = new AnnotationEncodedValueAdaptor(annotationItem.getEncodedAnnotation()); - } + AnnotationEncodedValueAdaptor aeva = new AnnotationEncodedValueAdaptor(annotationItem.getEncodedAnnotation()); - public String getVisibility() { - return annotationItem.getVisibility().name().toLowerCase(); - } + template.setAttribute("Visibility", annotationItem.getVisibility().name().toLowerCase()); + template.setAttribute("AnnotationType", aeva.getAnnotationType()); + template.setAttribute("Elements", aeva.getElements()); - public TypeReference getAnnotationType() { - return encodedAnnotationAdaptor.getAnnotationType(); - } - - public List getElements() { - return encodedAnnotationAdaptor.getElements(); + return template; } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/BlankMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/BlankMethodItem.java index 3bfd64b8..18d7b0da 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/BlankMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/BlankMethodItem.java @@ -28,17 +28,27 @@ package org.jf.baksmali.Adaptors; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; + //a "spacer" between instructions public class BlankMethodItem extends MethodItem { - public BlankMethodItem(int offset) { + private static StringTemplate template; + + public BlankMethodItem(StringTemplateGroup stg, int offset) { super(offset); + if (template == null) { + template = stg.getInstanceOf("Blank"); + } } - public String getTemplate() { - return "Blank"; - } public int getSortOrder() { return Integer.MAX_VALUE; } + + @Override + public String toString() { + return template.toString(); + } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/CatchMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/CatchMethodItem.java index e2094f6d..9f30b585 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/CatchMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/CatchMethodItem.java @@ -30,43 +30,44 @@ package org.jf.baksmali.Adaptors; import org.jf.dexlib.TypeIdItem; import org.jf.baksmali.Adaptors.Reference.TypeReference; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class CatchMethodItem extends MethodItem { - private TypeIdItem exceptionType; - private int startAddress; - private int endAddress; - private int handlerAddress; + private final StringTemplateGroup stg; + private final TypeIdItem exceptionType; + private final int startAddress; + private final int endAddress; + private final int handlerAddress; - public CatchMethodItem(int offset, TypeIdItem exceptionType, int startAddress, int endAddress, int handlerAddress) { + public CatchMethodItem(int offset, StringTemplateGroup stg, TypeIdItem exceptionType, int startAddress, + int endAddress, int handlerAddress) { super(offset); + this.stg = stg; this.exceptionType = exceptionType; this.startAddress = startAddress; this.endAddress = endAddress; this.handlerAddress = handlerAddress; } - public String getTemplate() { - return "Catch"; - } - public int getSortOrder() { //sort after instruction and end_try label return 102; } - public TypeReference getExceptionType() { - return new TypeReference(exceptionType); + protected String getTemplateName() { + return "Catch"; } - public int getStartAddress() { - return startAddress; - } - - public int getEndAddress() { - return endAddress; - } - - public int getHandlerAddress() { - return handlerAddress; + @Override + public String toString() { + StringTemplate template = stg.getInstanceOf(getTemplateName()); + if (exceptionType != null) { + template.setAttribute("ExceptionType", new TypeReference(exceptionType)); + } + template.setAttribute("StartAddress", Integer.toHexString(startAddress)); + template.setAttribute("EndAddress", Integer.toHexString(endAddress)); + template.setAttribute("HandlerAddress", Integer.toHexString(handlerAddress)); + return template.toString(); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java index 135e706e..e7c241cc 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java @@ -31,10 +31,13 @@ package org.jf.baksmali.Adaptors; import org.jf.dexlib.EncodedValue.EncodedValue; import org.jf.dexlib.*; import org.jf.dexlib.Util.AccessFlags; +import org.antlr.stringtemplate.StringTemplate; +import org.antlr.stringtemplate.StringTemplateGroup; import java.util.*; public class ClassDefinition { + private StringTemplateGroup stg; private ClassDefItem classDefItem; private ClassDataItem classDataItem; @@ -42,7 +45,8 @@ public class ClassDefinition { private HashMap fieldAnnotationsMap = new HashMap(); private HashMap parameterAnnotationsMap = new HashMap(); - public ClassDefinition(ClassDefItem classDefItem) { + public ClassDefinition(StringTemplateGroup stg, ClassDefItem classDefItem) { + this.stg = stg; this.classDefItem = classDefItem; this.classDataItem = classDefItem.getClassData(); buildAnnotationMaps(); @@ -119,11 +123,20 @@ public class ClassDefinition { return interfaces; } - public List getStaticFields() { - List staticFields = new ArrayList(); + public String getHasStaticFields() { + if (classDataItem != null) { + ClassDataItem.EncodedField fields[] = classDataItem.getStaticFields(); + if (fields != null && fields.length > 0) { + return "true"; + } + } + return null; + } + + public List getStaticFields() { + List staticFields = new ArrayList(); if (classDataItem != null) { - EncodedArrayItem encodedStaticInitializers = classDefItem.getStaticFieldInitializers(); EncodedValue[] staticInitializers; @@ -140,55 +153,86 @@ public class ClassDefinition { encodedValue = staticInitializers[i]; } AnnotationSetItem annotationSet = fieldAnnotationsMap.get(field.field.getIndex()); - staticFields.add(new FieldDefinition(field, encodedValue, annotationSet)); + + staticFields.add(FieldDefinition.createTemplate(stg, field, encodedValue, annotationSet)); i++; } } return staticFields; } - public List getInstanceFields() { - List instanceFields = new ArrayList(); + public String getHasInstanceFields() { + if (classDataItem != null) { + ClassDataItem.EncodedField fields[] = classDataItem.getInstanceFields(); + if (fields != null && fields.length > 0) { + return "true"; + } + } + return null; + } + + public List getInstanceFields() { + List instanceFields = new ArrayList(); if (classDataItem != null) { for (ClassDataItem.EncodedField field: classDataItem.getInstanceFields()) { AnnotationSetItem annotationSet = fieldAnnotationsMap.get(field.field.getIndex()); - instanceFields.add(new FieldDefinition(field, annotationSet)); + instanceFields.add(FieldDefinition.createTemplate(stg, field, annotationSet)); } } return instanceFields; } - public List getDirectMethods() { - List directMethods = new ArrayList(); + public String getHasDirectMethods() { + if (classDataItem != null) { + ClassDataItem.EncodedMethod[] methods = classDataItem.getDirectMethods(); + if (methods != null && methods.length > 0) { + return "true"; + } + } + return null; + } + + public List getDirectMethods() { + List directMethods = new ArrayList(); if (classDataItem != null) { for (ClassDataItem.EncodedMethod method: classDataItem.getDirectMethods()) { AnnotationSetItem annotationSet = methodAnnotationsMap.get(method.method.getIndex()); AnnotationSetRefList parameterAnnotationList = parameterAnnotationsMap.get(method.method.getIndex()); - directMethods.add(new MethodDefinition(method, annotationSet, parameterAnnotationList)); + directMethods.add(MethodDefinition.makeTemplate(stg, method, annotationSet, parameterAnnotationList)); } } return directMethods; } - public List getVirtualMethods() { - List virtualMethods = new ArrayList(); + public String getHasVirtualMethods() { + if (classDataItem != null) { + ClassDataItem.EncodedMethod[] methods = classDataItem.getVirtualMethods(); + if (methods != null && methods.length > 0) { + return "true"; + } + } + return null; + } + + public List getVirtualMethods() { + List virtualMethods = new ArrayList(); if (classDataItem != null) { for (ClassDataItem.EncodedMethod method: classDataItem.getVirtualMethods()) { AnnotationSetItem annotationSet = methodAnnotationsMap.get(method.method.getIndex()); AnnotationSetRefList parameterAnnotationList = parameterAnnotationsMap.get(method.method.getIndex()); - virtualMethods.add(new MethodDefinition(method, annotationSet, parameterAnnotationList)); + virtualMethods.add(MethodDefinition.makeTemplate(stg, method, annotationSet, parameterAnnotationList)); } } return virtualMethods; } - public List getAnnotations() { + public List getAnnotations() { AnnotationDirectoryItem annotationDirectory = classDefItem.getAnnotations(); if (annotationDirectory == null) { return null; @@ -199,11 +243,11 @@ public class ClassDefinition { return null; } - List annotationAdaptors = new ArrayList(); + List annotations = new ArrayList(); for (AnnotationItem annotationItem: annotationSet.getAnnotations()) { - annotationAdaptors.add(new AnnotationAdaptor(annotationItem)); + annotations.add(AnnotationAdaptor.makeTemplate(stg, annotationItem)); } - return annotationAdaptors; + return annotations; } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/DebugMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/DebugMethodItem.java index 6c21e1e4..6af19a3b 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/DebugMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/DebugMethodItem.java @@ -28,21 +28,33 @@ package org.jf.baksmali.Adaptors; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; + public class DebugMethodItem extends MethodItem { - private final String template; + private final StringTemplateGroup stg; + private final String templateName; private final int sortOrder; - public DebugMethodItem(int offset, String template, int sortOrder) { + public DebugMethodItem(int offset, StringTemplateGroup stg, String templateName, int sortOrder) { super(offset); - this.template = template; + this.stg = stg; + this.templateName = templateName; this.sortOrder = sortOrder; } - public String getTemplate() { - return template; - } - public int getSortOrder() { return sortOrder; } + + @Override + public String toString() { + StringTemplate template = stg.getInstanceOf(templateName); + setAttributes(template); + return template.toString(); + } + + protected void setAttributes(StringTemplate template) + { + } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/EndTryLabelMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/EndTryLabelMethodItem.java index 31b6ef9f..2298fdde 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/EndTryLabelMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/EndTryLabelMethodItem.java @@ -28,11 +28,13 @@ package org.jf.baksmali.Adaptors; +import org.antlr.stringtemplate.StringTemplateGroup; + public class EndTryLabelMethodItem extends LabelMethodItem { private int labelOffset; - public EndTryLabelMethodItem(int offset, int labelOffset) { - super(offset, "try_end_"); + public EndTryLabelMethodItem(int offset, StringTemplateGroup stg, int labelOffset) { + super(offset, stg, "try_end_"); this.labelOffset = labelOffset; } @@ -41,11 +43,7 @@ public class EndTryLabelMethodItem extends LabelMethodItem { return 101; } - public String getTemplate() { - return "EndTryLabel"; - } - - public int getLabelOffset() { - return labelOffset; + public String getLabelOffset() { + return Integer.toHexString(labelOffset); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/FieldDefinition.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/FieldDefinition.java index 8a00fc15..d93a525c 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/FieldDefinition.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/FieldDefinition.java @@ -31,77 +31,56 @@ package org.jf.baksmali.Adaptors; import org.jf.baksmali.Adaptors.EncodedValue.EncodedValueAdaptor; import org.jf.dexlib.ClassDataItem; import org.jf.dexlib.EncodedValue.EncodedValue; -import org.jf.dexlib.FieldIdItem; import org.jf.dexlib.AnnotationSetItem; import org.jf.dexlib.AnnotationItem; import org.jf.dexlib.Util.AccessFlags; +import org.antlr.stringtemplate.StringTemplate; +import org.antlr.stringtemplate.StringTemplateGroup; import java.util.ArrayList; import java.util.List; public class FieldDefinition { - private ClassDataItem.EncodedField encodedField; - private FieldIdItem fieldIdItem; - private EncodedValue initialValue; - private AnnotationSetItem annotationSet; + public static StringTemplate createTemplate(StringTemplateGroup stg, ClassDataItem.EncodedField encodedField, + EncodedValue initialValue, AnnotationSetItem annotationSet) { + StringTemplate template = stg.getInstanceOf("field"); - public FieldDefinition(ClassDataItem.EncodedField encodedField, AnnotationSetItem annotationSet) { - this(encodedField, null, annotationSet); - } - - public FieldDefinition(ClassDataItem.EncodedField encodedField, EncodedValue initialValue, - AnnotationSetItem annotationSet) { - this.encodedField = encodedField; - this.fieldIdItem = encodedField.field; - this.initialValue = initialValue; - this.annotationSet = annotationSet; - } - - private List accessFlags = null; - public List getAccessFlags() { - if (accessFlags == null) { - accessFlags = new ArrayList(); - - for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForField(encodedField.accessFlags)) { - accessFlags.add(accessFlag.toString()); - } + template.setAttribute("AccessFlags", getAccessFlags(encodedField)); + template.setAttribute("FieldName", encodedField.field.getFieldName().getStringValue()); + template.setAttribute("FieldType", encodedField.field.getFieldType().getTypeDescriptor()); + template.setAttribute("Annotations", getAnnotations(stg, annotationSet)); + + if (initialValue != null) { + template.setAttribute("InitialValue", EncodedValueAdaptor.make(initialValue)); } + + return template; + } + + public static StringTemplate createTemplate(StringTemplateGroup stg, ClassDataItem.EncodedField encodedField, + AnnotationSetItem annotationSet) { + return createTemplate(stg, encodedField, null, annotationSet); + } + + private static List getAccessFlags(ClassDataItem.EncodedField encodedField) { + List accessFlags = new ArrayList(); + + for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForField(encodedField.accessFlags)) { + accessFlags.add(accessFlag.toString()); + } + return accessFlags; } - private String fieldName = null; - public String getFieldName() { - if (fieldName == null) { - fieldName = fieldIdItem.getFieldName().getStringValue(); - } - return fieldName; - } - - private String fieldType = null; - public String getFieldType() { - if (fieldType == null) { - fieldType = fieldIdItem.getFieldType().getTypeDescriptor(); - } - return fieldType; - } - - private EncodedValueAdaptor encodedValueAdaptor = null; - public EncodedValueAdaptor getInitialValue() { - if (encodedValueAdaptor == null && initialValue != null) { - encodedValueAdaptor = EncodedValueAdaptor.make(initialValue); - } - return encodedValueAdaptor; - } - - public List getAnnotations() { + private static List getAnnotations(StringTemplateGroup stg, AnnotationSetItem annotationSet) { if (annotationSet == null) { return null; } - - List annotationAdaptors = new ArrayList(); + + List annotationAdaptors = new ArrayList(); for (AnnotationItem annotationItem: annotationSet.getAnnotations()) { - annotationAdaptors.add(new AnnotationAdaptor(annotationItem)); + annotationAdaptors.add(AnnotationAdaptor.makeTemplate(stg, annotationItem)); } return annotationAdaptors; } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ArrayDataMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ArrayDataMethodItem.java index 12d9aaa8..254184a2 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ArrayDataMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ArrayDataMethodItem.java @@ -30,6 +30,8 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.ArrayDataPseudoInstruction; import org.jf.dexlib.Util.ByteArray; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; import java.util.ArrayList; import java.util.List; @@ -37,33 +39,27 @@ import java.util.Iterator; import java.util.Arrays; public class ArrayDataMethodItem extends InstructionFormatMethodItem { - public ArrayDataMethodItem(int offset, ArrayDataPseudoInstruction instruction) { - super(offset, instruction); + public ArrayDataMethodItem(int offset, StringTemplateGroup stg, ArrayDataPseudoInstruction instruction) { + super(offset, stg, instruction); } - public int getElementWidth() { - return instruction.getElementWidth(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("ElementWidth", instruction.getElementWidth()); + template.setAttribute("Values", getValues()); } - public Iterator getValues() { - return new Iterator() { - int position; - final Iterator iterator = instruction.getElements(); + private List getValues() { + List values = new ArrayList(); + Iterator iterator = instruction.getElements(); - public boolean hasNext() { - return iterator.hasNext(); - } + while (iterator.hasNext()) { + ArrayDataPseudoInstruction.ArrayElement element = iterator.next(); + byte[] array = new byte[element.elementWidth]; + System.arraycopy(element.buffer, element.bufferIndex, array, 0, element.elementWidth); + values.add(new ByteArray(array)); + } - public ByteArray next() { - ArrayDataPseudoInstruction.ArrayElement element = iterator.next(); - byte[] array = new byte[element.elementWidth]; - System.arraycopy(element.buffer, element.bufferIndex, array, 0, element.elementWidth); - return new ByteArray(array); - } - - public void remove() { - } - }; + return values; } public static class ByteArray diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10tMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10tMethodItem.java index 2da08cf1..8b902404 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10tMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10tMethodItem.java @@ -29,13 +29,15 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction10t; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction10tMethodItem extends InstructionFormatMethodItem { - public Instruction10tMethodItem(int offset, Instruction10t instruction) { - super(offset, instruction); + public Instruction10tMethodItem(int offset, StringTemplateGroup stg, Instruction10t instruction) { + super(offset, stg, instruction); } - public String getTarget() { - return Integer.toHexString(getOffset() + instruction.getOffset()); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Target", Integer.toHexString(getOffset() + instruction.getOffset())); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10xMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10xMethodItem.java index 2cd34f40..35c75bcc 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10xMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction10xMethodItem.java @@ -29,9 +29,14 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction10x; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction10xMethodItem extends InstructionFormatMethodItem { - public Instruction10xMethodItem(int offset, Instruction10x instruction) { - super(offset, instruction); + public Instruction10xMethodItem(int offset, StringTemplateGroup stg, Instruction10x instruction) { + super(offset, stg, instruction); + } + + protected void setAttributes(StringTemplate template) { } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11nMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11nMethodItem.java index 935cde02..3e7a22cc 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11nMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11nMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction11n; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction11nMethodItem extends InstructionFormatMethodItem { - public Instruction11nMethodItem(int offset, Instruction11n instruction) { - super(offset, instruction); + public Instruction11nMethodItem(int offset, StringTemplateGroup stg, Instruction11n instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); - } - - public int getLiteral() { - return instruction.getLiteral(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); + template.setAttribute("Literal", instruction.getLiteral()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11xMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11xMethodItem.java index 83d35e6b..d2a77bc0 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11xMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction11xMethodItem.java @@ -29,14 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction11x; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction11xMethodItem extends InstructionFormatMethodItem { - public Instruction11xMethodItem(int offset, Instruction11x instruction) { - super(offset, instruction); + public Instruction11xMethodItem(int offset, StringTemplateGroup stg, Instruction11x instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction12xMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction12xMethodItem.java index caf9b149..3ff9945a 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction12xMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction12xMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction12x; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction12xMethodItem extends InstructionFormatMethodItem { - public Instruction12xMethodItem(int offset, Instruction12x instruction) { - super(offset, instruction); + public Instruction12xMethodItem(int offset, StringTemplateGroup stg, Instruction12x instruction) { + super(offset, stg, instruction); } - - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); + + protected void setAttributes(StringTemplate template) { + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction20tMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction20tMethodItem.java index 3ce50a69..bdb397b5 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction20tMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction20tMethodItem.java @@ -29,13 +29,15 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction20t; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction20tMethodItem extends InstructionFormatMethodItem { - public Instruction20tMethodItem(int offset, Instruction20t instruction) { - super(offset, instruction); + public Instruction20tMethodItem(int offset, StringTemplateGroup stg, Instruction20t instruction) { + super(offset, stg, instruction); } - - public String getTarget() { - return Integer.toHexString(getOffset() + instruction.getOffset()); + + protected void setAttributes(StringTemplate template) { + template.setAttribute("Target", Integer.toHexString(getOffset() + instruction.getOffset())); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21cMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21cMethodItem.java index 758ed40b..18360b20 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21cMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21cMethodItem.java @@ -29,13 +29,17 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction21c; +import org.jf.baksmali.Adaptors.Reference.Reference; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; -public class Instruction21cMethodItem extends ReferenceInstructionFormatMethodItem { - public Instruction21cMethodItem(int offset, Instruction21c instruction) { - super(offset, instruction); +public class Instruction21cMethodItem extends InstructionFormatMethodItem { + public Instruction21cMethodItem(int offset, StringTemplateGroup stg, Instruction21c instruction) { + super(offset, stg, instruction); } - - public int getRegister() { - return instruction.getRegister(); + + protected void setAttributes(StringTemplate template) { + template.setAttribute("Reference", Reference.makeReference(instruction.getReferencedItem())); + template.setAttribute("Register", instruction.getRegister()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21hMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21hMethodItem.java index ef30c324..5dd6d64c 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21hMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21hMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction21h; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction21hMethodItem extends InstructionFormatMethodItem { - public Instruction21hMethodItem(int offset, Instruction21h instruction) { - super(offset, instruction); + public Instruction21hMethodItem(int offset, StringTemplateGroup stg, Instruction21h instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); - } - - public int getLiteral() { - return instruction.getLiteral(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); + template.setAttribute("Literal", instruction.getLiteral()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21sMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21sMethodItem.java index 9eeba7c6..2a12a034 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21sMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21sMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction21s; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction21sMethodItem extends InstructionFormatMethodItem { - public Instruction21sMethodItem(int offset, Instruction21s instruction) { - super(offset, instruction); + public Instruction21sMethodItem(int offset, StringTemplateGroup stg, Instruction21s instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); - } - - public int getLiteral() { - return instruction.getLiteral(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); + template.setAttribute("Literal", instruction.getLiteral()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21tMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21tMethodItem.java index 26672561..d2ebe021 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21tMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction21tMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction21t; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction21tMethodItem extends InstructionFormatMethodItem { - public Instruction21tMethodItem(int offset, Instruction21t instruction) { - super(offset, instruction); + public Instruction21tMethodItem(int offset, StringTemplateGroup stg, Instruction21t instruction) { + super(offset, stg,instruction); } - public int getRegister() { - return instruction.getRegister(); - } - - public String getTarget() { - return Integer.toHexString(getOffset() + instruction.getOffset()); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); + template.setAttribute("Target", Integer.toHexString(getOffset() + instruction.getOffset())); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22bMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22bMethodItem.java index 3399f41a..ceec9061 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22bMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22bMethodItem.java @@ -29,21 +29,17 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction22b; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction22bMethodItem extends InstructionFormatMethodItem { - public Instruction22bMethodItem(int offset, Instruction22b instruction) { - super(offset, instruction); + public Instruction22bMethodItem(int offset, StringTemplateGroup stg, Instruction22b instruction) { + super(offset, stg, instruction); } - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); - } - - public int getLiteral() { - return instruction.getLiteral(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); + template.setAttribute("Literal", instruction.getLiteral()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22cMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22cMethodItem.java index aa44a091..ba215292 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22cMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22cMethodItem.java @@ -29,17 +29,18 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction22c; +import org.jf.baksmali.Adaptors.Reference.Reference; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; -public class Instruction22cMethodItem extends ReferenceInstructionFormatMethodItem { - public Instruction22cMethodItem(int offset, Instruction22c instruction) { - super(offset, instruction); +public class Instruction22cMethodItem extends InstructionFormatMethodItem { + public Instruction22cMethodItem(int offset, StringTemplateGroup stg, Instruction22c instruction) { + super(offset, stg, instruction); } - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Reference", Reference.makeReference(instruction.getReferencedItem())); + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22sMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22sMethodItem.java index 8638736f..5ca10056 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22sMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22sMethodItem.java @@ -29,21 +29,17 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction22s; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction22sMethodItem extends InstructionFormatMethodItem { - public Instruction22sMethodItem(int offset, Instruction22s instruction) { - super(offset, instruction); + public Instruction22sMethodItem(int offset, StringTemplateGroup stg, Instruction22s instruction) { + super(offset, stg, instruction); } - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); - } - - public int getLiteral() { - return instruction.getLiteral(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); + template.setAttribute("Literal", instruction.getLiteral()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22tMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22tMethodItem.java index 3f57987c..e8b764a7 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22tMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22tMethodItem.java @@ -29,21 +29,17 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction22t; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction22tMethodItem extends InstructionFormatMethodItem { - public Instruction22tMethodItem(int offset, Instruction22t instruction) { - super(offset, instruction); + public Instruction22tMethodItem(int offset, StringTemplateGroup stg, Instruction22t instruction) { + super(offset, stg, instruction); } - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); - } - - public String getTarget() { - return Integer.toHexString(getOffset() + instruction.getOffset()); + protected void setAttributes(StringTemplate template) { + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); + template.setAttribute("Target", Integer.toHexString(getOffset() + instruction.getOffset())); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22xMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22xMethodItem.java index 6f48c568..cecd7e53 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22xMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction22xMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction22x; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction22xMethodItem extends InstructionFormatMethodItem { - public Instruction22xMethodItem(int offset, Instruction22x instruction) { - super(offset, instruction); + public Instruction22xMethodItem(int offset, StringTemplateGroup stg, Instruction22x instruction) { + super(offset, stg, instruction); } - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction23xMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction23xMethodItem.java index a4d9ab1e..4fb73f80 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction23xMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction23xMethodItem.java @@ -29,21 +29,17 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction23x; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction23xMethodItem extends InstructionFormatMethodItem { - public Instruction23xMethodItem(int offset, Instruction23x instruction) { - super(offset, instruction); + public Instruction23xMethodItem(int offset, StringTemplateGroup stg, Instruction23x instruction) { + super(offset, stg, instruction); } - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); - } - - public int getRegisterC() { - return instruction.getRegisterC(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); + template.setAttribute("RegisterC", instruction.getRegisterC()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction30tMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction30tMethodItem.java index 76f08555..968197cc 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction30tMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction30tMethodItem.java @@ -29,13 +29,15 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction30t; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction30tMethodItem extends InstructionFormatMethodItem { - public Instruction30tMethodItem(int offset, Instruction30t instruction) { - super(offset, instruction); + public Instruction30tMethodItem(int offset, StringTemplateGroup stg, Instruction30t instruction) { + super(offset, stg, instruction); } - public String getTarget() { - return Integer.toHexString(getOffset() + instruction.getOffset()); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Target", Integer.toHexString(getOffset() + instruction.getOffset())); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31cMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31cMethodItem.java index c6aa771b..e452cbbd 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31cMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31cMethodItem.java @@ -29,13 +29,17 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction31c; +import org.jf.baksmali.Adaptors.Reference.Reference; +import org.antlr.stringtemplate.StringTemplate; +import org.antlr.stringtemplate.StringTemplateGroup; -public class Instruction31cMethodItem extends ReferenceInstructionFormatMethodItem { - public Instruction31cMethodItem(int offset, Instruction31c instruction) { - super(offset, instruction); +public class Instruction31cMethodItem extends InstructionFormatMethodItem { + public Instruction31cMethodItem(int offset, StringTemplateGroup stg, Instruction31c instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Reference", Reference.makeReference(instruction.getReferencedItem())); + template.setAttribute("Register", instruction.getRegister()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31iMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31iMethodItem.java index b7d93e82..054f00fd 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31iMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31iMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction31i; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction31iMethodItem extends InstructionFormatMethodItem { - public Instruction31iMethodItem(int offset, Instruction31i instruction) { - super(offset, instruction); + public Instruction31iMethodItem(int offset, StringTemplateGroup stg, Instruction31i instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); - } - - public int getLiteral() { - return instruction.getLiteral(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); + template.setAttribute("Literal", instruction.getLiteral()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31tMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31tMethodItem.java index fa51e0f5..c15e716d 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31tMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction31tMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction31t; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction31tMethodItem extends InstructionFormatMethodItem { - public Instruction31tMethodItem(int offset, Instruction31t instruction) { - super(offset, instruction); + public Instruction31tMethodItem(int offset, StringTemplateGroup stg, Instruction31t instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); - } - - public String getTarget() { - return Integer.toHexString(getOffset() + instruction.getOffset()); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); + template.setAttribute("Target", Integer.toHexString(getOffset() + instruction.getOffset())); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction32xMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction32xMethodItem.java index 8f1a767f..4b171ce0 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction32xMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction32xMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction32x; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction32xMethodItem extends InstructionFormatMethodItem { - public Instruction32xMethodItem(int offset, Instruction32x instruction) { - super(offset, instruction); + public Instruction32xMethodItem(int offset, StringTemplateGroup stg, Instruction32x instruction) { + super(offset, stg, instruction); } - public int getRegisterA() { - return instruction.getRegisterA(); - } - - public int getRegisterB() { - return instruction.getRegisterB(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("RegisterA", instruction.getRegisterA()); + template.setAttribute("RegisterB", instruction.getRegisterB()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction35cMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction35cMethodItem.java index 228ab983..bfb836d5 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction35cMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction35cMethodItem.java @@ -29,13 +29,21 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction35c; +import org.jf.baksmali.Adaptors.Reference.Reference; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; -public class Instruction35cMethodItem extends ReferenceInstructionFormatMethodItem { - public Instruction35cMethodItem(int offset, Instruction35c instruction) { - super(offset, instruction); +public class Instruction35cMethodItem extends InstructionFormatMethodItem { + public Instruction35cMethodItem(int offset, StringTemplateGroup stg, Instruction35c instruction) { + super(offset, stg, instruction); } - public int[] getRegisters() { + protected void setAttributes(StringTemplate template) { + template.setAttribute("Reference", Reference.makeReference(instruction.getReferencedItem())); + template.setAttribute("Registers", getRegisters()); + } + + private int[] getRegisters() { switch (instruction.getRegCount()) { case 1: return new int[] {instruction.getRegisterD()}; diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction3rcMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction3rcMethodItem.java index 0cabd8b6..c59d13dd 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction3rcMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction3rcMethodItem.java @@ -29,17 +29,18 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction3rc; +import org.jf.baksmali.Adaptors.Reference.Reference; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; -public class Instruction3rcMethodItem extends ReferenceInstructionFormatMethodItem { - public Instruction3rcMethodItem(int offset, Instruction3rc instruction) { - super(offset, instruction); +public class Instruction3rcMethodItem extends InstructionFormatMethodItem { + public Instruction3rcMethodItem(int offset, StringTemplateGroup stg, Instruction3rc instruction) { + super(offset, stg, instruction); } - public int getStartRegister() { - return instruction.getStartRegister(); - } - - public int getLastRegister() { - return instruction.getStartRegister() + instruction.getRegCount() - 1; + protected void setAttributes(StringTemplate template) { + template.setAttribute("Reference", Reference.makeReference(instruction.getReferencedItem())); + template.setAttribute("StartRegister", instruction.getStartRegister()); + template.setAttribute("LastRegister", instruction.getStartRegister() + instruction.getRegCount() - 1); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction51lMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction51lMethodItem.java index 297fa1fa..7153777b 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction51lMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/Instruction51lMethodItem.java @@ -29,17 +29,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.Instruction51l; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class Instruction51lMethodItem extends InstructionFormatMethodItem { - public Instruction51lMethodItem(int offset, Instruction51l instruction) { - super(offset, instruction); + public Instruction51lMethodItem(int offset, StringTemplateGroup stg, Instruction51l instruction) { + super(offset, stg, instruction); } - public int getRegister() { - return instruction.getRegister(); - } - - public long getLiteral() { - return instruction.getLiteral(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", instruction.getRegister()); + template.setAttribute("Literal", instruction.getLiteral()); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/InstructionFormatMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/InstructionFormatMethodItem.java index bd3a243e..6e973ec6 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/InstructionFormatMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/InstructionFormatMethodItem.java @@ -31,12 +31,16 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.baksmali.Adaptors.MethodItem; import org.jf.baksmali.Adaptors.Reference.Reference; import org.jf.dexlib.Code.Instruction; +import org.antlr.stringtemplate.StringTemplate; +import org.antlr.stringtemplate.StringTemplateGroup; public abstract class InstructionFormatMethodItem extends MethodItem { - protected T instruction; + private final StringTemplateGroup stg; + protected final T instruction; - public InstructionFormatMethodItem(int offset, T instruction) { + public InstructionFormatMethodItem(int offset, StringTemplateGroup stg, T instruction) { super(offset); + this.stg = stg; this.instruction = instruction; } @@ -52,4 +56,14 @@ public abstract class InstructionFormatMethodItem extends public String getTemplate() { return instruction.getFormat().name(); } + + @Override + public String toString() { + StringTemplate template = stg.getInstanceOf(instruction.getFormat().name()); + template.setAttribute("Opcode", instruction.opcode.name); + setAttributes(template); + return template.toString(); + } + + protected abstract void setAttributes(StringTemplate template); } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/PackedSwitchMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/PackedSwitchMethodItem.java index 25aff614..d49423ee 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/PackedSwitchMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/PackedSwitchMethodItem.java @@ -30,37 +30,36 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.PackedSwitchDataPseudoInstruction; import org.jf.dexlib.Code.Format.SparseSwitchDataPseudoInstruction; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; import java.util.Iterator; +import java.util.List; +import java.util.ArrayList; public class PackedSwitchMethodItem extends InstructionFormatMethodItem { private int baseAddress; - public PackedSwitchMethodItem(int offset, PackedSwitchDataPseudoInstruction instruction, int baseAddress) { - super(offset, instruction); + public PackedSwitchMethodItem(int offset, StringTemplateGroup stg, PackedSwitchDataPseudoInstruction instruction, + int baseAddress) { + super(offset, stg, instruction); this.baseAddress = baseAddress; } - public int getFirstKey() { - return instruction.getFirstKey(); + protected void setAttributes(StringTemplate template) { + template.setAttribute("FirstKey", instruction.getFirstKey()); + template.setAttribute("Targets", getTargets()); } - public Iterator getTargets() { - return new Iterator() { - Iterator iterator = instruction.getTargets(); + private List getTargets() { + List targets = new ArrayList(); + Iterator iterator = instruction.getTargets(); + while (iterator.hasNext()) { + PackedSwitchDataPseudoInstruction.PackedSwitchTarget target = iterator.next(); + targets.add(Integer.toHexString(target.target + baseAddress)); + } - public boolean hasNext() { - return iterator.hasNext(); - } - - public String next() { - PackedSwitchDataPseudoInstruction.PackedSwitchTarget target = iterator.next(); - return Integer.toHexString(target.target + baseAddress); - } - - public void remove() { - } - }; + return targets; } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ReferenceInstructionFormatMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ReferenceInstructionFormatMethodItem.java deleted file mode 100644 index ad7a39d4..00000000 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/ReferenceInstructionFormatMethodItem.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * [The "BSD licence"] - * Copyright (c) 2009 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.baksmali.Adaptors.Format; - -import org.jf.dexlib.Code.InstructionWithReference; -import org.jf.baksmali.Adaptors.Reference.Reference; - -public abstract class ReferenceInstructionFormatMethodItem - extends InstructionFormatMethodItem { - - public ReferenceInstructionFormatMethodItem(int offset, T instruction) { - super(offset, instruction); - } - - public Reference getReference() { - return Reference.makeReference(instruction.getReferencedItem()); - } -} diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/SparseSwitchMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/SparseSwitchMethodItem.java index 48141852..28c55725 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/SparseSwitchMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/Format/SparseSwitchMethodItem.java @@ -29,40 +29,44 @@ package org.jf.baksmali.Adaptors.Format; import org.jf.dexlib.Code.Format.SparseSwitchDataPseudoInstruction; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; import java.util.Iterator; +import java.util.List; +import java.util.ArrayList; public class SparseSwitchMethodItem extends InstructionFormatMethodItem { private int baseAddress; - public SparseSwitchMethodItem(int offset, SparseSwitchDataPseudoInstruction instruction, int baseAddress) { - super(offset, instruction); + public SparseSwitchMethodItem(int offset, StringTemplateGroup stg, SparseSwitchDataPseudoInstruction instruction, + int baseAddress) { + super(offset, stg, instruction); this.baseAddress = baseAddress; } + protected void setAttributes(StringTemplate template) { + template.setAttribute("Targets", getTargets()); + } + private static class SparseSwitchTarget { public int Value; public String Target; } - public Iterator getTargets() { - return new Iterator() { - Iterator iterator = instruction.getTargets(); + private List getTargets() { + List targets = new ArrayList(); - public boolean hasNext() { - return iterator.hasNext(); - } + Iterator iterator = instruction.getTargets(); - public SparseSwitchTarget next() { - SparseSwitchDataPseudoInstruction.SparseSwitchTarget target = iterator.next(); - SparseSwitchTarget sparseSwitchTarget = new SparseSwitchTarget(); - sparseSwitchTarget.Value = target.value; - sparseSwitchTarget.Target = Integer.toHexString(target.target + baseAddress); - return sparseSwitchTarget; - } + while (iterator.hasNext()) { + SparseSwitchDataPseudoInstruction.SparseSwitchTarget target = iterator.next(); + SparseSwitchTarget sparseSwitchTarget = new SparseSwitchTarget(); + sparseSwitchTarget.Value = target.value; + sparseSwitchTarget.Target = Integer.toHexString(target.target + baseAddress); + targets.add(sparseSwitchTarget); + } - public void remove() { - } - }; + return targets; } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/LabelMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/LabelMethodItem.java index 71e6d08f..d9866e6c 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/LabelMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/LabelMethodItem.java @@ -28,11 +28,16 @@ package org.jf.baksmali.Adaptors; -public class LabelMethodItem extends MethodItem { - private String labelPrefix; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; - public LabelMethodItem(int offset, String labelPrefix) { +public class LabelMethodItem extends MethodItem { + private final StringTemplateGroup stg; + private final String labelPrefix; + + public LabelMethodItem(int offset, StringTemplateGroup stg, String labelPrefix) { super(offset); + this.stg = stg; this.labelPrefix = labelPrefix; } @@ -51,14 +56,6 @@ public class LabelMethodItem extends MethodItem { return result; } - public String getPrefix() { - return labelPrefix; - } - - public String getTemplate() { - return "Label"; - } - public int hashCode() { //force it to call equals when two labels are at the same address return getOffset(); @@ -70,4 +67,16 @@ public class LabelMethodItem extends MethodItem { } return this.compareTo((MethodItem)o) == 0; } + + @Override + public String toString() { + StringTemplate template = stg.getInstanceOf("Label"); + template.setAttribute("Prefix", labelPrefix); + template.setAttribute("HexOffset", getLabelOffset()); + return template.toString(); + } + + public String getLabelOffset() { + return getHexOffset(); + } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/LocalDebugMethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/LocalDebugMethodItem.java index 8e2bf21e..6483b064 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/LocalDebugMethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/LocalDebugMethodItem.java @@ -30,19 +30,29 @@ package org.jf.baksmali.Adaptors; import org.jf.dexlib.TypeIdItem; import org.jf.dexlib.StringIdItem; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; public class LocalDebugMethodItem extends DebugMethodItem { - public final int Register; - public final String Name; - public final String Type; - public final String Signature; + private final int register; + private final String name; + private final String type; + private final String signature; - public LocalDebugMethodItem(int offset, String template, int sortOrder, int register, StringIdItem name, - TypeIdItem type, StringIdItem signature) { - super(offset, template, sortOrder); - this.Register = register; - this.Name = name==null?null:name.getStringValue(); - this.Type = type==null?null:type.getTypeDescriptor(); - this.Signature = signature==null?null:signature.getStringValue(); + public LocalDebugMethodItem(int offset, StringTemplateGroup stg, String templateName, int sortOrder, int register, + StringIdItem name, TypeIdItem type, StringIdItem signature) { + super(offset, stg, templateName, sortOrder); + this.register = register; + this.name = name==null?null:name.getStringValue(); + this.type = type==null?null:type.getTypeDescriptor(); + this.signature = signature==null?null:signature.getStringValue(); + } + + @Override + protected void setAttributes(StringTemplate template) { + template.setAttribute("Register", Integer.toString(register)); + template.setAttribute("Name", name); + template.setAttribute("Type", type); + template.setAttribute("Signature", signature); } } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodDefinition.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodDefinition.java index d6474165..0fd2b39f 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodDefinition.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodDefinition.java @@ -36,83 +36,44 @@ import org.jf.dexlib.Code.Instruction; import org.jf.dexlib.Code.Opcode; import org.jf.dexlib.Code.InstructionIterator; import org.jf.dexlib.Util.AccessFlags; +import org.antlr.stringtemplate.StringTemplateGroup; +import org.antlr.stringtemplate.StringTemplate; import java.util.*; public class MethodDefinition { - private ClassDataItem.EncodedMethod encodedMethod; - private MethodIdItem methodIdItem; - private CodeItem codeItem; - private AnnotationSetItem annotationSet; - private AnnotationSetRefList parameterAnnotations; + public static StringTemplate makeTemplate(StringTemplateGroup stg, ClassDataItem.EncodedMethod encodedMethod, + AnnotationSetItem annotationSet, + AnnotationSetRefList parameterAnnotations) { - public MethodDefinition(ClassDataItem.EncodedMethod encodedMethod, AnnotationSetItem annotationSet, - AnnotationSetRefList parameterAnnotations) { - this.encodedMethod = encodedMethod; - this.methodIdItem = encodedMethod.method; - this.codeItem = encodedMethod.codeItem; - this.annotationSet = annotationSet; - this.parameterAnnotations = parameterAnnotations; + CodeItem codeItem = encodedMethod.codeItem; + + StringTemplate template = stg.getInstanceOf("method"); + + template.setAttribute("AccessFlags", getAccessFlags(encodedMethod)); + template.setAttribute("MethodName", encodedMethod.method.getMethodName().getStringValue()); + template.setAttribute("Prototype", encodedMethod.method.getPrototype().getPrototypeString()); + template.setAttribute("HasCode", codeItem != null); + template.setAttribute("RegisterCount", codeItem==null?"0":Integer.toString(codeItem.getRegisterCount())); + template.setAttribute("Parameters", getParameters(stg, codeItem, parameterAnnotations)); + template.setAttribute("Annotations", getAnnotations(stg, annotationSet)); + template.setAttribute("MethodItems", getMethodItems(encodedMethod.method.getDexFile(), stg, codeItem)); + + return template; } - public String getMethodName() { - return methodIdItem.getMethodName().getStringValue(); - } + private static List getAccessFlags(ClassDataItem.EncodedMethod encodedMethod) { + List accessFlags = new ArrayList(); - private List accessFlags = null; - public List getAccessFlags() { - if (accessFlags == null) { - accessFlags = new ArrayList(); - - for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForMethod(encodedMethod.accessFlags)) { - accessFlags.add(accessFlag.toString()); - } + for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForMethod(encodedMethod.accessFlags)) { + accessFlags.add(accessFlag.toString()); } + return accessFlags; } - private String prototype = null; - public String getPrototype() { - if (prototype == null) { - prototype = methodIdItem.getPrototype().getPrototypeString(); - } - return prototype; - } - - private Boolean hasCode = null; - public boolean getHasCode() { - if (hasCode == null) { - hasCode = (codeItem != null); - } - return hasCode; - } - - private String registerCount = null; - public String getRegisterCount() { - if (registerCount == null) { - if (codeItem == null) { - registerCount = "0"; - } else { - registerCount = Integer.toString(codeItem.getRegisterCount()); - } - } - return registerCount; - } - - public List getAnnotations() { - if (annotationSet == null) { - return null; - } - - List annotationAdaptors = new ArrayList(); - - for (AnnotationItem annotationItem: annotationSet.getAnnotations()) { - annotationAdaptors.add(new AnnotationAdaptor(annotationItem)); - } - return annotationAdaptors; - } - - public List getParameters() { + private static List getParameters(StringTemplateGroup stg, CodeItem codeItem, + AnnotationSetRefList parameterAnnotations) { DebugInfoItem debugInfoItem = null; if (codeItem != null) { debugInfoItem = codeItem.getDebugInfo(); @@ -144,7 +105,7 @@ public class MethodDefinition { } } - List parameterAdaptors = new ArrayList(); + List parameters = new ArrayList(); for (int i=0; i getAnnotations(StringTemplateGroup stg, AnnotationSetItem annotationSet) { + if (annotationSet == null) { return null; } - DebugInfoItem debugInfoItem = codeItem.getDebugInfo(); - if (debugInfoItem == null) { - return null; - } + List annotationAdaptors = new ArrayList(); - return debugInfoItem.getParameterNames(); + for (AnnotationItem annotationItem: annotationSet.getAnnotations()) { + annotationAdaptors.add(AnnotationAdaptor.makeTemplate(stg, annotationItem)); + } + return annotationAdaptors; } - private List methodItems = null; - public List getMethodItems() { - if (methodItems == null) { - MethodItemList methodItemList = new MethodItemList(); - methodItemList.generateMethodItemList(); + private static List getMethodItems(DexFile dexFile, StringTemplateGroup stg, CodeItem codeItem) { + List methodItems = new ArrayList(); - methodItems = new ArrayList(); + MethodItemList methodItemList = new MethodItemList(dexFile, stg, codeItem); + methodItemList.generateMethodItemList(); + + methodItems.addAll(methodItemList.labels); + methodItems.addAll(methodItemList.instructions); + methodItems.addAll(methodItemList.blanks); + methodItems.addAll(methodItemList.catches); + methodItems.addAll(methodItemList.debugItems); + Collections.sort(methodItems); - methodItems.addAll(methodItemList.labels); - methodItems.addAll(methodItemList.instructions); - methodItems.addAll(methodItemList.blanks); - methodItems.addAll(methodItemList.catches); - methodItems.addAll(methodItemList.debugItems); - Collections.sort(methodItems); - } return methodItems; } - private class MethodItemList { + private static class MethodItemList { + private final DexFile dexFile; + private final StringTemplateGroup stg; + private final CodeItem codeItem; + public HashSet labels = new HashSet(); public List instructions = new ArrayList(); public List blanks = new ArrayList(); @@ -204,6 +167,11 @@ public class MethodDefinition { private HashMap packedSwitchMap = new HashMap(); private HashMap sparseSwitchMap = new HashMap(); + public MethodItemList(DexFile dexFile, StringTemplateGroup stg, CodeItem codeItem) { + this.dexFile = dexFile; + this.stg = stg; + this.codeItem = codeItem; + } public void generateMethodItemList() { if (codeItem == null) { @@ -217,11 +185,11 @@ public class MethodDefinition { public void ProcessNormalInstruction(Opcode opcode, int index) { if (opcode == Opcode.PACKED_SWITCH) { Instruction31t ins = (Instruction31t)opcode.format.Factory.makeInstruction( - methodIdItem.getDexFile(), opcode, encodedInstructions, index); + dexFile, opcode, encodedInstructions, index); packedSwitchMap.put(index/2 + ins.getOffset(), index/2); } else if (opcode == Opcode.SPARSE_SWITCH) { Instruction31t ins = (Instruction31t)opcode.format.Factory.makeInstruction( - methodIdItem.getDexFile(), opcode, encodedInstructions, index); + dexFile, opcode, encodedInstructions, index); sparseSwitchMap.put(index/2 + ins.getOffset(), index/2); } } @@ -235,16 +203,17 @@ public class MethodDefinition { public void ProcessSparseSwitchInstruction(int index, int targetCount, int instructionLength) { } - public void ProcessFillArrayDataInstruction(int index, int elementWidth, int elementCount, int instructionLength) { + public void ProcessFillArrayDataInstruction(int index, int elementWidth, int elementCount, + int instructionLength) { } }); - InstructionIterator.IterateInstructions(methodIdItem.getDexFile(), encodedInstructions, + InstructionIterator.IterateInstructions(dexFile, encodedInstructions, new InstructionIterator.ProcessInstructionDelegate() { public void ProcessInstruction(int index, Instruction instruction) { int offset = index/2; addMethodItemsForInstruction(offset, instruction); - blanks.add(new BlankMethodItem(offset)); + blanks.add(new BlankMethodItem(stg, offset)); } }); @@ -258,91 +227,94 @@ public class MethodDefinition { private void addMethodItemsForInstruction(int offset, Instruction instruction) { switch (instruction.getFormat()) { case Format10t: - instructions.add(new Instruction10tMethodItem(offset, (Instruction10t)instruction)); - labels.add(new LabelMethodItem(offset + ((Instruction10t)instruction).getOffset(), "goto_")); + instructions.add(new Instruction10tMethodItem(offset, stg,(Instruction10t)instruction)); + labels.add(new LabelMethodItem(offset + ((Instruction10t)instruction).getOffset(), stg, "goto_")); return; case Format10x: - instructions.add(new Instruction10xMethodItem(offset, (Instruction10x)instruction)); + instructions.add(new Instruction10xMethodItem(offset, stg, (Instruction10x)instruction)); return; case Format11n: - instructions.add(new Instruction11nMethodItem(offset, (Instruction11n)instruction)); + instructions.add(new Instruction11nMethodItem(offset, stg, (Instruction11n)instruction)); return; case Format11x: - instructions.add(new Instruction11xMethodItem(offset, (Instruction11x)instruction)); + instructions.add(new Instruction11xMethodItem(offset, stg, (Instruction11x)instruction)); return; case Format12x: - instructions.add(new Instruction12xMethodItem(offset, (Instruction12x)instruction)); + instructions.add(new Instruction12xMethodItem(offset, stg, (Instruction12x)instruction)); return; case Format20t: - instructions.add(new Instruction20tMethodItem(offset, (Instruction20t)instruction)); - labels.add(new LabelMethodItem(offset + ((Instruction20t)instruction).getOffset(), "goto_")); + instructions.add(new Instruction20tMethodItem(offset, stg, (Instruction20t)instruction)); + labels.add(new LabelMethodItem(offset + ((Instruction20t)instruction).getOffset(), stg, "goto_")); return; case Format21c: - instructions.add(new Instruction21cMethodItem(offset, (Instruction21c)instruction)); + instructions.add(new Instruction21cMethodItem(offset, stg, (Instruction21c)instruction)); return; case Format21h: - instructions.add(new Instruction21hMethodItem(offset, (Instruction21h)instruction)); + instructions.add(new Instruction21hMethodItem(offset, stg, (Instruction21h)instruction)); return; case Format21s: - instructions.add(new Instruction21sMethodItem(offset, (Instruction21s)instruction)); + instructions.add(new Instruction21sMethodItem(offset, stg, (Instruction21s)instruction)); return; case Format21t: - instructions.add(new Instruction21tMethodItem(offset, (Instruction21t)instruction)); - labels.add(new LabelMethodItem(offset + ((Instruction21t)instruction).getOffset(), "cond_")); + instructions.add(new Instruction21tMethodItem(offset, stg, (Instruction21t)instruction)); + labels.add(new LabelMethodItem(offset + ((Instruction21t)instruction).getOffset(), stg, "cond_")); return; case Format22b: - instructions.add(new Instruction22bMethodItem(offset, (Instruction22b)instruction)); + instructions.add(new Instruction22bMethodItem(offset, stg, (Instruction22b)instruction)); return; case Format22c: - instructions.add(new Instruction22cMethodItem(offset, (Instruction22c)instruction)); + instructions.add(new Instruction22cMethodItem(offset, stg, (Instruction22c)instruction)); return; case Format22s: - instructions.add(new Instruction22sMethodItem(offset, (Instruction22s)instruction)); + instructions.add(new Instruction22sMethodItem(offset, stg, (Instruction22s)instruction)); return; case Format22t: - instructions.add(new Instruction22tMethodItem(offset, (Instruction22t)instruction)); - labels.add(new LabelMethodItem(offset + ((Instruction22t)instruction).getOffset(), "cond_")); + instructions.add(new Instruction22tMethodItem(offset, stg, (Instruction22t)instruction)); + labels.add(new LabelMethodItem(offset + ((Instruction22t)instruction).getOffset(), stg, "cond_")); return; case Format22x: - instructions.add(new Instruction22xMethodItem(offset, (Instruction22x)instruction)); + instructions.add(new Instruction22xMethodItem(offset, stg, (Instruction22x)instruction)); return; case Format23x: - instructions.add(new Instruction23xMethodItem(offset, (Instruction23x)instruction)); + instructions.add(new Instruction23xMethodItem(offset, stg, (Instruction23x)instruction)); return; case Format30t: - instructions.add(new Instruction30tMethodItem(offset, (Instruction30t)instruction)); - labels.add(new LabelMethodItem(offset + ((Instruction30t)instruction).getOffset(), "goto_")); + instructions.add(new Instruction30tMethodItem(offset, stg, (Instruction30t)instruction)); + labels.add(new LabelMethodItem(offset + ((Instruction30t)instruction).getOffset(), stg, "goto_")); return; case Format31c: - instructions.add(new Instruction31cMethodItem(offset, (Instruction31c)instruction)); + instructions.add(new Instruction31cMethodItem(offset, stg, (Instruction31c)instruction)); return; case Format31i: - instructions.add(new Instruction31iMethodItem(offset, (Instruction31i)instruction)); + instructions.add(new Instruction31iMethodItem(offset, stg, (Instruction31i)instruction)); return; case Format31t: - instructions.add(new Instruction31tMethodItem(offset, (Instruction31t)instruction)); + instructions.add(new Instruction31tMethodItem(offset, stg, (Instruction31t)instruction)); if (instruction.opcode == Opcode.FILL_ARRAY_DATA) { - labels.add(new LabelMethodItem(offset + ((Instruction31t)instruction).getOffset(), "array_")); + labels.add(new LabelMethodItem(offset + ((Instruction31t)instruction).getOffset(), stg, + "array_")); } else if (instruction.opcode == Opcode.PACKED_SWITCH) { - labels.add(new LabelMethodItem(offset + ((Instruction31t)instruction).getOffset(), "pswitch_data_")); + labels.add(new LabelMethodItem(offset + ((Instruction31t)instruction).getOffset(), stg, + "pswitch_data_")); } else if (instruction.opcode == Opcode.SPARSE_SWITCH) { - labels.add(new LabelMethodItem(offset + ((Instruction31t)instruction).getOffset(), "sswitch_data_")); + labels.add(new LabelMethodItem(offset + ((Instruction31t)instruction).getOffset(), stg, + "sswitch_data_")); } return; case Format32x: - instructions.add(new Instruction32xMethodItem(offset, (Instruction32x)instruction)); + instructions.add(new Instruction32xMethodItem(offset, stg, (Instruction32x)instruction)); return; case Format35c: - instructions.add(new Instruction35cMethodItem(offset, (Instruction35c)instruction)); + instructions.add(new Instruction35cMethodItem(offset, stg, (Instruction35c)instruction)); return; case Format3rc: - instructions.add(new Instruction3rcMethodItem(offset, (Instruction3rc)instruction)); + instructions.add(new Instruction3rcMethodItem(offset, stg, (Instruction3rc)instruction)); return; case Format51l: - instructions.add(new Instruction51lMethodItem(offset, (Instruction51l)instruction)); + instructions.add(new Instruction51lMethodItem(offset, stg, (Instruction51l)instruction)); return; case ArrayData: - instructions.add(new ArrayDataMethodItem(offset, (ArrayDataPseudoInstruction)instruction)); + instructions.add(new ArrayDataMethodItem(offset, stg, (ArrayDataPseudoInstruction)instruction)); return; case PackedSwitchData: { @@ -352,14 +324,14 @@ public class MethodDefinition { PackedSwitchDataPseudoInstruction packedSwitchInstruction = (PackedSwitchDataPseudoInstruction)instruction; - instructions.add(new PackedSwitchMethodItem(offset, + instructions.add(new PackedSwitchMethodItem(offset, stg, packedSwitchInstruction, baseAddress)); Iterator iterator = packedSwitchInstruction.getTargets(); while (iterator.hasNext()) { PackedSwitchDataPseudoInstruction.PackedSwitchTarget target = iterator.next(); - labels.add(new LabelMethodItem(baseAddress + target.target, "pswitch_")); + labels.add(new LabelMethodItem(baseAddress + target.target, stg, "pswitch_")); } } return; @@ -372,14 +344,14 @@ public class MethodDefinition { SparseSwitchDataPseudoInstruction sparseSwitchInstruction = (SparseSwitchDataPseudoInstruction)instruction; - instructions.add(new SparseSwitchMethodItem(offset, + instructions.add(new SparseSwitchMethodItem(offset, stg, sparseSwitchInstruction, baseAddress)); Iterator iterator = sparseSwitchInstruction.getTargets(); while (iterator.hasNext()) { SparseSwitchDataPseudoInstruction.SparseSwitchTarget target = iterator.next(); - labels.add(new LabelMethodItem(baseAddress + target.target, "sswitch_")); + labels.add(new LabelMethodItem(baseAddress + target.target, stg, "sswitch_")); } } } @@ -400,7 +372,7 @@ public class MethodDefinition { * label to be associated with the last covered instruction, so we need to get * the offset for that instruction */ - int index = Collections.binarySearch(instructions, new BlankMethodItem(endAddress)); + int index = Collections.binarySearch(instructions, new BlankMethodItem(stg, endAddress)); if (index < 0) { index = (index * -1) - 1; } @@ -426,19 +398,19 @@ public class MethodDefinition { //add the catch all handler if it exists int catchAllAddress = tryItem.encodedCatchHandler.catchAllHandlerAddress; if (catchAllAddress != -1) { - CatchMethodItem catchMethodItem = new CatchMethodItem(lastInstructionOffset, null, startAddress, - endAddress, catchAllAddress) { - public String getTemplate() { + CatchMethodItem catchMethodItem = new CatchMethodItem(lastInstructionOffset, stg, null, + startAddress, endAddress, catchAllAddress) { + public String getTemplateName() { return "CatchAll"; } }; catches.add(catchMethodItem); - labels.add(new LabelMethodItem(startAddress, "try_start_")); + labels.add(new LabelMethodItem(startAddress, stg, "try_start_")); //use the offset from the last covered instruction, but make the label //name refer to the address of the next instruction - labels.add(new EndTryLabelMethodItem(lastInstructionOffset, endAddress)); - labels.add(new LabelMethodItem(catchAllAddress, "handler_")); + labels.add(new EndTryLabelMethodItem(lastInstructionOffset, stg, endAddress)); + labels.add(new LabelMethodItem(catchAllAddress, stg, "handler_")); } @@ -446,15 +418,15 @@ public class MethodDefinition { //TODO: find adjacent handlers for the same type and combine them for (CodeItem.EncodedTypeAddrPair handler: tryItem.encodedCatchHandler.handlers) { //use the offset from the last covered instruction - CatchMethodItem catchMethodItem = new CatchMethodItem(lastInstructionOffset, + CatchMethodItem catchMethodItem = new CatchMethodItem(lastInstructionOffset, stg, handler.exceptionType, startAddress, endAddress, handler.handlerAddress); catches.add(catchMethodItem); - labels.add(new LabelMethodItem(startAddress, "try_start_")); + labels.add(new LabelMethodItem(startAddress, stg, "try_start_")); //use the offset from the last covered instruction, but make the label //name refer to the address of the next instruction - labels.add(new EndTryLabelMethodItem(lastInstructionOffset, endAddress)); - labels.add(new LabelMethodItem(handler.handlerAddress, "handler_")); + labels.add(new EndTryLabelMethodItem(lastInstructionOffset, stg, endAddress)); + labels.add(new LabelMethodItem(handler.handlerAddress, stg, "handler_")); } } } @@ -470,58 +442,60 @@ public class MethodDefinition { @Override public void ProcessStartLocal(int codeAddress, int length, int registerNum, StringIdItem name, TypeIdItem type) { - debugItems.add(new LocalDebugMethodItem(codeAddress, "StartLocal", -1, registerNum, name, - type, null)); + debugItems.add(new LocalDebugMethodItem(codeAddress, stg, "StartLocal", -1, registerNum, + name, type, null)); } @Override public void ProcessStartLocalExtended(int codeAddress, int length, int registerNum, StringIdItem name, TypeIdItem type, StringIdItem signature) { - debugItems.add(new LocalDebugMethodItem(codeAddress, "StartLocal", -1, registerNum, name, - type, signature)); + debugItems.add(new LocalDebugMethodItem(codeAddress, stg, "StartLocal", -1, registerNum, + name, type, signature)); } @Override public void ProcessEndLocal(int codeAddress, int length, int registerNum, StringIdItem name, TypeIdItem type, StringIdItem signature) { - debugItems.add(new LocalDebugMethodItem(codeAddress, "EndLocal", -1, registerNum, name, + debugItems.add(new LocalDebugMethodItem(codeAddress, stg, "EndLocal", -1, registerNum, name, type, signature)); } @Override public void ProcessRestartLocal(int codeAddress, int length, int registerNum, StringIdItem name, TypeIdItem type, StringIdItem signature) { - debugItems.add(new LocalDebugMethodItem(codeAddress, "RestartLocal", -1, registerNum, name, - type, signature)); + debugItems.add(new LocalDebugMethodItem(codeAddress, stg, "RestartLocal", -1, registerNum, + name, type, signature)); } @Override public void ProcessSetPrologueEnd(int codeAddress) { - debugItems.add(new DebugMethodItem(codeAddress, "EndPrologue", -4)); + debugItems.add(new DebugMethodItem(codeAddress, stg, "EndPrologue", -4)); } @Override public void ProcessSetEpilogueBegin(int codeAddress) { - debugItems.add(new DebugMethodItem(codeAddress, "StartEpilogue", -4)); + debugItems.add(new DebugMethodItem(codeAddress, stg, "StartEpilogue", -4)); } @Override public void ProcessSetFile(int codeAddress, int length, final StringIdItem name) { - debugItems.add(new DebugMethodItem(codeAddress, "SetFile", -3) { - public String getFileName() { - return name.getStringValue(); - } + debugItems.add(new DebugMethodItem(codeAddress, stg, "SetFile", -3) { + @Override + protected void setAttributes(StringTemplate template) { + template.setAttribute("FileName", name.getStringValue()); + } }); } @Override public void ProcessLineEmit(int codeAddress, final int line) { - debugItems.add(new DebugMethodItem(codeAddress, "Line", -2) { - public int getLine() { - return line; - } - }); + debugItems.add(new DebugMethodItem(codeAddress, stg, "Line", -2) { + @Override + protected void setAttributes(StringTemplate template) { + template.setAttribute("Line", line); + } + }); } }); } diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodItem.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodItem.java index dbc7ab90..7bb72d8a 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodItem.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/MethodItem.java @@ -35,7 +35,6 @@ public abstract class MethodItem implements Comparable { this.offset = offset; } - public int getOffset() { return offset; } @@ -44,8 +43,6 @@ public abstract class MethodItem implements Comparable { return Integer.toHexString(offset); } - //return the name of the template that should be used to render this item - public abstract String getTemplate(); //return an arbitrary integer that determines how this item will be sorted with //others at the same offset public abstract int getSortOrder(); diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/ParameterAdaptor.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/ParameterAdaptor.java index 2047c33d..8469e865 100644 --- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/ParameterAdaptor.java +++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/ParameterAdaptor.java @@ -30,31 +30,31 @@ package org.jf.baksmali.Adaptors; import org.jf.dexlib.AnnotationSetItem; import org.jf.dexlib.AnnotationItem; +import org.antlr.stringtemplate.StringTemplate; +import org.antlr.stringtemplate.StringTemplateGroup; import java.util.List; import java.util.ArrayList; public class ParameterAdaptor { - private String parameterName; - private AnnotationSetItem parameterAnnotations; + public static StringTemplate makeTemplate(StringTemplateGroup stg, String parameterName, + AnnotationSetItem parameterAnnotations) { + StringTemplate template = stg.getInstanceOf("Parameter"); - public ParameterAdaptor(String parameterName, AnnotationSetItem parameterAnnotations) { - this.parameterName = parameterName; - this.parameterAnnotations = parameterAnnotations; + template.setAttribute("ParameterName", parameterName); + template.setAttribute("Annotations", getAnnotations(stg, parameterAnnotations)); + return template; } - public String getParameterName() { - return parameterName; - } - - public List getAnnotations() { + private static List getAnnotations(StringTemplateGroup stg, + AnnotationSetItem parameterAnnotations) { if (parameterAnnotations == null) { return null; } - List annotations = new ArrayList(); + List annotations = new ArrayList(); for (AnnotationItem annotationItem: parameterAnnotations.getAnnotations()) { - annotations.add(new AnnotationAdaptor(annotationItem)); + annotations.add(AnnotationAdaptor.makeTemplate(stg, annotationItem)); } return annotations; } diff --git a/baksmali/src/main/java/org/jf/baksmali/baksmali.java b/baksmali/src/main/java/org/jf/baksmali/baksmali.java index b059f4a5..e3c2df31 100644 --- a/baksmali/src/main/java/org/jf/baksmali/baksmali.java +++ b/baksmali/src/main/java/org/jf/baksmali/baksmali.java @@ -97,7 +97,7 @@ public class baksmali { //create and initialize the top level string template StringTemplate smaliFileST = templates.getInstanceOf("smaliFile"); - smaliFileST.setAttribute("classDef", new ClassDefinition(classDefItem)); + smaliFileST.setAttribute("classDef", new ClassDefinition(templates, classDefItem)); //generate the disassembly String output = smaliFileST.toString(); diff --git a/baksmali/src/main/resources/templates/templates/baksmali.stg b/baksmali/src/main/resources/templates/templates/baksmali.stg index 2c6bce37..13e257f3 100644 --- a/baksmali/src/main/resources/templates/templates/baksmali.stg +++ b/baksmali/src/main/resources/templates/templates/baksmali.stg @@ -22,35 +22,35 @@ smaliFile(classDef) ::= # annotations - + - + # static fields - + - + # instance fields - + - + # direct methods - + - + # virtual methods - + >> @@ -64,13 +64,13 @@ implement(interface) ::= >> -annotation(annotationAdaptor) ::= +annotation(Visibility, AnnotationType, Elements) ::= << -.annotation - - +.annotation + + - + @@ -79,46 +79,41 @@ annotation(annotationAdaptor) ::= -field(fieldDef) ::= +field(AccessFlags, FieldName, FieldType, Annotations, InitialValue) ::= << -.field }>: = - - +.field }>: = + + .end field >> -method(methodDef) ::= +method(AccessFlags, MethodName, Prototype, HasCode, RegisterCount, Parameters, Annotations, MethodItems) ::= << -.method }> - - .registers - - +.method }> + + .registers + + - - + + - - - + + + .end method >> -MethodItem(MethodItem) ::= +Parameter(ParameterName, Annotations) ::= << - ->> +.parameter "" -Parameter(Parameter) ::= -<< -.parameter "" - - + .end parameter >> @@ -139,161 +134,156 @@ v -Format10t(Instruction) ::= +Format10t(Opcode, Target) ::= << - goto_: + goto_: >> -Format10x(Instruction) ::= +Format10x(Opcode) ::= << - + >> -Format11n(Instruction) ::= +Format11n(Opcode, Register, Literal) ::= << - , + , >> -Format11x(Instruction) ::= +Format11x(Opcode, Register) ::= << - + >> -Format12x(Instruction) ::= +Format12x(Opcode, RegisterA, RegisterB) ::= << - , + , >> -Format20t(Instruction) ::= +Format20t(Opcode, Target) ::= << - goto_: + goto_: >> -Format21c(Instruction) ::= +Format21c(Opcode, Register, Reference) ::= << - , + , >> -Format21h(Instruction) ::= +Format21h(Opcode, Register, Literal) ::= << - , + , >> -Format21s(Instruction) ::= +Format21s(Opcode, Register, Literal) ::= << - , + , >> -Format21t(Instruction) ::= +Format21t(Opcode, Register, Target) ::= << - , cond_: + , cond_: >> -Format22b(Instruction) ::= +Format22b(Opcode, RegisterA, RegisterB, Literal) ::= << - , , + , , >> -Format22c(Instruction) ::= +Format22c(Opcode, RegisterA, RegisterB, Reference) ::= << - , , + , , >> -Format22s(Instruction) ::= +Format22s(Opcode, RegisterA, RegisterB, Literal) ::= << - , , + , , >> -Format22t(Instruction) ::= +Format22t(Opcode, RegisterA, RegisterB, Target) ::= << - , , cond_: + , , cond_: >> -Format22x(Instruction) ::= +Format22x(Opcode, RegisterA, RegisterB) ::= << - , + , >> -Format23x(Instruction) ::= +Format23x(Opcode, RegisterA, RegisterB, RegisterC) ::= << - , , + , , >> -Format30t(Instruction) ::= +Format30t(Opcode, Target) ::= << - goto_: + goto_: >> -Format31c(Instruction) ::= +Format31c(Opcode, Register, Reference) ::= << - , + , >> -Format31i(Instruction) ::= +Format31i(Opcode, Register, Literal) ::= << - , + , >> -Format31t(Instruction) ::= +Format31t(Opcode, Register, Target) ::= << - , : + , : >> -Format32x(Instruction) ::= +Format32x(Opcode, RegisterA, RegisterB) ::= << - , + , >> -Format35c(Instruction) ::= +Format35c(Opcode, Registers, Reference) ::= << - {}, + {}, >> -Format3rc(Instruction) ::= +Format3rc(Opcode, StartRegister, LastRegister, Reference) ::= << - { .. }, + { .. }, >> -Format51l(Instruction) ::= +Format51l(Opcode, Register, Literal) ::= << - , + , >> -ArrayData(Instruction) ::= +ArrayData(Opcode, ElementWidth, Values) ::= << -.array-data +.array-data }; separator="\n"> .end array-data >> -PackedSwitchData(Instruction) ::= +PackedSwitchData(Opcode, FirstKey, Targets) ::= << -.packed-switch - :}; separator="\n"> +.packed-switch + :}; separator="\n"> .end packed-switch >> -SparseSwitchData(Instruction) ::= +SparseSwitchData(Opcode, Targets) ::= << .sparse-switch - -> sswitch_:}; separator="\n"> + -> sswitch_:}; separator="\n"> .end sparse-switch >> -Label(Label) ::= +Label(Prefix, HexOffset) ::= << -: ->> - -EndTryLabel(Label) ::= -<< -: +: >> Line(Line) ::= << -.line +.line >> EndPrologue(Prologue) ::= @@ -306,24 +296,24 @@ StartEpilogue(Epilogue) ::= .epilogue >> -StartLocal(StartLocal) ::= +StartLocal(Register, Name, Type, Signature) ::= << -.local , :,"" +.local , :,"" >> -EndLocal(EndLocal) ::= +EndLocal(Register, Name, Type, Signature) ::= << -.end local #:,, "" +.end local #:,, "" >> -RestartLocal(RestartLocal) ::= +RestartLocal(Register, Name, Type, Signature) ::= << -.restart local #:,, "" +.restart local #:,, "" >> -SetFile(SetFile) ::= +SetFile(FileName) ::= << -.source "" +.source "" >> Blank(Blank) ::= @@ -331,14 +321,14 @@ Blank(Blank) ::= >> -Catch(Catch) ::= +Catch(ExceptionType, StartAddress, EndAddress, HandlerAddress) ::= << -.catch {try_start_: .. try_end_:} handler_: +.catch {try_start_: .. try_end_:} handler_: >> -CatchAll(Catch) ::= +CatchAll(StartAddress, EndAddress, HandlerAddress) ::= << -.catchall {try_start_: .. try_end_:} handler_: +.catchall {try_start_: .. try_end_:} handler_: >>