sometsome 3.10.46 → 3.10.50.33

data/lib/proguard4.7/src/proguard/classfile/editor/ConstantPoolSorter.java

@@ -1,123 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program 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 General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.classfile.editor;
-
-import proguard.classfile.*;
-import proguard.classfile.constant.Constant;
-import proguard.classfile.util.SimplifiedVisitor;
-import proguard.classfile.visitor.ClassVisitor;
-
-import java.util.Arrays;
-
-/**
- * This ClassVisitor sorts the constant pool entries of the program classes
- * that it visits. The sorting order is based on the types of the constant pool
- * entries in the first place, and on their contents in the second place.
- *
- * @author Eric Lafortune
- */
-public class ConstantPoolSorter
-extends      SimplifiedVisitor
-implements   ClassVisitor
-{
-    private int[]                constantIndexMap       = new int[ClassConstants.TYPICAL_CONSTANT_POOL_SIZE];
-    private ComparableConstant[] comparableConstantPool = new ComparableConstant[ClassConstants.TYPICAL_CONSTANT_POOL_SIZE];
-    private Constant[]           newConstantPool        = new Constant[ClassConstants.TYPICAL_CONSTANT_POOL_SIZE];
-
-    private final ConstantPoolRemapper constantPoolRemapper = new ConstantPoolRemapper();
-
-
-    // Implementations for ClassVisitor.
-
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        int constantPoolCount = programClass.u2constantPoolCount;
-
-        // Sort the constant pool and set up an index map.
-        if (constantIndexMap.length < constantPoolCount)
-        {
-            constantIndexMap       = new int[constantPoolCount];
-            comparableConstantPool = new ComparableConstant[constantPoolCount];
-            newConstantPool        = new Constant[constantPoolCount];
-        }
-
-        // Initialize an array whose elements can be compared.
-        int sortLength = 0;
-        for (int oldIndex = 1; oldIndex < constantPoolCount; oldIndex++)
-        {
-            Constant constant = programClass.constantPool[oldIndex];
-            if (constant != null)
-            {
-                comparableConstantPool[sortLength++] =
-                    new ComparableConstant(programClass, oldIndex, constant);
-            }
-        }
-
-        // Sort the array.
-        Arrays.sort(comparableConstantPool, 0, sortLength);
-
-        // Save the sorted elements.
-        int newLength = 1;
-        int newIndex  = 1;
-        ComparableConstant previousComparableConstant = null;
-        for (int sortIndex = 0; sortIndex < sortLength; sortIndex++)
-        {
-            ComparableConstant comparableConstant = comparableConstantPool[sortIndex];
-
-            // Isn't this a duplicate of the previous constant?
-            if (!comparableConstant.equals(previousComparableConstant))
-            {
-                // Remember the index of the new entry.
-                newIndex = newLength;
-
-                // Copy the sorted constant pool entry over to the constant pool.
-                Constant constant = comparableConstant.getConstant();
-
-                newConstantPool[newLength++] = constant;
-
-                // Long entries take up two slots, the second of which is null.
-                int tag = constant.getTag();
-                if (tag == ClassConstants.CONSTANT_Long ||
-                    tag == ClassConstants.CONSTANT_Double)
-                {
-                    newConstantPool[newLength++] = null;
-                }
-
-                previousComparableConstant = comparableConstant;
-            }
-
-            // Fill out the map array.
-            constantIndexMap[comparableConstant.getIndex()] = newIndex;
-        }
-
-        // Copy the new constant pool over.
-        System.arraycopy(newConstantPool, 0, programClass.constantPool, 0, newLength);
-
-        // Clear any remaining entries.
-        Arrays.fill(programClass.constantPool, newLength, constantPoolCount, null);
-
-        programClass.u2constantPoolCount = newLength;
-
-        // Remap all constant pool references.
-        constantPoolRemapper.setConstantIndexMap(constantIndexMap);
-        constantPoolRemapper.visitProgramClass(programClass);
-    }
-}

data/lib/proguard4.7/src/proguard/classfile/editor/ElementValueAdder.java

