sometsome 3.10.50 → 3.10.50.37

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

@@ -1,255 +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.*;
-
-/**
- * This class can add interfaces and class members to a given class.
- * Elements to be added must be filled out beforehand, including their
- * references to the constant pool.
- *
- * @author Eric Lafortune
- */
-public class ClassEditor
-{
-    private static final boolean DEBUG = false;
-
-    private ProgramClass targetClass;
-
-
-    /**
-     * Creates a new ClassEditor that will edit elements in the given
-     * target class.
-     */
-    public ClassEditor(ProgramClass targetClass)
-    {
-        this.targetClass = targetClass;
-    }
-
-
-    /**
-     * Adds the given interface.
-     */
-    public void addInterface(int interfaceConstantIndex)
-    {
-        int   interfacesCount = targetClass.u2interfacesCount;
-        int[] interfaces      = targetClass.u2interfaces;
-
-        // Make sure there is enough space for the new interface.
-        if (interfaces.length <= interfacesCount)
-        {
-            targetClass.u2interfaces = new int[interfacesCount+1];
-            System.arraycopy(interfaces, 0,
-                             targetClass.u2interfaces, 0,
-                             interfacesCount);
-            interfaces = targetClass.u2interfaces;
-        }
-
-        if (DEBUG)
-        {
-            System.out.println(targetClass.getName()+": adding interface ["+targetClass.getClassName(interfaceConstantIndex)+"]");
-        }
-
-        // Add the interface.
-        interfaces[targetClass.u2interfacesCount++] = interfaceConstantIndex;
-    }
-
-    /**
-     * Removes the given interface.
-     */
-    public void removeInterface(int interfaceConstantIndex)
-    {
-        int   interfacesCount = targetClass.u2interfacesCount;
-        int[] interfaces      = targetClass.u2interfaces;
-
-        int interfaceIndex = findInterfaceIndex(interfaceConstantIndex);
-
-        // Shift the interface entries.
-        System.arraycopy(interfaces, interfaceIndex+1,
-                         interfaces, interfaceIndex,
-                         interfacesCount - interfaceIndex - 1);
-
-        // Clear the last entry.
-        interfaces[--targetClass.u2interfacesCount] = 0;
-    }
-
-
-    /**
-     * Finds the index of the given interface in the target class.
-     */
-
-    private int findInterfaceIndex(int interfaceConstantIndex)
-    {
-        int   interfacesCount = targetClass.u2interfacesCount;
-        int[] interfaces      = targetClass.u2interfaces;
-
-        for (int index = 0; index < interfacesCount; index++)
-        {
-            if (interfaces[index] == interfaceConstantIndex)
-            {
-                return index;
-            }
-        }
-
-        return interfacesCount;
-    }
-
-
-    /**
-     * Adds the given field.
-     */
-    public void addField(Field field)
-    {
-        int     fieldsCount = targetClass.u2fieldsCount;
-        Field[] fields      = targetClass.fields;
-
-        // Make sure there is enough space for the new field.
-        if (fields.length <= fieldsCount)
-        {
-            targetClass.fields = new ProgramField[fieldsCount+1];
-            System.arraycopy(fields, 0,
-                             targetClass.fields, 0,
-                             fieldsCount);
-            fields = targetClass.fields;
-        }
-
-        if (DEBUG)
-        {
-            System.out.println(targetClass.getName()+": adding field ["+field.getName(targetClass)+" "+field.getDescriptor(targetClass)+"]");
-        }
-
-        // Add the field.
-        fields[targetClass.u2fieldsCount++] = field;
-    }
-
-
-    /**
-     * Removes the given field. Note that removing a field that is still being
-     * referenced can cause unpredictable effects.
-     */
-    public void removeField(Field field)
-    {
-        int     fieldsCount = targetClass.u2fieldsCount;
-        Field[] fields      = targetClass.fields;
-
-        int fieldIndex = findFieldIndex(field);
-
-        // Shift the field entries.
-        System.arraycopy(fields, fieldIndex+1,
-                         fields, fieldIndex,
-                         fieldsCount - fieldIndex - 1);
-
-        // Clear the last entry.
-        fields[--targetClass.u2fieldsCount] = null;
-    }
-
-
-    /**
-     * Finds the index of the given field in the target class.
-     */
-
-    private int findFieldIndex(Field field)
-    {
-        int     fieldsCount = targetClass.u2fieldsCount;
-        Field[] fields      = targetClass.fields;
-
-        for (int index = 0; index < fieldsCount; index++)
-        {
-            if (fields[index].equals(field))
-            {
-                return index;
-            }
-        }
-
-        return fieldsCount;
-    }
-
-
-    /**
-     * Adds the given method.
-     */
-    public void addMethod(Method method)
-    {
-        int      methodsCount = targetClass.u2methodsCount;
-        Method[] methods      = targetClass.methods;
-
-        // Make sure there is enough space for the new method.
-        if (methods.length <= methodsCount)
-        {
-            targetClass.methods = new ProgramMethod[methodsCount+1];
-            System.arraycopy(methods, 0,
-                             targetClass.methods, 0,
-                             methodsCount);
-            methods = targetClass.methods;
-        }
-
-        if (DEBUG)
-        {
-            System.out.println(targetClass.getName()+": adding method ["+method.getName(targetClass)+method.getDescriptor(targetClass)+"]");
-        }
-
-        // Add the method.
-        methods[targetClass.u2methodsCount++] = method;
-    }
-
-
-    /**
-     * Removes the given method. Note that removing a method that is still being
-     * referenced can cause unpredictable effects.
-     */
-    public void removeMethod(Method method)
-    {
-        int      methodsCount = targetClass.u2methodsCount;
-        Method[] methods      = targetClass.methods;
-
-        int methodIndex = findMethodIndex(method);
-
-        // Shift the method entries.
-        System.arraycopy(methods, methodIndex+1,
-                         methods, methodIndex,
-                         methodsCount - methodIndex - 1);
-
-        // Clear the last entry.
-        methods[--targetClass.u2methodsCount] = null;
-    }
-
-
-    /**
-     * Finds the index of the given method in the target class.
-     */
-
-    private int findMethodIndex(Method method)
-    {
-        int      methodsCount = targetClass.u2methodsCount;
-        Method[] methods      = targetClass.methods;
-
-        for (int index = 0; index < methodsCount; index++)
-        {
-            if (methods[index].equals(method))
-            {
-                return index;
-            }
-        }
-
-        return methodsCount;
-    }
-}

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

