ReVanced/smali
1
0
Fork 0
mirror of https://github.com/revanced/smali.git synced 2025-05-08 10:24:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor all the encoded value stuff to use template attributes instead of object properties

Browse Source 
git-svn-id: https://smali.googlecode.com/svn/trunk@368 55b6fa8a-2a1e-11de-a435-ffa8d773f76a
This commit is contained in:
JesusFreke@JesusFreke.com 2009-08-06 06:47:07 +00:00
parent cc32387e75
commit a3cf936fc2
10 changed files with 91 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
baksmali/src/main/java/org/jf/baksmali/Adaptors/AnnotationAdaptor.java
View File

@ -40,11 +40,8 @@ public class AnnotationAdaptor {
public static StringTemplate makeTemplate(StringTemplateGroup stg, AnnotationItem annotationItem) {
StringTemplate template = stg.getInstanceOf("annotation");
AnnotationEncodedValueAdaptor aeva = new AnnotationEncodedValueAdaptor(annotationItem.getEncodedAnnotation());
template.setAttribute("Visibility", annotationItem.getVisibility().name().toLowerCase());
template.setAttribute("AnnotationType", aeva.getAnnotationType());
template.setAttribute("Elements", aeva.getElements());
AnnotationEncodedValueAdaptor.setAttributesForAnnotation(template, annotationItem.getEncodedAnnotation());
return template;
}

54
baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/AnnotationEncodedValueAdaptor.java
View File

@ -32,55 +32,45 @@ import org.jf.dexlib.EncodedValue.EncodedValue;
import org.jf.dexlib.EncodedValue.AnnotationEncodedSubValue;
import org.jf.dexlib.StringIdItem;
import org.jf.baksmali.Adaptors.Reference.TypeReference;
import org.antlr.stringtemplate.StringTemplate;
import org.antlr.stringtemplate.StringTemplateGroup;
import java.util.List;
import java.util.ArrayList;
public class AnnotationEncodedValueAdaptor extends EncodedValueAdaptor {
private AnnotationEncodedSubValue encodedAnnotation;
public abstract class AnnotationEncodedValueAdaptor {
public AnnotationEncodedValueAdaptor(AnnotationEncodedSubValue encodedAnnotation) {
this.encodedAnnotation = encodedAnnotation;
public static StringTemplate makeTemplate(StringTemplateGroup stg, AnnotationEncodedSubValue encodedAnnotation) {
StringTemplate template = stg.getInstanceOf("AnnotationEncodedValue");
template.setAttribute("AnnotationType", new TypeReference(encodedAnnotation.annotationType));
template.setAttribute("Elements", getElements(stg, encodedAnnotation));
return template;
}
public String getFormat() {
return "AnnotationEncodedValue";
public static void setAttributesForAnnotation(StringTemplate template,
AnnotationEncodedSubValue encodedAnnotation) {
template.setAttribute("AnnotationType", new TypeReference(encodedAnnotation.annotationType));
template.setAttribute("Elements", getElements(template.getGroup(), encodedAnnotation));
}
public Object getValue() {
return this;
}
public TypeReference getAnnotationType() {
return new TypeReference(encodedAnnotation.annotationType);
}
public List<AnnotationElementAdaptor> getElements() {
List<AnnotationElementAdaptor> elements = new ArrayList<AnnotationElementAdaptor>();
private static List<String> getElements(StringTemplateGroup stg,
AnnotationEncodedSubValue encodedAnnotation) {
List<String> elements = new ArrayList<String>();
for (int i=0; i<encodedAnnotation.names.length; i++) {
elements.add(new AnnotationElementAdaptor(encodedAnnotation.names[i], encodedAnnotation.values[i]));
elements.add(AnnotationElementAdaptor.toString(stg, encodedAnnotation.names[i], encodedAnnotation.values[i]));
}
return elements;
}
public static class AnnotationElementAdaptor {
private StringIdItem name;
private EncodedValue value;
public AnnotationElementAdaptor(StringIdItem name, EncodedValue value) {
this.name = name;
this.value = value;
}
public String getName() {
return name.getStringValue();
}
public EncodedValueAdaptor getValue() {
return EncodedValueAdaptor.make(value);
private static class AnnotationElementAdaptor {
public static String toString(StringTemplateGroup stg, StringIdItem name, EncodedValue value) {
StringTemplate template = stg.getInstanceOf("AnnotationElement");
template.setAttribute("Name", name);
template.setAttribute("Value", EncodedValueAdaptor.make(stg, value));
return template.toString();
}
}
}

22
baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/ArrayEncodedValueAdaptor.java
View File

@ -30,26 +30,24 @@ package org.jf.baksmali.Adaptors.EncodedValue;
import org.jf.dexlib.EncodedValue.EncodedValue;
import org.jf.dexlib.EncodedValue.ArrayEncodedValue;
import org.antlr.stringtemplate.StringTemplateGroup;
import org.antlr.stringtemplate.StringTemplate;
import java.util.List;
import java.util.ArrayList;
public class ArrayEncodedValueAdaptor extends EncodedValueAdaptor {
private ArrayEncodedValue encodedArray;
public ArrayEncodedValueAdaptor(ArrayEncodedValue encodedArray) {
this.encodedArray = encodedArray;
public class ArrayEncodedValueAdaptor {
public static StringTemplate makeTemplate(StringTemplateGroup stg, ArrayEncodedValue encodedArray) {
StringTemplate template = stg.getInstanceOf("ArrayEncodedValue");
template.setAttribute("Value", getValue(stg, encodedArray));
return template;
}
public String getFormat() {
return "ArrayEncodedValue";
}
public Object getValue() {
List<EncodedValueAdaptor> encodedValues = new ArrayList<EncodedValueAdaptor>();
private static List<StringTemplate> getValue(StringTemplateGroup stg, ArrayEncodedValue encodedArray) {
List<StringTemplate> encodedValues = new ArrayList<StringTemplate>();
for (EncodedValue encodedValue: encodedArray.values) {
encodedValues.add(EncodedValueAdaptor.make(encodedValue));
encodedValues.add(EncodedValueAdaptor.make(stg, encodedValue));
}
return encodedValues;
}

20
baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/EncodedIndexedItemAdaptor.java
View File

@ -29,19 +29,13 @@
package org.jf.baksmali.Adaptors.EncodedValue;
import org.jf.baksmali.Adaptors.Reference.Reference;
import org.antlr.stringtemplate.StringTemplate;
import org.antlr.stringtemplate.StringTemplateGroup;
public class EncodedIndexedItemAdaptor extends EncodedValueAdaptor {
private Reference reference;
public EncodedIndexedItemAdaptor(Reference reference) {
this.reference = reference;
}
public String getFormat() {
return "EncodedIndexedItemReference";
}
public Object getValue() {
return reference;
public class EncodedIndexedItemAdaptor {
public static StringTemplate makeTemplate(StringTemplateGroup stg, Reference reference) {
StringTemplate template = stg.getInstanceOf("EncodedIndexedItemReference");
template.setAttribute("Value", reference);
return template;
}
}

41
baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/EncodedValueAdaptor.java
View File

@ -30,47 +30,46 @@ package org.jf.baksmali.Adaptors.EncodedValue;
import org.jf.dexlib.EncodedValue.*;
import org.jf.baksmali.Adaptors.Reference.*;
import org.antlr.stringtemplate.StringTemplate;
import org.antlr.stringtemplate.StringTemplateGroup;
public abstract class EncodedValueAdaptor {
public static EncodedValueAdaptor make(EncodedValue encodedValue) {
public static StringTemplate make(StringTemplateGroup stg, EncodedValue encodedValue) {
switch (encodedValue.getValueType()) {
case VALUE_ANNOTATION:
return new AnnotationEncodedValueAdaptor((AnnotationEncodedValue)encodedValue);
return AnnotationEncodedValueAdaptor.makeTemplate(stg, (AnnotationEncodedValue)encodedValue);
case VALUE_ARRAY:
return new ArrayEncodedValueAdaptor((ArrayEncodedValue)encodedValue);
return ArrayEncodedValueAdaptor.makeTemplate(stg, (ArrayEncodedValue)encodedValue);
case VALUE_BOOLEAN:
return new SimpleEncodedValueAdaptor(((BooleanEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((BooleanEncodedValue)encodedValue).value);
case VALUE_BYTE:
return new SimpleEncodedValueAdaptor(((ByteEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((ByteEncodedValue)encodedValue).value);
case VALUE_CHAR:
return new SimpleEncodedValueAdaptor(((CharEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((CharEncodedValue)encodedValue).value);
case VALUE_DOUBLE:
return new SimpleEncodedValueAdaptor(((DoubleEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((DoubleEncodedValue)encodedValue).value);
case VALUE_ENUM:
return new EnumEncodedValueAdaptor(new FieldReference(((EnumEncodedValue)encodedValue).value));
return EnumEncodedValueAdaptor.makeTemplate(stg,
new FieldReference(((EnumEncodedValue)encodedValue).value));
case VALUE_FIELD:
return new EncodedIndexedItemAdaptor(new FieldReference(((FieldEncodedValue)encodedValue).value));
return EncodedIndexedItemAdaptor.makeTemplate(stg, new FieldReference(((FieldEncodedValue)encodedValue).value));
case VALUE_FLOAT:
return new SimpleEncodedValueAdaptor(((FloatEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((FloatEncodedValue)encodedValue).value);
case VALUE_INT:
return new SimpleEncodedValueAdaptor(((IntEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((IntEncodedValue)encodedValue).value);
case VALUE_LONG:
return new SimpleEncodedValueAdaptor(((LongEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((LongEncodedValue)encodedValue).value);
case VALUE_METHOD:
return new EncodedIndexedItemAdaptor(new MethodReference(((MethodEncodedValue)encodedValue).value));
return EncodedIndexedItemAdaptor.makeTemplate(stg, new MethodReference(((MethodEncodedValue)encodedValue).value));
case VALUE_NULL:
return new SimpleEncodedValueAdaptor("null");
return SimpleEncodedValueAdaptor.makeTemplate(stg, "null");
case VALUE_SHORT:
return new SimpleEncodedValueAdaptor(((ShortEncodedValue)encodedValue).value);
return SimpleEncodedValueAdaptor.makeTemplate(stg, ((ShortEncodedValue)encodedValue).value);
case VALUE_STRING:
return new EncodedIndexedItemAdaptor(new StringReference(((StringEncodedValue)encodedValue).value));
return EncodedIndexedItemAdaptor.makeTemplate(stg, new StringReference(((StringEncodedValue)encodedValue).value));
case VALUE_TYPE:
return new EncodedIndexedItemAdaptor(new TypeReference(((TypeEncodedValue)encodedValue).value));
return EncodedIndexedItemAdaptor.makeTemplate(stg, new TypeReference(((TypeEncodedValue)encodedValue).value));
}
return null;
}
public abstract String getFormat();
public abstract Object getValue();
}

21
baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/EnumEncodedValueAdaptor.java
View File

@ -29,20 +29,13 @@
package org.jf.baksmali.Adaptors.EncodedValue;
import org.jf.baksmali.Adaptors.Reference.FieldReference;
import org.antlr.stringtemplate.StringTemplate;
import org.antlr.stringtemplate.StringTemplateGroup;
public class EnumEncodedValueAdaptor extends EncodedValueAdaptor {
private FieldReference fieldReference;
public EnumEncodedValueAdaptor(FieldReference fieldReference) {
this.fieldReference = fieldReference;
}
public String getFormat() {
return "EnumEncodedValue";
}
public Object getValue() {
return fieldReference;
public class EnumEncodedValueAdaptor {
public static StringTemplate makeTemplate(StringTemplateGroup stg, FieldReference fieldReference) {
StringTemplate template = stg.getInstanceOf("EnumEncodedValue");
template.setAttribute("Value", fieldReference);
return template;
}
}

32
baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/NullEncodedValueAdaptor.java
View File

@ -1,32 +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.EncodedValue;
public class NullEncodedValueAdaptor {
}

19
baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/SimpleEncodedValueAdaptor.java
View File

@ -28,18 +28,13 @@
package org.jf.baksmali.Adaptors.EncodedValue;
public class SimpleEncodedValueAdaptor extends EncodedValueAdaptor {
private Object value;
import org.antlr.stringtemplate.StringTemplateGroup;
import org.antlr.stringtemplate.StringTemplate;
public SimpleEncodedValueAdaptor(Object value) {
this.value = value;
}
public String getFormat() {
return "SimpleEncodedValue";
}
public Object getValue() {
return value;
public class SimpleEncodedValueAdaptor {
public static StringTemplate makeTemplate(StringTemplateGroup stg, Object value) {
StringTemplate template = stg.getInstanceOf("SimpleEncodedValue");
template.setAttribute("Value", value);
return template;
}
}

2
baksmali/src/main/java/org/jf/baksmali/Adaptors/FieldDefinition.java
View File

@ -51,7 +51,7 @@ public class FieldDefinition {
template.setAttribute("Annotations", getAnnotations(stg, annotationSet));
if (initialValue != null) {
template.setAttribute("InitialValue", EncodedValueAdaptor.make(initialValue));
template.setAttribute("InitialValue", EncodedValueAdaptor.make(stg, initialValue));
}
return template;

35
baksmali/src/main/resources/templates/templates/baksmali.stg
View File

@ -68,7 +68,7 @@ annotation(Visibility, AnnotationType, Elements) ::=
<<
.annotation <Visibility> <Reference(AnnotationType)>
<if(Elements)>
<Elements: AnnotationElement(it); separator="\n">
<Elements; separator="\n">
<endif>
<if(Elements)>
@ -81,7 +81,7 @@ annotation(Visibility, AnnotationType, Elements) ::=
field(AccessFlags, FieldName, FieldType, Annotations, InitialValue) ::=
<<
.field <AccessFlags: {<it> }><FieldName>:<FieldType><if(InitialValue)> = <InitialValue: EncodedValue(it)><endif>
.field <AccessFlags: {<it> }><FieldName>:<FieldType><if(InitialValue)> = <InitialValue><endif>
<if(Annotations)>
<Annotations; separator="\n\n">
.end field
@ -359,41 +359,36 @@ TypeReference(TypeReference) ::=
EncodedValue(EncodedValue) ::=
SimpleEncodedValue(Value) ::=
<<
<(EncodedValue.Format)(EncodedValue)>
<Value>
>>
SimpleEncodedValue(EncodedValue) ::=
EncodedIndexedItemReference(Value) ::=
<<
<EncodedValue.Value>
<Reference(Value)>
>>
EncodedIndexedItemReference(EncodedValue) ::=
<<
<Reference(EncodedValue.Value)>
>>
ArrayEncodedValue(EncodedValue) ::=
ArrayEncodedValue(Value) ::=
<<
{
<EncodedValue.Value: EncodedValue(it); separator=",\n">
<Value; separator=",\n">
}
>>
EnumEncodedValue(EncodedValue) ::=
EnumEncodedValue(Value) ::=
<<
.enum <Reference(EncodedValue.Value)>
.enum <Reference(Value)>
>>
AnnotationEncodedValue(EncodedValue) ::=
AnnotationEncodedValue(AnnotationType, Elements) ::=
<<
.subannotation <Reference(EncodedValue.AnnotationType)>
<EncodedValue.Elements: AnnotationElement(it); separator="\n">
.subannotation <Reference(AnnotationType)>
<Elements; separator="\n">
.end subannotation
>>
AnnotationElement(AnnotationElement) ::=
AnnotationElement(Name, Value) ::=
<<
<AnnotationElement.Name> = <EncodedValue(AnnotationElement.Value)>
<Name> = <Value>
>>