@@ -1,217 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program 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 General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.classfile.editor;
-
-import proguard.classfile.*;
-import proguard.classfile.attribute.annotation.*;
-import proguard.classfile.attribute.annotation.visitor.ElementValueVisitor;
-
-/**
- * This AnnotationVisitor adds all element values that it visits to the given
- * target annotation default attribute, annotation, or element value.
- *
- * @author Eric Lafortune
- */
-public class ElementValueAdder
-implements   ElementValueVisitor
-{
-    private static final ElementValue[] EMPTY_ELEMENT_VALUES = new ElementValue[0];
-
-
-    private final ProgramClass               targetClass;
-    private final AnnotationDefaultAttribute targetAnnotationDefaultAttribute;
-
-    private final ConstantAdder       constantAdder;
-    private final ElementValuesEditor elementValuesEditor;
-
-
-    /**
-     * Creates a new ElementValueAdder that will copy element values into the
-     * given target annotation default attribute value.
-     */
-    public ElementValueAdder(ProgramClass               targetClass,
-                             AnnotationDefaultAttribute targetAnnotationDefaultAttribute,
-                             boolean                    replaceElementValues)
-    {
-        this.targetClass                      = targetClass;
-        this.targetAnnotationDefaultAttribute = targetAnnotationDefaultAttribute;
-
-        constantAdder       = new ConstantAdder(targetClass);
-        elementValuesEditor = null;
-    }
-
-
-    /**
-     * Creates a new ElementValueAdder that will copy element values into the
-     * given target annotation.
-     */
-    public ElementValueAdder(ProgramClass targetClass,
-                             Annotation   targetAnnotation,
-                             boolean      replaceElementValues)
-    {
-        this.targetClass                      = targetClass;
-        this.targetAnnotationDefaultAttribute = null;
-
-        constantAdder       = new ConstantAdder(targetClass);
-        elementValuesEditor = new ElementValuesEditor(targetClass,
-                                                      targetAnnotation,
-                                                      replaceElementValues);
-    }
-
-
-    /**
-     * Creates a new ElementValueAdder that will copy element values into the
-     * given target element value.
-     */
-    public ElementValueAdder(ProgramClass      targetClass,
-                             ArrayElementValue targetArrayElementValue,
-                             boolean           replaceElementValues)
-    {
-        this.targetClass                      = targetClass;
-        this.targetAnnotationDefaultAttribute = null;
-
-        constantAdder       = new ConstantAdder(targetClass);
-        elementValuesEditor = new ElementValuesEditor(targetClass,
-                                                      targetArrayElementValue,
-                                                      replaceElementValues);
-    }
-
-
-    // Implementations for ElementValueVisitor.
-
-    public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue)
-    {
-        // Create a copy of the element value.
-        ConstantElementValue newConstantElementValue =
-            new ConstantElementValue(constantElementValue.u1tag,
-                                     constantElementValue.u2elementNameIndex == 0 ? 0 :
-                                     constantAdder.addConstant(clazz, constantElementValue.u2elementNameIndex),
-                                     constantAdder.addConstant(clazz, constantElementValue.u2constantValueIndex));
-
-        newConstantElementValue.referencedClass  = constantElementValue.referencedClass;
-        newConstantElementValue.referencedMethod = constantElementValue.referencedMethod;
-
-        // Add it to the target.
-        addElementValue(newConstantElementValue);
-    }
-
-
-    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
-    {
-        // Create a copy of the element value.
-        EnumConstantElementValue newEnumConstantElementValue =
-            new EnumConstantElementValue(enumConstantElementValue.u2elementNameIndex == 0 ? 0 :
-                                         constantAdder.addConstant(clazz, enumConstantElementValue.u2elementNameIndex),
-                                         constantAdder.addConstant(clazz, enumConstantElementValue.u2typeNameIndex),
-                                         constantAdder.addConstant(clazz, enumConstantElementValue.u2constantNameIndex));
-
-        newEnumConstantElementValue.referencedClass  = enumConstantElementValue.referencedClass;
-        newEnumConstantElementValue.referencedMethod = enumConstantElementValue.referencedMethod;
-
-        // TODO: Clone array.
-        newEnumConstantElementValue.referencedClasses = enumConstantElementValue.referencedClasses;
-
-        // Add it to the target.
-        addElementValue(newEnumConstantElementValue);
-    }
-
-
-    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
-    {
-        // Create a copy of the element value.
-        ClassElementValue newClassElementValue =
-            new ClassElementValue(classElementValue.u2elementNameIndex == 0 ? 0 :
-                                  constantAdder.addConstant(clazz, classElementValue.u2elementNameIndex),
-                                  constantAdder.addConstant(clazz, classElementValue.u2classInfoIndex));
-
-        newClassElementValue.referencedClass  = classElementValue.referencedClass;
-        newClassElementValue.referencedMethod = classElementValue.referencedMethod;
-
-        // TODO: Clone array.
-        newClassElementValue.referencedClasses = classElementValue.referencedClasses;
-
-        // Add it to the target.
-        addElementValue(newClassElementValue);
-    }
-
-
-    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
-    {
-        // Create a copy of the element value.
-        AnnotationElementValue newAnnotationElementValue =
-            new AnnotationElementValue(annotationElementValue.u2elementNameIndex == 0 ? 0 :
-                                       constantAdder.addConstant(clazz, annotationElementValue.u2elementNameIndex),
-                                       new Annotation());
-
-        newAnnotationElementValue.referencedClass  = annotationElementValue.referencedClass;
-        newAnnotationElementValue.referencedMethod = annotationElementValue.referencedMethod;
-
-        annotationElementValue.annotationAccept(clazz,
-                                                new AnnotationAdder(targetClass,
-                                                                    newAnnotationElementValue));
-
-        // Add it to the target.
-        addElementValue(newAnnotationElementValue);
-    }
-
-
-    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
-    {
-        // Create a copy of the element value.
-        ArrayElementValue newArrayElementValue =
-            new ArrayElementValue(arrayElementValue.u2elementNameIndex == 0 ? 0 :
-                                  constantAdder.addConstant(clazz, arrayElementValue.u2elementNameIndex),
-                                  0,
-                                  arrayElementValue.u2elementValuesCount > 0 ?
-                                      new ElementValue[arrayElementValue.u2elementValuesCount] :
-                                      EMPTY_ELEMENT_VALUES);
-
-        newArrayElementValue.referencedClass  = arrayElementValue.referencedClass;
-        newArrayElementValue.referencedMethod = arrayElementValue.referencedMethod;
-
-        arrayElementValue.elementValuesAccept(clazz,
-                                              annotation,
-                                              new ElementValueAdder(targetClass,
-                                                                    newArrayElementValue,
-                                                                    false));
-
-        // Add it to the target.
-        addElementValue(newArrayElementValue);
-    }
-
-
-    // Small utility methods.
-
-    private void addElementValue(ElementValue newElementValue)
-    {
-        // What's the target?
-        if (targetAnnotationDefaultAttribute != null)
-        {
-            // Simply set the completed element value.
-            targetAnnotationDefaultAttribute.defaultValue = newElementValue;
-        }
-        else
-        {
-            // Add it to the target.
-            elementValuesEditor.addElementValue(newElementValue);
-        }
-    }
-}