@@ -1,52 +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.ProgramClass;
-import proguard.classfile.util.SimplifiedVisitor;
-import proguard.classfile.visitor.ClassVisitor;
-
-/**
- * This ClassVisitor sorts the various elements of the classes that it visits:
- * interfaces, constants, fields, methods, and attributes.
- *
- * @author Eric Lafortune
- */
-public class ClassElementSorter
-extends      SimplifiedVisitor
-implements   ClassVisitor
-{
-    private final ClassVisitor interfaceSorter    = new InterfaceSorter();
-    private final ClassVisitor constantPoolSorter = new ConstantPoolSorter();
-//  private ClassVisitor classMemberSorter  = new ClassMemberSorter();
-    private final ClassVisitor attributeSorter    = new AttributeSorter();
-
-
-    // Implementations for ClassVisitor.
-
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        programClass.accept(constantPoolSorter);
-        programClass.accept(interfaceSorter);
-//      programClass.accept(classMemberSorter);
-        programClass.accept(attributeSorter);
-    }
-}

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

@@ -1,69 +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.visitor.ClassVisitor;
-
-import java.util.*;
-
-/**
- * This ClassVisitor sorts the class members of the classes that it visits.
- * The sorting order is based on the access flags, the names, and the
- * descriptors.
- *
- * @author Eric Lafortune
- */
-public class ClassMemberSorter implements ClassVisitor, Comparator
-{
-    // Implementations for ClassVisitor.
-
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        // Sort the fields.
-        Arrays.sort(programClass.fields, 0, programClass.u2fieldsCount, this);
-
-        // Sort the methods.
-        Arrays.sort(programClass.methods, 0, programClass.u2methodsCount, this);
-    }
-
-
-    public void visitLibraryClass(LibraryClass libraryClass)
-    {
-    }
-
-
-    // Implementations for Comparator.
-
-    public int compare(Object object1, Object object2)
-    {
-        ProgramMember member1 = (ProgramMember)object1;
-        ProgramMember member2 = (ProgramMember)object2;
-
-        return member1.u2accessFlags     < member2.u2accessFlags     ? -1 :
-               member1.u2accessFlags     > member2.u2accessFlags     ?  1 :
-               member1.u2nameIndex       < member2.u2nameIndex       ? -1 :
-               member1.u2nameIndex       > member2.u2nameIndex       ?  1 :
-               member1.u2descriptorIndex < member2.u2descriptorIndex ? -1 :
-               member1.u2descriptorIndex > member2.u2descriptorIndex ?  1 :
-                                                                        0;
-    }
-}

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

