classfilereferencefixer.java

proguard 3.5 java 混淆器 最新 免费 好用的 大家用用试一下吧 天行健-君子以自强不息 地势坤-君子以厚德载物

/* $Id: ClassFileReferenceFixer.java,v 1.4.2.2 2006/01/16 22:57:55 eric Exp $
 *
 * ProGuard -- shrinking, optimization, and obfuscation of Java class files.
 *
 * Copyright (c) 2002-2006 Eric Lafortune ([e-mail])
 *
 * 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.util.*;
import proguard.classfile.visitor.*;

/**
 * This ClassFileVisitor fixes constant pool references to classes whose
 * names have changed. Descriptors of member references are not updated yet.
 *
 * @see MemberReferenceFixer
 * @author Eric Lafortune
 */
public class ClassFileReferenceFixer
  implements ClassFileVisitor,
             CpInfoVisitor,
             MemberInfoVisitor,
             AttrInfoVisitor,
             LocalVariableInfoVisitor,
             LocalVariableTypeInfoVisitor,
             AnnotationVisitor,
             ElementValueVisitor
{
    private boolean ensureUniqueMemberNames;


    private ConstantPoolEditor constantPoolEditor = new ConstantPoolEditor();


    /**
     * Creates a new ClassFileReferenceFixer.
     * @param ensureUniqueMemberNames specifies whether class members whose
     *                                descriptor changes should get new, unique
     *                                names, in order to avoid naming conflicts
     *                                with similar methods.
     */
    public ClassFileReferenceFixer(boolean ensureUniqueMemberNames)
    {
        this.ensureUniqueMemberNames = ensureUniqueMemberNames;
    }


    // Implementations for ClassFileVisitor.

    public void visitProgramClassFile(ProgramClassFile programClassFile)
    {
        // Fix the constant pool.
        programClassFile.constantPoolEntriesAccept(this);

        // Fix class members.
        programClassFile.fieldsAccept(this);
        programClassFile.methodsAccept(this);

        // Fix the attributes.
        programClassFile.attributesAccept(this);
    }


    public void visitLibraryClassFile(LibraryClassFile libraryClassFile)
    {
        // Fix class members.
        libraryClassFile.fieldsAccept(this);
        libraryClassFile.methodsAccept(this);
    }


    // Implementations for MemberInfoVisitor.

    public void visitProgramFieldInfo(ProgramClassFile programClassFile, ProgramFieldInfo programFieldInfo)
    {
        // Has the descriptor changed?
        String descriptor    = programFieldInfo.getDescriptor(programClassFile);
        String newDescriptor = newDescriptor(descriptor,
                                             programFieldInfo.referencedClassFile);

        if (!descriptor.equals(newDescriptor))
        {
            // Update the descriptor.
            programFieldInfo.u2descriptorIndex =
                constantPoolEditor.addUtf8CpInfo(programClassFile, newDescriptor);

            // Update the name, if requested.
            if (ensureUniqueMemberNames)
            {
                String name    = programFieldInfo.getName(programClassFile);
                String newName = newUniqueMemberName(name, descriptor);
                programFieldInfo.u2nameIndex =
                    constantPoolEditor.addUtf8CpInfo(programClassFile, newName);
            }
        }

        // Fix the attributes.
        programFieldInfo.attributesAccept(programClassFile, this);
    }


    public void visitProgramMethodInfo(ProgramClassFile programClassFile, ProgramMethodInfo programMethodInfo)
    {
        // Has the descriptor changed?
        String descriptor    = programMethodInfo.getDescriptor(programClassFile);
        String newDescriptor = newDescriptor(descriptor,
                                             programMethodInfo.referencedClassFiles);

        if (!descriptor.equals(newDescriptor))
        {
            // Update the descriptor.
            programMethodInfo.u2descriptorIndex =
                constantPoolEditor.addUtf8CpInfo(programClassFile, newDescriptor);

            // Update the name, if requested.
            if (ensureUniqueMemberNames)
            {
                String name    = programMethodInfo.getName(programClassFile);
                String newName = newUniqueMemberName(name, descriptor);
                programMethodInfo.u2nameIndex =
                    constantPoolEditor.addUtf8CpInfo(programClassFile, newName);
            }
        }

        // Fix the attributes.
        programMethodInfo.attributesAccept(programClassFile, this);
    }


    public void visitLibraryFieldInfo(LibraryClassFile libraryClassFile, LibraryFieldInfo libraryFieldInfo)
    {
        // Has the descriptor changed?
        String descriptor    = libraryFieldInfo.getDescriptor(libraryClassFile);
        String newDescriptor = newDescriptor(descriptor,
                                             libraryFieldInfo.referencedClassFile);

        // Update the descriptor.
        libraryFieldInfo.descriptor = newDescriptor;
    }


    public void visitLibraryMethodInfo(LibraryClassFile libraryClassFile, LibraryMethodInfo libraryMethodInfo)
    {
        // Has the descriptor changed?
        String descriptor    = libraryMethodInfo.getDescriptor(libraryClassFile);
        String newDescriptor = newDescriptor(descriptor,
                                             libraryMethodInfo.referencedClassFiles);

        // Update the descriptor.
        libraryMethodInfo.descriptor = newDescriptor;
    }


    // Implementations for CpInfoVisitor.

    public void visitIntegerCpInfo(ClassFile classFile, IntegerCpInfo integerCpInfo) {}
    public void visitLongCpInfo(ClassFile classFile, LongCpInfo longCpInfo) {}
    public void visitFloatCpInfo(ClassFile classFile, FloatCpInfo floatCpInfo) {}
    public void visitDoubleCpInfo(ClassFile classFile, DoubleCpInfo doubleCpInfo) {}
    public void visitFieldrefCpInfo(ClassFile classFile, FieldrefCpInfo fieldrefCpInfo) {}
    public void visitInterfaceMethodrefCpInfo(ClassFile classFile, InterfaceMethodrefCpInfo interfaceMethodrefCpInfo) {}
    public void visitMethodrefCpInfo(ClassFile classFile, MethodrefCpInfo methodrefCpInfo) {}
    public void visitNameAndTypeCpInfo(ClassFile classFile, NameAndTypeCpInfo nameAndTypeCpInfo) {}
    public void visitUtf8CpInfo(ClassFile classFile, Utf8CpInfo utf8CpInfo) {}


    public void visitStringCpInfo(ClassFile classFile, StringCpInfo stringCpInfo)
    {
        // Does the string refer to a class file, due to a Class.forName construct?
        ClassFile referencedClassFile = stringCpInfo.referencedClassFile;
        if (referencedClassFile != null)
        {
            // Reconstruct the new class name.
            String externalClassName    = stringCpInfo.getString(classFile);
            String internalClassName    = ClassUtil.internalClassName(externalClassName);
            String newInternalClassName = newClassName(internalClassName,
                                                       referencedClassFile);

            // Update the String entry if required.
            if (!newInternalClassName.equals(internalClassName))
            {
                String newExternalClassName = ClassUtil.externalClassName(newInternalClassName);

                // Refer to a new Utf8 entry.
                stringCpInfo.u2stringIndex =
                    constantPoolEditor.addUtf8CpInfo((ProgramClassFile)classFile,
                                                     newExternalClassName);
            }
        }
    }


    public void visitClassCpInfo(ClassFile classFile, ClassCpInfo classCpInfo)
    {
        // Do we know the referenced class file?
        ClassFile referencedClassFile = classCpInfo.referencedClassFile;
        if (referencedClassFile != null)
        {
            // Has the class name changed?
            String className    = classCpInfo.getName(classFile);
            String newClassName = newClassName(className, referencedClassFile);
            if (!className.equals(newClassName))
            {
                // Refer to a new Utf8 entry.
                classCpInfo.u2nameIndex =
                    constantPoolEditor.addUtf8CpInfo((ProgramClassFile)classFile,
                                                     newClassName);
            }
        }
    }


    // Implementations for AttrInfoVisitor.

    public void visitUnknownAttrInfo(ClassFile classFile, UnknownAttrInfo unknownAttrInfo) {}
    public void visitInnerClassesAttrInfo(ClassFile classFile, InnerClassesAttrInfo innerClassesAttrInfo) {}
    public void visitEnclosingMethodAttrInfo(ClassFile classFile, EnclosingMethodAttrInfo enclosingMethodAttrInfo) {}
    public void visitConstantValueAttrInfo(ClassFile classFile, FieldInfo fieldInfo, ConstantValueAttrInfo constantValueAttrInfo) {}
    public void visitExceptionsAttrInfo(ClassFile classFile, MethodInfo methodInfo, ExceptionsAttrInfo exceptionsAttrInfo) {}
    public void visitLineNumberTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LineNumberTableAttrInfo lineNumberTableAttrInfo) {}
    public void visitSourceFileAttrInfo(ClassFile classFile, SourceFileAttrInfo sourceFileAttrInfo) {}
    public void visitSourceDirAttrInfo(ClassFile classFile, SourceDirAttrInfo sourceDirAttrInfo) {}
    public void visitDeprecatedAttrInfo(ClassFile classFile, DeprecatedAttrInfo deprecatedAttrInfo) {}
    public void visitSyntheticAttrInfo(ClassFile classFile, SyntheticAttrInfo syntheticAttrInfo) {}


    public void visitCodeAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo)
    {
        // Fix the attributes.
        codeAttrInfo.attributesAccept(classFile, methodInfo, this);
    }


    public void visitLocalVariableTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableTableAttrInfo localVariableTableAttrInfo)
    {
        // Fix the types of the local variables.
        localVariableTableAttrInfo.localVariablesAccept(classFile, methodInfo, codeAttrInfo, this);
    }


    public void visitLocalVariableTypeTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableTypeTableAttrInfo localVariableTypeTableAttrInfo)
    {
        // Fix the signatures of the local variables.
        localVariableTypeTableAttrInfo.localVariablesAccept(classFile, methodInfo, codeAttrInfo, this);
    }


    public void visitSignatureAttrInfo(ClassFile classFile, SignatureAttrInfo signatureAttrInfo)
    {
        // Compute the new signature.
        String signature    = classFile.getCpString(signatureAttrInfo.u2signatureIndex);
        String newSignature = newDescriptor(signature,
                                            signatureAttrInfo.referencedClassFiles);

        if (!signature.equals(newSignature))