proguard.classfile.visitor.ClassVisitor Java Examples

/**
 * Constructs a ClassPoolVisitor to efficiently travel to the specified
 * classes and class members.
 *
 * @param classSpecifications the list of ClassSpecification instances,
 *                            defining of the classes and class members to
 *                            visit.
 * @param classVisitor        the ClassVisitor to be applied to matching
 *                            classes.
 * @param memberVisitor       the MemberVisitor to be applied to matching
 *                            class members.
 */
public static ClassPoolVisitor createClassPoolVisitor(List          classSpecifications,
                                                      ClassVisitor  classVisitor,
                                                      MemberVisitor memberVisitor)
{
    MultiClassPoolVisitor multiClassPoolVisitor = new MultiClassPoolVisitor();

    if (classSpecifications != null)
    {
        for (int index = 0; index < classSpecifications.size(); index++)
        {
            ClassSpecification classSpecification =
                (ClassSpecification)classSpecifications.get(index);

            multiClassPoolVisitor.addClassPoolVisitor(
                createClassPoolVisitor(classSpecification,
                                       classVisitor,
                                       memberVisitor));
        }
    }

    return multiClassPoolVisitor;
}
 

/**
 * Performs subroutine inlining of the given program class pool.
 */
public void execute(ClassPool programClassPool)
{
    // Clean up any old visitor info.
    programClassPool.classesAccept(new ClassCleaner());

    // Inline all subroutines.
    ClassVisitor inliner =
        new AllMethodVisitor(
        new AllAttributeVisitor(
        new CodeSubroutineInliner()));

    // In Java Standard Edition, only class files from Java 6 or higher
    // should be preverified.
    if (!configuration.microEdition)
    {
        inliner =
            new ClassVersionFilter(ClassConstants.INTERNAL_CLASS_VERSION_1_6,
                                   Integer.MAX_VALUE,
                                   inliner);
    }

    programClassPool.classesAccept(inliner);
}
 

/**
 * Lets the Clazz objects referenced in the descriptor string
 * accept the given visitor.
 */
public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            if (referencedClasses[index] != null)
            {
                referencedClasses[index].accept(classVisitor);
            }
        }
    }
}
 

public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            if (referencedClasses[index] != null)
            {
                referencedClasses[index].accept(classVisitor);
            }
        }
    }
}
 

/**
 * Creates a new DataEntryClassFilter for reading the specified
 * Clazz objects.
 */
public ClassReader(boolean        isLibrary,
                   boolean        skipNonPublicLibraryClasses,
                   boolean        skipNonPublicLibraryClassMembers,
                   WarningPrinter warningPrinter,
                   ClassVisitor   classVisitor)
{
    this.isLibrary                        = isLibrary;
    this.skipNonPublicLibraryClasses      = skipNonPublicLibraryClasses;
    this.skipNonPublicLibraryClassMembers = skipNonPublicLibraryClassMembers;
    this.warningPrinter                   = warningPrinter;
    this.classVisitor                     = classVisitor;
}
 

/**
 * Applies the given visitor to all referenced classes.
 */
public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            Clazz referencedClass = referencedClasses[index];
            if (referencedClass != null)
            {
                referencedClass.accept(classVisitor);
            }
        }
    }
}
 

/**
 * Applies the given visitor to all referenced classes.
 */
public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            Clazz referencedClass = referencedClasses[index];
            if (referencedClass != null)
            {
                referencedClass.accept(classVisitor);
            }
        }
    }
}
 

@Override
public void visitAnyClass(Clazz clazz)
{
    // Is the class marked to be escaping?
    ClassVisitor classVisitor = EscapingClassMarker.isClassEscaping(clazz) ?
        escapingClassVisitor :
        otherClassVisitor;

    if (classVisitor != null)
    {
        clazz.accept(classVisitor);
    }
}
 

@Override
public void visitAnyClass(Clazz clazz)
{
    ClassVisitor delegateVisitor =
        KeepMarker.isKept(clazz) ? acceptedVisitor : rejectedVisitor;

    if (delegateVisitor != null)
    {
        clazz.accept(delegateVisitor);
    }
}
 

/**
 * Lets the referenced class accept the given visitor.
 */
public void referencedClassAccept(ClassVisitor classVisitor)
{
    if (referencedClass != null)
    {
        referencedClass.accept(classVisitor);
    }
}
 

public void visitProgramClass(ProgramClass programClass)
{
    // Is the class marked as a simple enum?
    ClassVisitor classVisitor = SimpleEnumMarker.isSimpleEnum(programClass) ?
        simpleEnumClassVisitor : otherClassVisitor;

    if (classVisitor != null)
    {
        classVisitor.visitProgramClass(programClass);
    }
}
 

/**
 * Lets the referenced class accept the given visitor.
 */
public void referencedClassAccept(ClassVisitor classVisitor)
{
    if (referencedClass != null)
    {
        referencedClass.accept(classVisitor);
    }
}
 

/**
 * Constructs a ClassVisitor to efficiently travel to the specified class
 * members.
 *
 * @param classSpecification the specifications of the class members to visit.
 * @param memberVisitor      the MemberVisitor to be applied to matching
 *                           class members.
 */