data/lib/proguard4.7/src/proguard/classfile/editor/ElementValuesEditor.java

@@ -1,238 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program 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 General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.classfile.editor;
-
-import proguard.classfile.*;
-import proguard.classfile.attribute.annotation.*;
-
-/**
- * This class can add and delete element values to and from a given target
- * annotation default attribute, annotation, or array element value. Element
- * values to be added must be filled out beforehand, including their references
- * to the constant pool.
- *
- * @author Eric Lafortune
- */
-public class ElementValuesEditor
-{
-    private final ProgramClass      targetClass;
-    private final Annotation        targetAnnotation;
-    private final ArrayElementValue targetArrayElementValue;
-    private final boolean           replaceElementValues;
-
-
-    /**
-     * Creates a new ElementValuesEditor that will edit element values in the
-     * given target annotation.
-     */
-    public ElementValuesEditor(ProgramClass targetClass,
-                               Annotation   targetAnnotation,
-                               boolean      replaceElementValues)
-    {
-        this.targetClass             = targetClass;
-        this.targetAnnotation        = targetAnnotation;
-        this.targetArrayElementValue = null;
-        this.replaceElementValues    = replaceElementValues;
-    }
-
-
-    /**
-     * Creates a new ElementValuesEditor that will edit element values in the
-     * given target array element value.
-     */
-    public ElementValuesEditor(ProgramClass      targetClass,
-                               ArrayElementValue targetArrayElementValue,
-                               boolean           replaceElementValues)
-    {
-        this.targetClass             = targetClass;
-        this.targetAnnotation        = null;
-        this.targetArrayElementValue = targetArrayElementValue;
-        this.replaceElementValues    = replaceElementValues;
-    }
-
-
-    /**
-     * Adds the given elementValue to the target.
-     */
-    public void addElementValue(ElementValue elementValue)
-    {
-        // What's the target?
-        if (targetAnnotation != null)
-        {
-            // Try to replace an existing element value.
-            if (!replaceElementValues ||
-                !replaceElementValue(targetAnnotation.u2elementValuesCount,
-                                     targetAnnotation.elementValues,
-                                     elementValue))
-            {
-                // Otherwise append the element value.
-                targetAnnotation.elementValues =
-                    addElementValue(targetAnnotation.u2elementValuesCount,
-                                    targetAnnotation.elementValues,
-                                    elementValue);
-
-                targetAnnotation.u2elementValuesCount++;
-            }
-        }
-        else
-        {
-            // Try to replace an existing element value.
-            if (!replaceElementValues ||
-                !replaceElementValue(targetArrayElementValue.u2elementValuesCount,
-                                     targetArrayElementValue.elementValues,
-                                     elementValue))
-            {
-                // Otherwise append the element value.
-                targetArrayElementValue.elementValues =
-                    addElementValue(targetArrayElementValue.u2elementValuesCount,
-                                    targetArrayElementValue.elementValues,
-                                    elementValue);
-
-                targetArrayElementValue.u2elementValuesCount++;
-            }
-        }
-    }
-
-
-    /**
-     * Deletes the given elementValue to the target.
-     */
-    public void deleteElementValue(String elementValueMethodName)
-    {
-        // What's the target?
-        if (targetAnnotation != null)
-        {
-            // Delete the element value to the target annotation.
-            targetAnnotation.u2elementValuesCount =
-                deleteElementValue(targetAnnotation.u2elementValuesCount,
-                                   targetAnnotation.elementValues,
-                                   elementValueMethodName);
-        }
-        else
-        {
-            // Delete the element value to the target array element value.
-            targetArrayElementValue.u2elementValuesCount =
-                deleteElementValue(targetArrayElementValue.u2elementValuesCount,
-                                   targetArrayElementValue.elementValues,
-                                   elementValueMethodName);
-        }
-    }
-
-
-    // Small utility methods.
-
-    /**
-     * Tries put the given element value in place of an existing element value
-     * of the same name, returning whether it was present.
-     */
-    private boolean replaceElementValue(int            elementValuesCount,
-                                        ElementValue[] elementValues,
-                                        ElementValue   elementValue)
-    {
-        // Find the element value with the same name.
-        int index = findElementValue(elementValuesCount,
-                                     elementValues,
-                                     elementValue.getMethodName(targetClass));
-        if (index < 0)
-        {
-            return false;
-        }
-
-        elementValues[index] = elementValue;
-
-        return true;
-    }
-
-
-    /**
-     * Appends the given element value to the given array of element values,
-     * creating a new array if necessary.
-     */
-    private ElementValue[] addElementValue(int            elementValuesCount,
-                                           ElementValue[] elementValues,
-                                           ElementValue   elementValue)
-    {
-        // Is the array too small to contain the additional elementValue?
-        if (elementValues.length <= elementValuesCount)
-        {
-            // Create a new array and copy the elementValues into it.
-            ElementValue[] newElementValues = new ElementValue[elementValuesCount + 1];
-            System.arraycopy(elementValues, 0,
-                             newElementValues, 0,
-                             elementValuesCount);
-            elementValues = newElementValues;
-        }
-
-        // Append the elementValue.
-        elementValues[elementValuesCount] = elementValue;
-
-        return elementValues;
-    }
-
-
-    /**
-     * Deletes the element values with the given name from the given array of
-     * element values, returning the new number of element values.
-     */
-    private int deleteElementValue(int            elementValuesCount,
-                                   ElementValue[] elementValues,
-                                   String         elementValueMethodName)
-    {
-        // Find the element value.
-        int index = findElementValue(elementValuesCount,
-                                     elementValues,
-                                     elementValueMethodName);
-        if (index < 0)
-        {
-            return elementValuesCount;
-        }
-
-        // Shift the other element values in the array.
-        System.arraycopy(elementValues, index + 1,
-                         elementValues, index,
-                         elementValuesCount - index - 1);
-
-        // Clear the last entry in the array.
-        elementValues[--elementValuesCount] = null;
-
-        return elementValuesCount;
-    }
-
-
-    /**
-     * Finds the index of the element value with the given name in the given
-     * array of element values.
-     */
-    private int findElementValue(int            elementValuesCount,
-                                 ElementValue[] elementValues,
-                                 String         elementValueName)
-    {
-        for (int index = 0; index < elementValuesCount; index++)
-        {
-            if (elementValues[index].getMethodName(targetClass).equals(elementValueName))
-            {
-                return index;
-            }
-        }
-
-        return -1;
-    }
-}