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

git-svn-id: https://smali.googlecode.com/svn/trunk@368 55b6fa8a-2a1e-11de-a435-ffa8d773f76a

baksmali/src/main/java/org/jf/baksmali/Adaptors/AnnotationAdaptor.java

@@ -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());
+        AnnotationEncodedValueAdaptor.setAttributesForAnnotation(template, annotationItem.getEncodedAnnotation());
-        template.setAttribute("Elements", aeva.getElements());
 
         return template;
     }

baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/AnnotationEncodedValueAdaptor.java

@@ -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 {
+public abstract class AnnotationEncodedValueAdaptor {
-    private AnnotationEncodedSubValue encodedAnnotation;
+    
-
+    public static StringTemplate makeTemplate(StringTemplateGroup stg, AnnotationEncodedSubValue encodedAnnotation) {
-    public AnnotationEncodedValueAdaptor(AnnotationEncodedSubValue encodedAnnotation) {
+        StringTemplate template = stg.getInstanceOf("AnnotationEncodedValue");
-        this.encodedAnnotation = encodedAnnotation;
+        template.setAttribute("AnnotationType", new TypeReference(encodedAnnotation.annotationType));
+        template.setAttribute("Elements", getElements(stg, encodedAnnotation));
+        return template;
     }
 
-    public String getFormat() {
+    public static void setAttributesForAnnotation(StringTemplate template,
-        return "AnnotationEncodedValue";
+                                                  AnnotationEncodedSubValue encodedAnnotation) {
+        template.setAttribute("AnnotationType", new TypeReference(encodedAnnotation.annotationType));
+        template.setAttribute("Elements", getElements(template.getGroup(), encodedAnnotation));
     }
 
-    public Object getValue() {
+    private static List<String> getElements(StringTemplateGroup stg,
-        return this;
+                                                              AnnotationEncodedSubValue encodedAnnotation) {
-    }
+        List<String> elements = new ArrayList<String>();
-
-    public TypeReference getAnnotationType() {
-        return new TypeReference(encodedAnnotation.annotationType);
-    }
-
-    public List<AnnotationElementAdaptor> getElements() {
-        List<AnnotationElementAdaptor> elements = new ArrayList<AnnotationElementAdaptor>();
 
         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 static class AnnotationElementAdaptor {
-        private StringIdItem name;
+        public static String toString(StringTemplateGroup stg, StringIdItem name, EncodedValue value) {
-        private EncodedValue value;
+            StringTemplate template = stg.getInstanceOf("AnnotationElement");
-
+            template.setAttribute("Name", name);
-        public AnnotationElementAdaptor(StringIdItem name, EncodedValue value) {
+            template.setAttribute("Value", EncodedValueAdaptor.make(stg, value));
-            this.name = name;
+            return template.toString();
-            this.value = value;
-        }
-
-        public String getName() {
-            return name.getStringValue();
-        }
-
-        public EncodedValueAdaptor getValue() {
-            return EncodedValueAdaptor.make(value);
         }
     }
 }

baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/ArrayEncodedValueAdaptor.java

@@ -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 {
+public class ArrayEncodedValueAdaptor {
-    private ArrayEncodedValue encodedArray;
+    public static StringTemplate makeTemplate(StringTemplateGroup stg, ArrayEncodedValue encodedArray) {
-
+        StringTemplate template = stg.getInstanceOf("ArrayEncodedValue");
-    public ArrayEncodedValueAdaptor(ArrayEncodedValue encodedArray) {
+        template.setAttribute("Value", getValue(stg, encodedArray));
-        this.encodedArray = encodedArray;        
+        return template;
     }
 
-    public String getFormat() {
+    private static List<StringTemplate> getValue(StringTemplateGroup stg, ArrayEncodedValue encodedArray) {
-        return "ArrayEncodedValue";
+        List<StringTemplate> encodedValues = new ArrayList<StringTemplate>();
-    }
-
-    public Object getValue() {
-        List<EncodedValueAdaptor> encodedValues = new ArrayList<EncodedValueAdaptor>();
 
         for (EncodedValue encodedValue: encodedArray.values) {
-            encodedValues.add(EncodedValueAdaptor.make(encodedValue));
+            encodedValues.add(EncodedValueAdaptor.make(stg, encodedValue));
         }
         return encodedValues;
     }

baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/EncodedIndexedItemAdaptor.java

@@ -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 {
+public class EncodedIndexedItemAdaptor {
-    private Reference reference;
+    public static StringTemplate makeTemplate(StringTemplateGroup stg, Reference reference) {
-
+        StringTemplate template = stg.getInstanceOf("EncodedIndexedItemReference");
-    public EncodedIndexedItemAdaptor(Reference reference) {
+        template.setAttribute("Value", reference);
-        this.reference = reference;
+        return template;
-    }
-
-    public String getFormat() {
-        return "EncodedIndexedItemReference";
-    }
-
-    public Object getValue() {
-        return reference;
     }
 }

baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/EncodedValueAdaptor.java

@@ -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();
 }

baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/EnumEncodedValueAdaptor.java

@@ -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 {
+public class EnumEncodedValueAdaptor {
-    private FieldReference fieldReference;
+    public static StringTemplate makeTemplate(StringTemplateGroup stg, FieldReference fieldReference) {
-
+        StringTemplate template = stg.getInstanceOf("EnumEncodedValue");
-    public EnumEncodedValueAdaptor(FieldReference fieldReference) {
+        template.setAttribute("Value", fieldReference);
-        this.fieldReference = fieldReference;
+        return template;
-    }
-
-
-    public String getFormat() {
-        return "EnumEncodedValue";
-    }
-
-    public Object getValue() {
-        return fieldReference;
     }
 }

baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/NullEncodedValueAdaptor.java

@@ -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 {
-}

baksmali/src/main/java/org/jf/baksmali/Adaptors/EncodedValue/SimpleEncodedValueAdaptor.java

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

baksmali/src/main/java/org/jf/baksmali/Adaptors/FieldDefinition.java

@@ -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;

baksmali/src/main/resources/templates/templates/baksmali.stg

@@ -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) ::=
+ArrayEncodedValue(Value) ::=
-<<
-<Reference(EncodedValue.Value)>
->>
-
-ArrayEncodedValue(EncodedValue) ::=
 <<
 {
-    <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)>
+.subannotation <Reference(AnnotationType)>
-    <EncodedValue.Elements: AnnotationElement(it); separator="\n">
+    <Elements; separator="\n">
 .end subannotation
 >>
 
-AnnotationElement(AnnotationElement) ::=
+AnnotationElement(Name, Value) ::=
 <<
-<AnnotationElement.Name> = <EncodedValue(AnnotationElement.Value)>
+<Name> = <Value>
 >>