@@ -1,546 +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.*;
-import proguard.classfile.attribute.annotation.*;
-import proguard.classfile.attribute.annotation.visitor.*;
-import proguard.classfile.attribute.visitor.*;
-import proguard.classfile.constant.*;
-import proguard.classfile.constant.visitor.ConstantVisitor;
-import proguard.classfile.util.*;
-import proguard.classfile.visitor.*;
-
-/**
- * This ClassVisitor fixes references of constant pool entries, fields,
- * methods, and attributes to classes whose names have changed. Descriptors
- * of member references are not updated yet.
- *
- * @see MemberReferenceFixer
- * @author Eric Lafortune
- */
-public class ClassReferenceFixer
-extends      SimplifiedVisitor
-implements   ClassVisitor,
-             ConstantVisitor,
-             MemberVisitor,
-             AttributeVisitor,
-             InnerClassesInfoVisitor,
-             LocalVariableInfoVisitor,
-             LocalVariableTypeInfoVisitor,
-             AnnotationVisitor,
-             ElementValueVisitor
-{
-    private final boolean ensureUniqueMemberNames;
-
-
-    /**
-     * Creates a new ClassReferenceFixer.
-     * @param ensureUniqueMemberNames specifies whether class members whose
-     *                                descriptor changes should get new, unique
-     *                                names, in order to avoid naming conflicts
-     *                                with similar methods.
-     */
-    public ClassReferenceFixer(boolean ensureUniqueMemberNames)
-    {
-        this.ensureUniqueMemberNames = ensureUniqueMemberNames;
-    }
-
-
-    // Implementations for ClassVisitor.
-
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        // Fix the constant pool.
-        programClass.constantPoolEntriesAccept(this);
-
-        // Fix class members.
-        programClass.fieldsAccept(this);
-        programClass.methodsAccept(this);
-
-        // Fix the attributes.
-        programClass.attributesAccept(this);
-    }
-
-
-    public void visitLibraryClass(LibraryClass libraryClass)
-    {
-        // Fix class members.
-        libraryClass.fieldsAccept(this);
-        libraryClass.methodsAccept(this);
-    }
-
-
-    // Implementations for MemberVisitor.
-
-    public void visitProgramField(ProgramClass programClass, ProgramField programField)
-    {
-        // Has the descriptor changed?
-        String descriptor    = programField.getDescriptor(programClass);
-        String newDescriptor = newDescriptor(descriptor,
-                                             programField.referencedClass);
-
-        if (!descriptor.equals(newDescriptor))
-        {
-            ConstantPoolEditor constantPoolEditor =
-                new ConstantPoolEditor(programClass);
-
-            // Update the descriptor.
-            programField.u2descriptorIndex =
-                constantPoolEditor.addUtf8Constant(newDescriptor);
-
-            // Update the name, if requested.
-            if (ensureUniqueMemberNames)
-            {
-                String name    = programField.getName(programClass);
-                String newName = newUniqueMemberName(name, descriptor);
-                programField.u2nameIndex =
-                    constantPoolEditor.addUtf8Constant(newName);
-            }
-        }
-
-        // Fix the attributes.
-        programField.attributesAccept(programClass, this);
-    }
-
-
-    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
-    {
-        // Has the descriptor changed?
-        String descriptor    = programMethod.getDescriptor(programClass);
-        String newDescriptor = newDescriptor(descriptor,
-                                             programMethod.referencedClasses);
-
-        if (!descriptor.equals(newDescriptor))
-        {
-            ConstantPoolEditor constantPoolEditor =
-                new ConstantPoolEditor(programClass);
-
-            // Update the descriptor.
-            programMethod.u2descriptorIndex =
-                constantPoolEditor.addUtf8Constant(newDescriptor);
-
-            // Update the name, if requested.
-            if (ensureUniqueMemberNames)
-            {
-                String name    = programMethod.getName(programClass);
-                String newName = newUniqueMemberName(name, descriptor);
-                programMethod.u2nameIndex =
-                    constantPoolEditor.addUtf8Constant(newName);
-            }
-        }
-
-        // Fix the attributes.
-        programMethod.attributesAccept(programClass, this);
-    }
-
-
-    public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
-    {
-        // Has the descriptor changed?
-        String descriptor    = libraryField.getDescriptor(libraryClass);
-        String newDescriptor = newDescriptor(descriptor,
-                                             libraryField.referencedClass);
-
-        // Update the descriptor.
-        libraryField.descriptor = newDescriptor;
-    }
-
-
-    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
-    {
-        // Has the descriptor changed?
-        String descriptor    = libraryMethod.getDescriptor(libraryClass);
-        String newDescriptor = newDescriptor(descriptor,
-                                             libraryMethod.referencedClasses);
-
-        // Update the descriptor.
-        libraryMethod.descriptor = newDescriptor;
-    }
-
-
-    // Implementations for ConstantVisitor.
-
-    public void visitAnyConstant(Clazz clazz, Constant constant) {}
-
-
-    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
-    {
-        // Does the string refer to a class, due to a Class.forName construct?
-        Clazz  referencedClass  = stringConstant.referencedClass;
-        Member referencedMember = stringConstant.referencedMember;
-        if (referencedClass  != null &&
-            referencedMember == null)
-        {
-            // Reconstruct the new class name.
-            String externalClassName    = stringConstant.getString(clazz);
-            String internalClassName    = ClassUtil.internalClassName(externalClassName);
-            String newInternalClassName = newClassName(internalClassName,
-                                                       referencedClass);
-
-            // Update the String entry if required.
-            if (!newInternalClassName.equals(internalClassName))
-            {
-                String newExternalClassName = ClassUtil.externalClassName(newInternalClassName);
-
-                // Refer to a new Utf8 entry.
-                stringConstant.u2stringIndex =
-                    new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newExternalClassName);
-            }
-        }
-    }
-
-
-    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
-    {
-        // Do we know the referenced class?
-        Clazz referencedClass = classConstant.referencedClass;
-        if (referencedClass != null)
-        {
-            // Has the class name changed?
-            String className    = classConstant.getName(clazz);
-            String newClassName = newClassName(className, referencedClass);
-            if (!className.equals(newClassName))
-            {
-                // Refer to a new Utf8 entry.
-                classConstant.u2nameIndex =
-                    new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newClassName);
-            }
-        }
-    }
-
-    // Implementations for AttributeVisitor.
-
-    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-
-
-    public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
-    {
-        // Fix the inner class names.
-        innerClassesAttribute.innerClassEntriesAccept(clazz, this);
-    }
-
-
-    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
-    {
-        // Fix the attributes.
-        codeAttribute.attributesAccept(clazz, method, this);
-    }
-
-
-    public void visitLocalVariableTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTableAttribute localVariableTableAttribute)
-    {
-        // Fix the types of the local variables.
-        localVariableTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
-    }
-
-
-    public void visitLocalVariableTypeTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeTableAttribute localVariableTypeTableAttribute)
-    {
-        // Fix the signatures of the local variables.
-        localVariableTypeTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
-    }
-
-
-    public void visitSignatureAttribute(Clazz clazz, SignatureAttribute signatureAttribute)
-    {
-        // Compute the new signature.
-        String signature    = clazz.getString(signatureAttribute.u2signatureIndex);
-        String newSignature = newDescriptor(signature,
-                                            signatureAttribute.referencedClasses);
-
-        if (!signature.equals(newSignature))
-        {
-            signatureAttribute.u2signatureIndex =
-                new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newSignature);
-        }
-    }
-
-
-    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
-    {
-        // Fix the annotations.
-        annotationsAttribute.annotationsAccept(clazz, this);
-    }
-
-
-    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
-    {
-        // Fix the annotations.
-        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
-    }
-
-
-    public void visitAnnotationDefaultAttribute(Clazz clazz, Method method, AnnotationDefaultAttribute annotationDefaultAttribute)
-    {
-        // Fix the annotation.
-        annotationDefaultAttribute.defaultValueAccept(clazz, this);
-    }
-
-
-    // Implementations for InnerClassesInfoVisitor.
-
-    public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo)
-    {
-        // Fix the inner class name.
-        int innerClassIndex = innerClassesInfo.u2innerClassIndex;
-        int innerNameIndex  = innerClassesInfo.u2innerNameIndex;
-        if (innerClassIndex != 0 &&
-            innerNameIndex  != 0)
-        {
-            String newInnerName = clazz.getClassName(innerClassIndex);
-            int index = newInnerName.lastIndexOf(ClassConstants.INTERNAL_INNER_CLASS_SEPARATOR);
-            if (index >= 0)
-            {
-                innerClassesInfo.u2innerNameIndex =
-                    new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newInnerName.substring(index + 1));
-            }
-        }
-    }
-
-
-    // Implementations for LocalVariableInfoVisitor.
-
-    public void visitLocalVariableInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableInfo localVariableInfo)
-    {
-        // Has the descriptor changed?
-        String descriptor    = clazz.getString(localVariableInfo.u2descriptorIndex);
-        String newDescriptor = newDescriptor(descriptor,
-                                             localVariableInfo.referencedClass);
-
-        if (!descriptor.equals(newDescriptor))
-        {
-            // Refer to a new Utf8 entry.
-            localVariableInfo.u2descriptorIndex =
-                new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newDescriptor);
-        }
-    }
-
-    // Implementations for LocalVariableTypeInfoVisitor.
-
-    public void visitLocalVariableTypeInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeInfo localVariableTypeInfo)
-    {
-        // Has the signature changed?
-        String signature    = clazz.getString(localVariableTypeInfo.u2signatureIndex);
-        String newSignature = newDescriptor(signature,
-                                            localVariableTypeInfo.referencedClasses);
-
-        if (!signature.equals(newSignature))
-        {
-            localVariableTypeInfo.u2signatureIndex =
-                new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newSignature);
-        }
-    }
-
-    // Implementations for AnnotationVisitor.
-
-    public void visitAnnotation(Clazz clazz, Annotation annotation)
-    {
-        // Compute the new type name.
-        String typeName    = clazz.getString(annotation.u2typeIndex);
-        String newTypeName = newDescriptor(typeName,
-                                           annotation.referencedClasses);
-
-        if (!typeName.equals(newTypeName))
-        {
-            // Refer to a new Utf8 entry.
-            annotation.u2typeIndex =
-                new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newTypeName);
-        }
-
-        // Fix the element values.
-        annotation.elementValuesAccept(clazz, this);
-    }
-
-
-    // Implementations for ElementValueVisitor.
-
-    public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue)
-    {
-    }
-
-
-    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
-    {
-        // Compute the new type name.
-        String typeName    = clazz.getString(enumConstantElementValue.u2typeNameIndex);
-        String newTypeName = newDescriptor(typeName,
-                                           enumConstantElementValue.referencedClasses);
-
-        if (!typeName.equals(newTypeName))
-        {
-            // Refer to a new Utf8 entry.
-            enumConstantElementValue.u2typeNameIndex =
-                new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newTypeName);
-        }
-    }
-
-
-    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
-    {
-        // Compute the new class name.
-        String className    = clazz.getString(classElementValue.u2classInfoIndex);
-        String newClassName = newDescriptor(className,
-                                            classElementValue.referencedClasses);
-
-        if (!className.equals(newClassName))
-        {
-            // Refer to a new Utf8 entry.
-            classElementValue.u2classInfoIndex =
-                new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newClassName);
-        }
-    }
-
-
-    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
-    {
-        // Fix the annotation.
-        annotationElementValue.annotationAccept(clazz, this);
-    }
-
-
-    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
-    {
-        // Fix the element values.
-        arrayElementValue.elementValuesAccept(clazz, annotation, this);
-    }
-
-
-    // Small utility methods.
-
-    private static String newDescriptor(String descriptor,
-                                        Clazz  referencedClass)
-    {
-        // If there is no referenced class, the descriptor won't change.
-        if (referencedClass == null)
-        {
-            return descriptor;
-        }
-
-        // Unravel and reconstruct the class element of the descriptor.
-        DescriptorClassEnumeration descriptorClassEnumeration =
-            new DescriptorClassEnumeration(descriptor);
-
-        StringBuffer newDescriptorBuffer = new StringBuffer(descriptor.length());
-        newDescriptorBuffer.append(descriptorClassEnumeration.nextFluff());
-
-        // Only if the descriptor contains a class name (e.g. with an array of
-        // primitive types), the descriptor can change.
-        if (descriptorClassEnumeration.hasMoreClassNames())
-        {
-            String className = descriptorClassEnumeration.nextClassName();
-            String fluff     = descriptorClassEnumeration.nextFluff();
-
-            String newClassName = newClassName(className,
-                                               referencedClass);
-
-            newDescriptorBuffer.append(newClassName);
-            newDescriptorBuffer.append(fluff);
-        }
-
-        return newDescriptorBuffer.toString();
-    }
-
-
-    private static String newDescriptor(String  descriptor,
-                                        Clazz[] referencedClasses)
-    {
-        // If there are no referenced classes, the descriptor won't change.
-        if (referencedClasses == null ||
-            referencedClasses.length == 0)
-        {
-            return descriptor;
-        }
-
-        // Unravel and reconstruct the class elements of the descriptor.
-        DescriptorClassEnumeration descriptorClassEnumeration =
-            new DescriptorClassEnumeration(descriptor);
-
-        StringBuffer newDescriptorBuffer = new StringBuffer(descriptor.length());
-        newDescriptorBuffer.append(descriptorClassEnumeration.nextFluff());
-
-        int index = 0;
-        while (descriptorClassEnumeration.hasMoreClassNames())
-        {
-            String  className        = descriptorClassEnumeration.nextClassName();
-            boolean isInnerClassName = descriptorClassEnumeration.isInnerClassName();
-            String  fluff            = descriptorClassEnumeration.nextFluff();
-
-            String newClassName = newClassName(className,
-                                               referencedClasses[index++]);
-
-            // Strip the outer class name again, if it's an inner class.
-            if (isInnerClassName)
-            {
-                newClassName =
-                    newClassName.substring(newClassName.lastIndexOf(ClassConstants.INTERNAL_INNER_CLASS_SEPARATOR)+1);
-            }
-
-            newDescriptorBuffer.append(newClassName);
-            newDescriptorBuffer.append(fluff);
-        }
-
-        return newDescriptorBuffer.toString();
-    }
-
-
-    /**
-     * Returns a unique class member name, based on the given name and descriptor.
-     */
-    private String newUniqueMemberName(String name, String descriptor)
-    {
-        return name.equals(ClassConstants.INTERNAL_METHOD_NAME_INIT) ?
-            ClassConstants.INTERNAL_METHOD_NAME_INIT :
-            name + ClassConstants.SPECIAL_MEMBER_SEPARATOR + Long.toHexString(Math.abs((descriptor).hashCode()));
-    }
-
-
-    /**
-     * Returns the new class name based on the given class name and the new
-     * name of the given referenced class. Class names of array types
-     * are handled properly.
-     */
-    private static String newClassName(String className,
-                                       Clazz  referencedClass)
-    {
-        // If there is no referenced class, the class name won't change.
-        if (referencedClass == null)
-        {
-            return className;
-        }
-
-        // Reconstruct the class name.
-        String newClassName = referencedClass.getName();
-
-        // Is it an array type?
-        if (className.charAt(0) == ClassConstants.INTERNAL_TYPE_ARRAY)
-        {
-            // Add the array prefixes and suffix "[L...;".
-            newClassName =
-                 className.substring(0, className.indexOf(ClassConstants.INTERNAL_TYPE_CLASS_START)+1) +
-                 newClassName +
-                 ClassConstants.INTERNAL_TYPE_CLASS_END;
-        }
-
-        return newClassName;
-    }
-}