private static ClassVisitor createClassVisitor(ClassSpecification classSpecification,
                                               MemberVisitor      memberVisitor)
{
    MultiClassVisitor multiClassVisitor = new MultiClassVisitor();

    addMemberVisitors(classSpecification.fieldSpecifications,  true,  multiClassVisitor, memberVisitor);
    addMemberVisitors(classSpecification.methodSpecifications, false, multiClassVisitor, memberVisitor);

    // Mark the class member in this class and in super classes.
    return new ClassHierarchyTraveler(true, true, false, false,
                                      multiClassVisitor);
}
 

/**
 * Constructs a ClassVisitor that conditionally applies the given
 * ClassVisitor to all classes that contain the given class members.
 */
private static ClassVisitor createClassMemberTester(ClassSpecification classSpecification,
                                                    ClassVisitor       classVisitor)
{
    // Create a linked list of conditional visitors, for fields and for
    // methods.
    return createClassMemberTester(classSpecification.fieldSpecifications,
                                   true,
           createClassMemberTester(classSpecification.methodSpecifications,
                                   false,
                                   classVisitor));
}
 

/**
 * Lets the referenced class accept the given visitor.
 */
public void referencedClassAccept(ClassVisitor classVisitor)
{
    if (referencedClass != null)
    {
        referencedClass.accept(classVisitor);
    }
}
 

/**
 * Lets the Clazz objects referenced in the signature string accept the
 * given visitor.
 */
public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            if (referencedClasses[index] != null)
            {
                referencedClasses[index].accept(classVisitor);
            }
        }
    }
}
 

@Override
public void visitAnyClass(Clazz clazz)
{
    ClassVisitor delegateVisitor = selectVisitor(clazz);
    if (delegateVisitor != null)
    {
        clazz.accept(delegateVisitor);
    }
}
 

/**
 * Applies the given visitor to all referenced classes.
 */
public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            Clazz referencedClass = referencedClasses[index];
            if (referencedClass != null)
            {
                referencedClass.accept(classVisitor);
            }
        }
    }
}
 

public void visitProgramClass(ProgramClass programClass)
{
    // Is the class marked to be retargeted?
    ClassVisitor classVisitor = ClassMerger.getTargetClass(programClass) != null ?
        retargetedClassVisitor : otherClassVisitor;

    if (classVisitor != null)
    {
        classVisitor.visitProgramClass(programClass);
    }
}
 

/**
 * Lets the referenced class accept the given visitor.
 */
public void referencedClassAccept(ClassVisitor classVisitor)
{
    if (referencedClass != null)
    {
        referencedClass.accept(classVisitor);
    }
}
 

/**
 * Lets the referenced class accept the given visitor.
 */
public void referencedClassAccept(ClassVisitor classVisitor)
{
    if (referencedClass != null)
    {
        referencedClass.accept(classVisitor);
    }
}
 

public void visitProgramClass(ProgramClass programClass)
{
    // Is the class marked as a simple enum?
    ClassVisitor classVisitor = SimpleEnumMarker.isSimpleEnum(programClass) ?
        simpleEnumClassVisitor : otherClassVisitor;

    if (classVisitor != null)
    {
        classVisitor.visitProgramClass(programClass);
    }
}
 

/**
 * Applies the given visitor to all referenced classes.
 */
public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            Clazz referencedClass = referencedClasses[index];
            if (referencedClass != null)
            {
                referencedClass.accept(classVisitor);
            }
        }
    }
}
 

/**
 * Applies the given visitor to all referenced classes.
 */
public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        for (int index = 0; index < referencedClasses.length; index++)
        {
            Clazz referencedClass = referencedClasses[index];
            if (referencedClass != null)
            {
                referencedClass.accept(classVisitor);
            }
        }
    }
}
 

/**
 * Lets the given class visitor visit the superclass, if it is known.
 * @param classVisitor the <code>ClassVisitor</code> that will visit the
 *                     superclass.
 */
public void superClassAccept(ClassVisitor classVisitor)
{
    if (superClass != null)
    {
        superClass.accept(classVisitor);
    }
}
 

/**
 * Applies the given visitor to the first referenced class. This is the
 * main annotation class.
 */
public void referencedClassAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        Clazz referencedClass = referencedClasses[0];
        if (referencedClass != null)
        {
            referencedClass.accept(classVisitor);
        }
    }
}
 

/**
 * Applies the given visitor to the first referenced class. This is the
 * main annotation class.
 */
public void referencedClassAccept(ClassVisitor classVisitor)
{
    if (referencedClasses != null)
    {
        Clazz referencedClass = referencedClasses[0];
        if (referencedClass != null)
        {
            referencedClass.accept(classVisitor);
        }
    }
}
 

/**
 * Applies the given ClassVisitor to all classes in the class pool,
 * in sorted order.
 */
public void classesAcceptAlphabetically(ClassVisitor classVisitor)
{
    // We're already using a tree map.
    //TreeMap sortedClasses = new TreeMap(classes);
    //Iterator iterator = sortedClasses.values().iterator();

    Iterator iterator = classes.values().iterator();
    while (iterator.hasNext())
    {
        Clazz clazz = (Clazz)iterator.next();
        clazz.accept(classVisitor);
    }
}
 

/**
 * Applies the given ClassVisitor to the class with the given name,
 * if it is present in the class pool.
 */
public void classAccept(String className, ClassVisitor classVisitor)
{
    Clazz clazz = getClass(className);
    if (clazz != null)
    {
        clazz.accept(classVisitor);
    }
}
 

public void referencedClassesAccept(ClassVisitor classVisitor)
{
    if (referencedClass != null)
    {
        referencedClass.accept(classVisitor);
    }
}