*

* Project Info:  http://www.xmlvm.org

*

* This program is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation; either version 2.1 of the License, or

* (at your option) any later version.

*

* This library is distributed in the hope that it will be useful, but

* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public

* License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,

* USA.

*/

* This OutputProcess emits XMLVM code containing register-based DEX

* instructions (XMLVM-DEX).

* <p>

* Android's own DX compiler tool is used to parse class files and to create the

* register-based DEX code in-memory which is then converted to XML.

*/

  /**

   * The references found inside the class file are annotated with "kind"

   * information: self means reference to the class itself super means

   * reference to the superclass interface means reference to an implemented

   * interface usage is all other uses

   */

  private static enum ReferenceKind

  {

    SUPER_CLASS("super"), INTERFACE("interface"), SELF("self"), USAGE("usage");

    private final String human;

    private ReferenceKind(String human)

    {

      this.human= human;

    }

    public String toHuman()

    {

      return human;

    }

  }

  /**

   * Pair of type name and its super type name.

   */

  private static class TypePlusSuperType

  {

    public final String typeName;

    public final String superTypeName;

    public TypePlusSuperType(String typeName, String superTypeName)

    {

      this.typeName= typeName;

      this.superTypeName= superTypeName;

    }

  }

  /**

   * A little helper class that contains package- and class name.

   */

  private static class PackagePlusClassName

  {

    public String packageName= "";

    public String className= "";

    public PackagePlusClassName(String className)

    {

      this.className= className;

    }

    public PackagePlusClassName(String packageName, String className)

    {

      this.packageName= packageName;

      this.className= className;

    }

    public String toString()

    {

      if (packageName.isEmpty())

      {

        return className;

      }

      else

      {

        return packageName + "." + className;

      }

    }

  }

  /**

   * Little helper class for keeping a target address and the info about

   * whether this target should split a try-catch block.

   */

  private static class Target

  {

    int address;

    boolean requiresSplit;

    public Target(int address, boolean requiresSplit)

    {

      this.address= address;

      this.requiresSplit= requiresSplit;

    }

    public boolean equals(Object obj)

    {

      if (obj instanceof Target)

      {

        Target otherTarget= (Target) obj;

        return this.address == otherTarget.address;

      }

      else

      {

        return false;

      }

    }

    public int hashCode()

    {

      return address;

    }

  }

  private static final String TAG= DEXmlvmOutputProcess.class.getSimpleName();

  private static final boolean LOTS_OF_DEBUG= false;

  private static final boolean REF_LOGGING= false;

  private static final String JLO= "java.lang.Object";

  private static final String DEXMLVM_ENDING= ".dexmlvm";

  private static final Namespace NS_XMLVM= XmlvmResource.nsXMLVM;

  private static final Namespace NS_DEX= Namespace.getNamespace("dex", "http://xmlvm.org/dex");

  private static final UniversalFile RED_LIST_FILE= null;

  private boolean useRedList= true;

  private boolean noGenRedClass= false;

  private boolean enableProxyReplacement= true;

  /**

   * Green classes are classes that are OK to translate. Red classes are

   * excluded from the compilation.

   */

  private static Set<String> redTypes= null;

  private static Set<String> greenTypes= null;

  private Element lastDexInstruction= null;

  private ResourceCache cache= ResourceCache.getCache(DEXmlvmOutputProcess.class.getName());

  private List<OutputFile> filesFromCache= new ArrayList<OutputFile>();

  private static final Set<String> INVALID_REFERENCES= Collections.unmodifiableSet(new HashSet<String>(Arrays.asList("void", "char", "float", "double", "int", "boolean", "short", "byte", "float", "long", "null")));

  /**

   * Initializes the {@link DEXmlvmOutputProcess}.

   *

   * @param arguments

   */

  public DEXmlvmOutputProcess(Arguments arguments)

  {

    this(arguments, true, true);

  }

  /**

   * Use this constructor, if you need to be able to generate bytecode even

   * from a red-listed file.

   *

   * @param arguments

   *            The default arguments.

   * @param noGenRedClass

   *            True, if a red-listed class should not be generated (default).

   * @param enableProxyReplacement

   *            Whether classes for which proxies exist should be replaced.

   *            This is set to "false" by the LibraryLoader, as it might have

   *            loaded a proxy class already, if it exists.

   */

  public DEXmlvmOutputProcess(Arguments arguments, boolean noGenRedClass, boolean enableProxyReplacement)

  {

    super(arguments);

    // We can either read class files directly or use the

    // JavaByteCodeOutputProcess to use generated bytecode as the input.

    addSupportedInput(ClassInputProcess.class);

    addSupportedInput(JavaByteCodeOutputProcess.class);

    if (redTypes == null)

    {

      UniversalFile redlist= RED_LIST_FILE;

      if (arguments.option_redlist() != null)

      {

        redlist= UniversalFileCreator.createFile(new File(arguments.option_redlist()));

      }

      redTypes= ClassListLoader.loadRedlist(redlist);//initializeClassList(redlist);

    }

    if (greenTypes == null && arguments.option_greenlist() != null)

    {

      greenTypes= ClassListLoader.loadGreenlist(UniversalFileCreator.createFile(new File(arguments.option_greenlist())));

      UniversalFile defaultGreenList= UniversalFileCreator.createFile("/lib/greenlist.txt", "lib/greenlist.txt");

      if (defaultGreenList != null)

      { // Add defaults, if they have been packaged

        greenTypes.addAll(ClassListLoader.loadGreenlist(defaultGreenList));

      }

    }

    this.enableProxyReplacement= enableProxyReplacement;

    this.noGenRedClass= noGenRedClass;

    // Red type elimination should only be performed when load_dependencies

    // is enabled or we are generating c wrappers.

    this.useRedList= (arguments.option_load_dependencies() && !arguments.option_disable_load_dependencies()) || arguments.option_target() == Targets.GENCWRAPPERS || arguments.option_target() == Targets.GENCSHARPWRAPPERS || arguments.option_target() == Targets.SDLANDROID;

  }

  public boolean processPhase1(BundlePhase1 bundle)

  {

    for (OutputFile preOutputFile : bundle.getOutputFiles())

    {

      String resourceName= preOutputFile.getOrigin();

      long lastModified= preOutputFile.getLastModified();

      OutputFile outputFile= null;

      // Check whether we can get the file from memory or disk cache.

      if (!arguments.option_no_cache() && cache.contains(resourceName, lastModified))

      {

        Log.debug(TAG, "Getting resource from cache: " + resourceName);

        outputFile= new OutputFile(cache.get(resourceName, lastModified), lastModified);

        outputFile.setLocation(preOutputFile.getLocation());

        outputFile.setFileName(preOutputFile.getFileName());

        filesFromCache.add(outputFile);

      }

      else

      {

        outputFile= generateDEXmlvmFile(preOutputFile, bundle);

        if (outputFile != null && !arguments.option_no_cache())

        {

          cache.put(resourceName, lastModified, outputFile.getDataAsBytes());

        }

      }

      if (isTargetProcess && outputFile != null)

      {

        outputFile.setOrigin(preOutputFile.getOrigin());

        bundle.addOutputFile(outputFile);

      }

      bundle.removeOutputFile(preOutputFile);

    }

    addResourcesFromCachedFiles(bundle);

    return true;

  }

  public boolean processPhase2(BundlePhase2 bundle)

  {

    return true;

  }

  private void addResourcesFromCachedFiles(BundlePhase1 resources)

  {

    for (OutputFile cachedFile : filesFromCache)

    {

      resources.addResource(XmlvmResource.fromFile(cachedFile));

    }

  }

  public OutputFile generateDEXmlvmFile(final OutputFile classFile, BundlePhase1 resources)

  {

    return generateDEXmlvmFile(classFile, false, resources);

  }

  @SuppressWarnings("unchecked")

  private OutputFile generateDEXmlvmFile(final OutputFile classFile, boolean proxy, BundlePhase1 resources)

  {

    //        Log.debug(TAG, "DExing:" + classFile.getFileName());

    DirectClassFile directClassFile= new DirectClassFile(classFile.getDataAsBytes(), classFile.getFileName(), false);

    directClassFile.setAttributeFactory(StdAttributeFactory.THE_ONE);

    try

    {

      directClassFile.getMagic();

    }

    catch (ParseException ex)

    {

      Log.debug(TAG, "Could not parse class.");

      return null;

    }

    String packagePlusClassName= directClassFile.getThisClass().getClassType().toHuman();

    // We want to prevent "red" classes from being loaded. If the there is a

    // green class list, and this process is run by a library loaded, then

    // we expect the class to be a library class. Hence, it must be in the

    // green class list. If it's not, we discard it.

    if (noGenRedClass && isRedType(packagePlusClassName))

    {

      Log.debug("Discarding red class: " + packagePlusClassName);

      return null;

    }

    if (enableProxyReplacement && !proxy && LibraryLoader.hasProxy(packagePlusClassName))

    {

      return generateDEXmlvmFile(new OutputFile(LibraryLoader.getProxy(packagePlusClassName)), true, resources);

    }

    // If the class has the XMLVMIgnore annotation, it will be skipped.

    if (hasAnnotation(directClassFile.getAttributes(), XMLVMIgnore.class))

    {

      return null;

    }

    // If the class is synthetic, we don't want to generate code from it

    // while generating the wrapper code.

    if (AccessFlags.isSynthetic(directClassFile.getAccessFlags()) && (arguments.option_target() == Targets.GENCWRAPPERS || arguments.option_target() == Targets.GENCSHARPWRAPPERS))

    {

      return null;

    }

    // This is for auxiliary analysis. We record all the types that are

    // referenced.

    Map<String, ReferenceKind> referencedTypes= new TreeMap<String, DEXmlvmOutputProcess.ReferenceKind>();

    final Document document= createDocument();

    TypePlusSuperType type= process(directClassFile, document.getRootElement(), referencedTypes);

    String className= type.typeName.replace('.', '_');

    String jClassName= document.getRootElement().getChild("class", InstructionProcessor.vm).getAttributeValue("name");

    List<Element> methods= (List<Element>) document.getRootElement().getChild("class", InstructionProcessor.vm).getChildren("method", InstructionProcessor.vm);

    if (arguments.option_enable_ref_counting())

    {

      if (REF_LOGGING)

      {

        Log.debug(TAG + "-ref", "Processing class: " + jClassName);

      }

      // We now need to mark up the code with retains/releases.

      ReferenceCounting refCounting= new ReferenceCounting();

      for (Element e : methods)

      {

        if (REF_LOGGING)

        {

          Log.debug(TAG + "-ref", "Processing method: " + e.getAttributeValue("name"));

        }

        try

        {

          refCounting.process(e);

        }

        catch (ReferenceCountingException ex)

        {

          Log.error(TAG + "-ref", "Processing method: " + e.getAttributeValue("name"));

          Log.error(TAG + "-ref", "Failed while processing: " + ex.getMessage() + " in " + jClassName);

          return null;

        }

        catch (DataConversionException ex)

        {

          Log.error(TAG + "-ref", "Processing method: " + e.getAttributeValue("name"));

          Log.error(TAG + "-ref", "Failed while processing: " + ex.getMessage() + " in " + jClassName);

          return null;

        }

        if (REF_LOGGING)

        {

          Log.debug(TAG + "-ref", "Done with " + e.getAttributeValue("name"));

        }

      }

      if (REF_LOGGING)

      {

        Log.debug(TAG + "-ref", "Done processing methods!");

      }

    }

    Element classElement= document.getRootElement().getChild("class", InstructionProcessor.vm);

    // If the class has the XMLVMSkeletonOnly annotation we add it to the

    // class element, so that the stylesheet can use the information.

    boolean skeletonOnly= hasAnnotation(directClassFile.getAttributes(), XMLVMSkeletonOnly.class);

    if (skeletonOnly)

    {

      classElement.setAttribute("skeletonOnly", "true");

      Annotation skeletonAnnotation= getAnnotation(directClassFile.getAttributes(), XMLVMSkeletonOnly.class);

      for (NameValuePair pair : skeletonAnnotation.getNameValuePairs())

      {

        if (pair.getName().getString().equals("references"))

        {

          CstArray.List clazzArrayList= ((CstArray) pair.getValue()).getList();

          for (int i= 0; i < clazzArrayList.size(); i++)

          {

            addReference(referencedTypes, ((CstType) clazzArrayList.get(i)).toHuman(), ReferenceKind.USAGE);

          }

        }

      }

    }

    Annotation delegateAnnotation= getAnnotation(directClassFile.getAttributes(), XMLVMDelegate.class);

    if (delegateAnnotation != null)

    {

      for (NameValuePair pair : delegateAnnotation.getNameValuePairs())

      {

        if (pair.getName().getString().equals("protocolType"))

        {

          String protocolType= ((CstString) pair.getValue()).getString().getString();

          classElement.setAttribute("delegateProtocolType", protocolType);

        }

      }

    }

    addReferences(document, referencedTypes);

    XmlvmResource resource= new XmlvmResource(Type.DEX, document);

    // If the class has the XMLVmSkeletonOnly annotation we add a tag to the

    // resource, so that later processes can use this information.

    if (skeletonOnly)

    {

      resource.setTag(Tag.SKELETON_ONLY, "true");

    }

    resources.addResource(resource);

    String fileName= className + DEXMLVM_ENDING;

    // Some processes depending on this processor don't actually need the

    // String version of the DEXMLVM files. As generating them takes some

    // time, we want to make sure we only generate it when necessary.

    OutputFile result= new OutputFile(new DelayedXmlvmSerializationProvider(document));

    result.setLocation(arguments.option_out());

    result.setFileName(fileName);

    return result;

  }

  private void addReference(Map<String, ReferenceKind> referenceMap, String reference, ReferenceKind type)

  {

    String baseReferencedType= reference;

    int j= baseReferencedType.indexOf('[');

    if (j != -1)

    {

      // Remove array type

      baseReferencedType= baseReferencedType.substring(0, j);

    }

    if (!INVALID_REFERENCES.contains(baseReferencedType))

    {

      ReferenceKind oldType= referenceMap.get(baseReferencedType);

      if (oldType == null || oldType.compareTo(type) > 0)

      {

        if (isRedType(baseReferencedType))

        {

          if (type != ReferenceKind.USAGE)

          {

            //                        Log.error("Red Class " + reference + " referenced as " + type.toHuman()

            //                                + "\n" + "References: " + referenceMap);

            //                        throw new RuntimeException("Build contains errors. See above. Failed.");

          }

          else

          {

            // Log.warn("Red Class " + reference + " referenced as "

            // + type.toHuman()

            // + " ignoring");

            referenceMap.remove(baseReferencedType);

          }

        }

        else

        {

          referenceMap.put(baseReferencedType, type);

        }

      }

    }

  }

  /**

   * Adds the given set of references to the given XMLVM document.

   */

  private static void addReferences(Document xmlvmDocument, Map<String, ReferenceKind> referencedTypes)

  {

    Element references= new Element("references", NS_XMLVM);

    for (Map.Entry<String, ReferenceKind> referencedType : referencedTypes.entrySet())

    {

      Element reference= new Element("reference", NS_XMLVM);

      reference.setAttribute("name", referencedType.getKey());

      reference.setAttribute("kind", referencedType.getValue().toHuman());

      references.addContent(reference);

    }

    xmlvmDocument.getRootElement().addContent(references);

  }

  /**

   * Returns whether the given class is a red class. This method will return

   * false, if the config file has not been provided.

   *

   * @param packagePlusClassName

   *            e.g. "java.lang.Object".

   * @return whether the class is a red class, that should be avoided.

   */

  private boolean isRedType(String packagePlusClassName)

  {

    return packagePlusClassName.contains("org.apache.bcel");

    //        if (!useRedList) {

    //            return false;

    //        }

    //        // In case packagePlusClassName is an array, perform the red-class-test

    //        // on the base type

    //        int i = packagePlusClassName.indexOf('[');

    //        String baseType = i == -1 ? packagePlusClassName : packagePlusClassName.substring(0, i);

    //       

    //        if (greenTypes != null) {

    //            return !greenTypes.contains(baseType);

    //        }

    //       

    //        return redTypes != null && redTypes.contains(baseType);

  }

  /**

   * Converts a class name in the form of a/b/C into a

   * {@link PackagePlusClassName} object.

   *

   */

  private static PackagePlusClassName parseClassName(String packagePlusClassName)

  {

    int lastSlash= packagePlusClassName.lastIndexOf('/');

    if (lastSlash == -1)

    {

      return new PackagePlusClassName(packagePlusClassName);

    }

    String className= packagePlusClassName.substring(lastSlash + 1);

    String packageName= packagePlusClassName.substring(0, lastSlash).replace('/', '.');

    return new PackagePlusClassName(packageName, className);

  }

  /**

   * Creates a basic XMLVM document.

   */

  private static Document createDocument()

  {

    Element root= new Element("xmlvm", NS_XMLVM);

    root.addNamespaceDeclaration(NS_DEX);

    Document document= new Document();

    document.addContent(root);

    return document;

  }

  /**

   * Process the given Java Class file and add the classes to the given root.

   *

   * @param cf

   *            the class file to process

   * @param root

   *            the root element to append the classes to

   * @param referencedTypes

   *            will be filled with the types references in this class file

   * @return the class name for the DEXMLVM file

   */

  private TypePlusSuperType process(DirectClassFile cf, Element root, Map<String, ReferenceKind> referencedTypes)

  {

    boolean skeletonOnly= hasAnnotation(cf.getAttributes(), XMLVMSkeletonOnly.class);

    Element classElement= processClass(cf, root, referencedTypes);

    processFields(cf.getFields(), classElement, referencedTypes, skeletonOnly);

    MethodList methods= cf.getMethods();

    int sz= methods.size();

    for (int i= 0; i < sz; i++)

    {

      Method one= methods.get(i);

      if (hasAnnotation(one.getAttributes(), XMLVMIgnore.class))

      {

        // If this method has the @XMLVMIgnore annotation, we just

        // simply ignore it.

        continue;

      }

      if (skeletonOnly && (one.getAccessFlags() & (AccessFlags.ACC_PRIVATE | AccessFlags.ACC_SYNTHETIC)) != 0)

      {

        // We only want to generate skeletons. This method is private or

        // synthetic so simply ignore it.

        continue;

      }

      try

      {

        processMethod(one, cf, classElement, referencedTypes, skeletonOnly);

      }

      catch (RuntimeException ex)

      {

        String msg= "...while processing " + one.getName().toHuman() + " " + one.getDescriptor().toHuman();

        throw ExceptionWithContext.withContext(ex, msg);

      }

    }

    String className= classElement.getAttributeValue("name");

    String superClassName= classElement.getAttributeValue("extends");

    return new TypePlusSuperType(className, superClassName);

  }

  /**

   * Creates an XMLVM element for the given type and appends it to the given

   * root element.

   *

   * @param cf

   *            the {@link DirectClassFile} instance of this class

   * @param root

   *            the root element to append the generated element to

   * @param referencedTypes

   *            will be filled with the types references in this class file

   * @return the generated element

   */

  private Element processClass(DirectClassFile cf, Element root, Map<String, ReferenceKind> referencedTypes)

  {

    Element classElement= new Element("class", NS_XMLVM);

    CstType type= cf.getThisClass();

    PackagePlusClassName parsedClassName= parseClassName(type.getClassType().getClassName());

    addReference(referencedTypes, parsedClassName.toString(), ReferenceKind.SELF);

    classElement.setAttribute("name", parsedClassName.className);

    classElement.setAttribute("package", parsedClassName.packageName);

    String superClassName= "";

    // if we are an innerclass add the enclosingMethod

    AttEnclosingMethod enclosingMethodAnnotation= (AttEnclosingMethod) cf.getAttributes().findFirst(AttEnclosingMethod.ATTRIBUTE_NAME);

    if (enclosingMethodAnnotation != null)

    {

      CstType enclosingClass= enclosingMethodAnnotation.getEnclosingClass();

      CstNat enclosingMethod= enclosingMethodAnnotation.getMethod();

      if (enclosingClass != null)

      {

        addReference(referencedTypes, enclosingClass.toHuman(), ReferenceKind.USAGE);

        classElement.setAttribute("enclosingClass", enclosingClass.toHuman());

      }

      if (enclosingMethod != null)

      {

        classElement.setAttribute("enclosingMethod", enclosingMethod.toHuman());

      }

    }

    // get signature annotation if availabke

    AttSignature signatureAnnotation= (AttSignature) cf.getAttributes().findFirst(AttSignature.ATTRIBUTE_NAME);

    if (signatureAnnotation != null)

    {

      classElement.setAttribute("signature", signatureAnnotation.getSignature().toHuman());

    }

    // This can happen for java.lang.Object.

    if (cf.getSuperclass() != null)

    {

      superClassName= parseClassName(cf.getSuperclass().getClassType().getClassName()).toString();

      addReference(referencedTypes, superClassName, ReferenceKind.SUPER_CLASS);

    }

    classElement.setAttribute("extends", superClassName);

    processAccessFlags(cf.getAccessFlags(), classElement);

    TypeList interfaces= cf.getInterfaces();

    if (interfaces.size() > 0)

    {

      String interfaceList= "";

      for (int i= 0; i < interfaces.size(); ++i)

      {

        if (i > 0)

        {

          interfaceList+= ",";

        }

        String interfaceName= parseClassName(interfaces.getType(i).getClassName()).toString();

        interfaceList+= interfaceName;

        addReference(referencedTypes, interfaceName, ReferenceKind.INTERFACE);

      }

      classElement.setAttribute("interfaces", interfaceList);

    }

    root.addContent(classElement);

    return classElement;

  }

  /**

   * Processes the fields and adds corresponding elements to the class

   * element.

   *

   * @param skeletonOnly

   */

  private void processFields(FieldList fieldList, Element classElement, Map<String, ReferenceKind> referencedTypes, boolean skeletonOnly)

  {

    for (int i= 0; i < fieldList.size(); ++i)

    {

      Field field= fieldList.get(i);

      if (hasAnnotation(field.getAttributes(), XMLVMIgnore.class))

      {

        // If this field has the @XMLVMIgnore annotation, we just

        // simply ignore it.

        continue;

      }

      if (skeletonOnly && (field.getAccessFlags() & (AccessFlags.ACC_PRIVATE | AccessFlags.ACC_SYNTHETIC)) != 0)

      {

        // This field is private or synthetic and we want to generate

        // only a skeleton, so we just simply ignore it.

        continue;

      }

      Element fieldElement= new Element("field", NS_XMLVM);

      fieldElement.setAttribute("name", field.getName().toHuman());

      String fieldType= field.getNat().getFieldType().toHuman();

      if (isRedType(fieldType))

      {

        fieldType= JLO;

      }

      else

      {

        addReference(referencedTypes, fieldType, ReferenceKind.USAGE);

      }

      fieldElement.setAttribute("type", fieldType);

      TypedConstant value= field.getConstantValue();

      if (value != null)

      {

        String constValue= null;

        if (fieldType.equals("java.lang.String"))

        {

          constValue= ((CstString) value).getString().getString();

          encodeString(fieldElement, constValue);

        }

        else

        {

          constValue= value.toHuman();

          fieldElement.setAttribute("value", constValue);

        }

      }

      processAccessFlags(field.getAccessFlags(), fieldElement);

      classElement.addContent(fieldElement);

    }

  }

  /**

   * Debugging use: Builds a catch-table in XML.

   */

  private void processCatchTable(CatchTable catchTable, Element codeElement)

  {

    if (catchTable.size() == 0)

    {

      return;

    }

    Element catchTableElement= new Element("catches", NS_DEX);

    for (int i= 0; i < catchTable.size(); ++i)

    {

      Entry entry= catchTable.get(i);

      Element entryElement= new Element("entry", NS_DEX);

      entryElement.setAttribute("start", String.valueOf(entry.getStart()));

      entryElement.setAttribute("end", String.valueOf(entry.getEnd()));

      CatchHandlerList catchHandlers= entry.getHandlers();

      for (int j= 0; j < catchHandlers.size(); ++j)

      {

        com.android.dx.dex.code.CatchHandlerList.Entry handlerEntry= catchHandlers.get(j);

        String exceptionType= handlerEntry.getExceptionType().toHuman();

        // We can remove the exception because a red type exception

        // will never be created or thrown.

        // This change is in sync with the one in processMethod.

        if (!isRedType(exceptionType))

        {

          Element handlerElement= new Element("handler", NS_DEX);

          handlerElement.setAttribute("type", exceptionType);

          handlerElement.setAttribute("target", String.valueOf(handlerEntry.getHandler()));

          entryElement.addContent(handlerElement);

        }

      }

      catchTableElement.addContent(entryElement);

    }

    codeElement.addContent(catchTableElement);

  }

  private void addDelegateElement(Method method, Element methodElement)

  {

    Annotation delegateAnnotation= getAnnotation(method.getAttributes(), XMLVMDelegateMethod.class);

    if (delegateAnnotation != null)

    {

      Element delegateMethodElement= new Element("delegateMethod", NS_XMLVM);

      methodElement.addContent(delegateMethodElement);

      for (NameValuePair pair : delegateAnnotation.getNameValuePairs())

      {

        String attrName= pair.getName().getString();

        if (attrName.equals("selector"))

        {

          String selector= ((CstString) pair.getValue()).getString().getString();

          delegateMethodElement.setAttribute("selector", selector);

        }

        else if (attrName.equals("params"))

        {

          CstArray.List paramList= ((CstArray) pair.getValue()).getList();

          for (int i= 0; i < paramList.size(); i++)

          {

            Element paramElement= new Element("param", NS_XMLVM);

            delegateMethodElement.addContent(paramElement);

            Annotation paramsAnnotation= ((CstAnnotation) paramList.get(i)).getAnnotation();

            for (NameValuePair paramsPair : paramsAnnotation.getNameValuePairs())

            {

              String paramsAttrName= paramsPair.getName().getString();

              if (paramsAttrName.equals("type"))

              {

                String type= ((CstString) paramsPair.getValue()).getString().getString();

                paramElement.setAttribute("type", type);

              }

              else if (paramsAttrName.equals("name"))

              {

                String name= ((CstString) paramsPair.getValue()).getString().getString();

                paramElement.setAttribute("name", name);

              }

              else if (paramsAttrName.equals("isSource"))

              {

                boolean isSource= ((CstBoolean) paramsPair.getValue()).getValue();

                paramElement.setAttribute("isSource", Boolean.toString(isSource));

              }

              else if (paramsAttrName.equals("isStruct"))

              {

                boolean isStruct= ((CstBoolean) paramsPair.getValue()).getValue();

                paramElement.setAttribute("isStruct", Boolean.toString(isStruct));

              }

              else if (paramsAttrName.equals("convert"))

              {

                boolean convert= ((CstBoolean) paramsPair.getValue()).getValue();

                paramElement.setAttribute("convert", Boolean.toString(convert));

              }

            }

          }

        }

      }

    }

  }

  /**

   * Creates an XMLVM element for the given method and appends it to the given

   * class element.

   * <p>

   * This method is roughly based on

   * {@link CfTranslator#translate(String, byte[], com.android.dx.dex.cf.CfOptions)}

   *

   * @param method

   *            the method to create the element for

   * @param classElement

   *            the class element to append the generated element to

   * @param cf

   *            the class file where this method was originally defined in

   * @param referencedTypes

   *            will be filled with the types references in this class file

   */

  private void processMethod(Method method, DirectClassFile cf, Element classElement, Map<String, ReferenceKind> referencedTypes, boolean skeletonOnly)

  {

    final boolean localInfo= true;

    final int positionInfo= PositionList.LINES;

    CstMethodRef meth= new CstMethodRef(method.getDefiningClass(), method.getNat());

    // Extract flags for this method.

    int accessFlags= method.getAccessFlags();

    boolean isNative= AccessFlags.isNative(accessFlags);

    boolean isStatic= AccessFlags.isStatic(accessFlags);

    boolean isAbstract= AccessFlags.isAbstract(accessFlags);

    // Create XMLVM element for this method

    Element methodElement= new Element("method", NS_XMLVM);

    methodElement.setAttribute("name", method.getName().getString());

    methodElement.setAttribute("signature", method.getNat().getDescriptor().toHuman());// meth.getPrototype().getDescriptor());

    classElement.addContent(methodElement);

    // Set the access flag attributes for this method.

    processAccessFlags(accessFlags, methodElement);

    // Create signature element.

    methodElement.addContent(processSignature(meth, referencedTypes));

    // Create code element.

    Element codeElement= new Element("code", NS_DEX);

    methodElement.addContent(codeElement);

    // Add delegate method information

    addDelegateElement(method, methodElement);

    // For skeleton-only classes we don't generate instructions.

    if (skeletonOnly)

    {

      methodElement.setAttribute("noImplementation", "true");

      return;

    }

    // Native and abstract methods don't have an implementation.

    if (isNative || isAbstract)

    {

      return;

    }

    ConcreteMethod concrete= new ConcreteMethod(method, cf, (positionInfo != PositionList.NONE), localInfo);

    TranslationAdvice advice= DexTranslationAdvice.THE_ONE;

    RopMethod rmeth= Ropper.convert(concrete, advice);

    int paramSize= meth.getParameterWordCount(isStatic);

    String canonicalName= method.getDefiningClass().getClassType().getDescriptor() + "." + method.getName().getString();

    if (LOTS_OF_DEBUG)

    {

      System.out.println("\n\nMethod: " + canonicalName);

    }

    // Optimize

    rmeth= Optimizer.optimize(rmeth, paramSize, isStatic, localInfo, advice);

    LocalVariableInfo locals= null;

    if (localInfo)

    {

      locals= LocalVariableExtractor.extract(rmeth);

    }

    DalvCode code= RopTranslator.translate(rmeth, positionInfo, locals, paramSize);

    DalvCode.AssignIndicesCallback callback= new DalvCode.AssignIndicesCallback()

    {

      public int getIndex(Constant cst)

      {

        // Everything is at index 0!

        return 0;

      }

    };

    code.assignIndices(callback);

    DalvInsnList instructions= code.getInsns();

    codeElement.setAttribute("register-size", String.valueOf(instructions.getRegistersSize()));

    processLocals(instructions.getRegistersSize(), isStatic, parseClassName(cf.getThisClass().getClassType().getClassName()).toString(), meth.getPrototype().getParameterTypes(), codeElement);

    Map<Integer, SwitchData> switchDataBlocks= extractSwitchData(instructions);

    Map<Integer, ArrayData> arrayData= extractArrayData(instructions);

    CatchTable catches= code.getCatches();

    processCatchTable(catches, codeElement);

    Map<Integer, Target> targets= extractTargets(instructions, catches);

    // For each entry in the catch table, we create a try-catch element,

    // including the try and all the catch children and append it to the

    // code element. We store the try elements in a list, in order to

    // append the matching instructions to them as they are processed.

    List<Element> tryElements= new ArrayList<Element>();

    Map<Integer, Element> tryCatchElements= new HashMap<Integer, Element>();

    for (int i= 0; i < catches.size(); ++i)

    {

      Element tryCatchElement= new Element("try-catch", NS_DEX);

      Element tryElement= new Element("try", NS_DEX);

      tryCatchElement.addContent(tryElement);

      tryElements.add(tryElement);

      // For each handler create a catch element as the child of the

      // try-catch element.

      CatchHandlerList handlers= catches.get(i).getHandlers();

      for (int j= 0; j < handlers.size(); ++j)

      {

        String exceptionType= handlers.get(j).getExceptionType().toHuman();

        // We can remove the exception because a red type exception

        // will never be created or thrown.

        // This change is in sync with the one in processCatchTable

        if (!isRedType(exceptionType))

        {

          Element catchElement= new Element("catch", NS_DEX);

          catchElement.setAttribute("exception-type", exceptionType);

          catchElement.setAttribute("target", String.valueOf(handlers.get(j).getHandler()));

          tryCatchElement.addContent(catchElement);

        }

      }

      tryCatchElements.put(catches.get(i).getStart(), tryCatchElement);

    }

    Element lastTryCatchElement= null;

    // Used inside processInstruction to mark source file lines as

    // already added, so they don't get added twice.

    List<Integer> sourceLinesAlreadyPut= new ArrayList<Integer>();

    // Process every single instruction of this method. Either add it do

    // the main code element, or to a try-catch block.

    for (int i= 0; i < instructions.size(); ++i)

    {

      Element instructionParent= codeElement;

      DalvInsn instruction= instructions.get(i);

      int address= instruction.getAddress();

      // Determine whether to add the next instruction to the

      // codeElement or to a try block.

      Entry currentCatch= null;

      int tryElementIndex= 0;