sometsome 3.10.48 → 3.10.50.35

data/lib/proguard4.7/src/proguard/shrink/Shrinker.java

@@ -1,181 +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.shrink;
-
-import proguard.*;
-import proguard.classfile.*;
-import proguard.classfile.attribute.visitor.*;
-import proguard.classfile.visitor.*;
-
-import java.io.*;
-
-/**
- * This class shrinks class pools according to a given configuration.
- *
- * @author Eric Lafortune
- */
-public class Shrinker
-{
-    private final Configuration configuration;
-
-
-    /**
-     * Creates a new Shrinker.
-     */
-    public Shrinker(Configuration configuration)
-    {
-        this.configuration = configuration;
-    }
-
-
-    /**
-     * Performs shrinking of the given program class pool.
-     */
-    public ClassPool execute(ClassPool programClassPool,
-                             ClassPool libraryClassPool) throws IOException
-    {
-        // Check if we have at least some keep commands.
-        if (configuration.keep == null)
-        {
-            throw new IOException("You have to specify '-keep' options for the shrinking step.");
-        }
-
-        // Clean up any old visitor info.
-        programClassPool.classesAccept(new ClassCleaner());
-        libraryClassPool.classesAccept(new ClassCleaner());
-
-        // Create a visitor for marking the seeds.
-        UsageMarker usageMarker = configuration.whyAreYouKeeping == null ?
-            new UsageMarker() :
-            new ShortestUsageMarker();
-
-        // Automatically mark the parameterless constructors of seed classes,
-        // mainly for convenience and for backward compatibility.
-        ClassVisitor classUsageMarker =
-            new MultiClassVisitor(new ClassVisitor[]
-            {
-                usageMarker,
-                new NamedMethodVisitor(ClassConstants.INTERNAL_METHOD_NAME_INIT,
-                                       ClassConstants.INTERNAL_METHOD_TYPE_INIT,
-                                       usageMarker)
-            });
-
-        ClassPoolVisitor classPoolvisitor =
-            ClassSpecificationVisitorFactory.createClassPoolVisitor(configuration.keep,
-                                                                    classUsageMarker,
-                                                                    usageMarker,
-                                                                    true,
-                                                                    false,
-                                                                    false);
-        // Mark the seeds.
-        programClassPool.accept(classPoolvisitor);
-        libraryClassPool.accept(classPoolvisitor);
-
-        // Mark interfaces that have to be kept.
-        programClassPool.classesAccept(new InterfaceUsageMarker(usageMarker));
-
-        // Mark the inner class and annotation information that has to be kept.
-        programClassPool.classesAccept(
-            new UsedClassFilter(usageMarker,
-            new AllAttributeVisitor(true,
-            new MultiAttributeVisitor(new AttributeVisitor[]
-            {
-                new InnerUsageMarker(usageMarker),
-                new AnnotationUsageMarker(usageMarker),
-            }))));
-
-        // Should we explain ourselves?
-        if (configuration.whyAreYouKeeping != null)
-        {
-            System.out.println();
-
-            // Create a visitor for explaining classes and class members.
-            ShortestUsagePrinter shortestUsagePrinter =
-                new ShortestUsagePrinter((ShortestUsageMarker)usageMarker,
-                                         configuration.verbose);
-
-            ClassPoolVisitor whyClassPoolvisitor =
-                ClassSpecificationVisitorFactory.createClassPoolVisitor(configuration.whyAreYouKeeping,
-                                                                        shortestUsagePrinter,
-                                                                        shortestUsagePrinter);
-
-            // Mark the seeds.
-            programClassPool.accept(whyClassPoolvisitor);
-            libraryClassPool.accept(whyClassPoolvisitor);
-        }
-
-        if (configuration.printUsage != null)
-        {
-            PrintStream ps = isFile(configuration.printUsage) ?
-                new PrintStream(new BufferedOutputStream(new FileOutputStream(configuration.printUsage))) :
-                System.out;
-
-            // Print out items that will be removed.
-            programClassPool.classesAcceptAlphabetically(
-                new UsagePrinter(usageMarker, true, ps));
-
-            if (ps != System.out)
-            {
-                ps.close();
-            }
-        }
-
-        // Discard unused program classes.
-        int originalProgramClassPoolSize = programClassPool.size();
-
-        ClassPool newProgramClassPool = new ClassPool();
-        programClassPool.classesAccept(
-            new UsedClassFilter(usageMarker,
-            new MultiClassVisitor(
-            new ClassVisitor[] {
-                new ClassShrinker(usageMarker),
-                new ClassPoolFiller(newProgramClassPool)
-            })));
-
-        programClassPool.clear();
-
-        // Check if we have at least some output classes.
-        int newProgramClassPoolSize = newProgramClassPool.size();
-        if (newProgramClassPoolSize == 0)
-        {
-            throw new IOException("The output jar is empty. Did you specify the proper '-keep' options?");
-        }
-
-        if (configuration.verbose)
-        {
-            System.out.println("Removing unused program classes and class elements...");
-            System.out.println("  Original number of program classes: " + originalProgramClassPoolSize);
-            System.out.println("  Final number of program classes:    " + newProgramClassPoolSize);
-        }
-
-        return newProgramClassPool;
-    }
-
-
-    /**
-     * Returns whether the given file is actually a file, or just a placeholder
-     * for the standard output.
-     */
-    private boolean isFile(File file)
-    {
-        return file.getPath().length() > 0;
-    }
-}

data/lib/proguard4.7/src/proguard/shrink/UsageMarker.java

@@ -1,1036 +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.shrink;
-
-import proguard.classfile.*;
-import proguard.classfile.attribute.*;
-import proguard.classfile.attribute.annotation.*;
-import proguard.classfile.attribute.preverification.*;
-import proguard.classfile.attribute.preverification.visitor.*;
-import proguard.classfile.attribute.visitor.*;
-import proguard.classfile.constant.*;
-import proguard.classfile.constant.visitor.*;
-import proguard.classfile.instruction.*;
-import proguard.classfile.instruction.visitor.InstructionVisitor;
-import proguard.classfile.util.*;
-import proguard.classfile.visitor.*;
-
-
-/**
- * This ClassVisitor and MemberVisitor recursively marks all classes and class
- * elements that are being used.
- *
- * @see ClassShrinker
- *
- * @author Eric Lafortune
- */
-class      UsageMarker
-extends    SimplifiedVisitor
-implements ClassVisitor,
-           MemberVisitor,
-           ConstantVisitor,
-           AttributeVisitor,
-           InnerClassesInfoVisitor,
-           ExceptionInfoVisitor,
-           StackMapFrameVisitor,
-           VerificationTypeVisitor,
-           LocalVariableInfoVisitor,
-           LocalVariableTypeInfoVisitor,
-//         AnnotationVisitor,
-//         ElementValueVisitor,
-           InstructionVisitor
-{
-    // A visitor info flag to indicate the ProgramMember object is being used,
-    // if its Clazz can be determined as being used as well.
-    private static final Object POSSIBLY_USED = new Object();
-    // A visitor info flag to indicate the visitor accepter is being used.
-    private static final Object USED          = new Object();
-
-
-    private final MyInterfaceUsageMarker          interfaceUsageMarker           = new MyInterfaceUsageMarker();
-    private final MyPossiblyUsedMemberUsageMarker possiblyUsedMemberUsageMarker  = new MyPossiblyUsedMemberUsageMarker();
-    private final MemberVisitor                   nonEmptyMethodUsageMarker      = new AllAttributeVisitor(
-                                                                                   new MyNonEmptyMethodUsageMarker());
-    private final ConstantVisitor                 parameterlessConstructorMarker = new ConstantTagFilter(new int[] { ClassConstants.CONSTANT_String, ClassConstants.CONSTANT_Class },
-                                                                                   new ReferencedClassVisitor(
-                                                                                   new NamedMethodVisitor(ClassConstants.INTERNAL_METHOD_NAME_INIT,
-                                                                                                          ClassConstants.INTERNAL_METHOD_TYPE_INIT,
-                                                                                                          this)));
-
-    // Implementations for ClassVisitor.
-
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        if (shouldBeMarkedAsUsed(programClass))
-        {
-            // Mark this class.
-            markAsUsed(programClass);
-
-            markProgramClassBody(programClass);
-        }
-    }
-
-
-    protected void markProgramClassBody(ProgramClass programClass)
-    {
-        // Mark this class's name.
-        markConstant(programClass, programClass.u2thisClass);
-
-        // Mark the superclass.
-        if (programClass.u2superClass != 0)
-        {
-            markConstant(programClass, programClass.u2superClass);
-        }
-
-        // Give the interfaces preliminary marks.
-        programClass.hierarchyAccept(false, false, true, false,
-                                     interfaceUsageMarker);
-
-        // Explicitly mark the <clinit> method, if it's not empty.
-        programClass.methodAccept(ClassConstants.INTERNAL_METHOD_NAME_CLINIT,
-                                  ClassConstants.INTERNAL_METHOD_TYPE_CLINIT,
-                                  nonEmptyMethodUsageMarker);
-
-        // Process all class members that have already been marked as possibly used.
-        programClass.fieldsAccept(possiblyUsedMemberUsageMarker);
-        programClass.methodsAccept(possiblyUsedMemberUsageMarker);
-
-        // Mark the attributes.
-        programClass.attributesAccept(this);
-    }
-
-
-    public void visitLibraryClass(LibraryClass libraryClass)
-    {
-        if (shouldBeMarkedAsUsed(libraryClass))
-        {
-            markAsUsed(libraryClass);
-
-            // We're not going to analyze all library code. We're assuming that
-            // if this class is being used, all of its methods will be used as
-            // well. We'll mark them as such (here and in all subclasses).
-
-            // Mark the superclass.
-            Clazz superClass = libraryClass.superClass;
-            if (superClass != null)
-            {
-                superClass.accept(this);
-            }
-
-            // Mark the interfaces.
-            Clazz[] interfaceClasses = libraryClass.interfaceClasses;
-            if (interfaceClasses != null)
-            {
-                for (int index = 0; index < interfaceClasses.length; index++)
-                {
-                    if (interfaceClasses[index] != null)
-                    {
-                        interfaceClasses[index].accept(this);
-                    }
-                }
-            }
-
-            // Mark all methods.
-            libraryClass.methodsAccept(this);
-        }
-    }
-
-
-    /**
-     * This ClassVisitor marks ProgramClass objects as possibly used,
-     * and it visits LibraryClass objects with its outer UsageMarker.
-     */
-    private class MyInterfaceUsageMarker
-    implements    ClassVisitor
-    {
-        public void visitProgramClass(ProgramClass programClass)
-        {
-            if (shouldBeMarkedAsPossiblyUsed(programClass))
-            {
-                // We can't process the interface yet, because it might not
-                // be required. Give it a preliminary mark.
-                markAsPossiblyUsed(programClass);
-            }
-        }
-
-        public void visitLibraryClass(LibraryClass libraryClass)
-        {
-            // Make sure all library interface methods are marked.
-            UsageMarker.this.visitLibraryClass(libraryClass);
-        }
-    }
-
-
-    /**
-     * This MemberVisitor marks ProgramField and ProgramMethod objects that
-     * have already been marked as possibly used.
-     */
-    private class MyPossiblyUsedMemberUsageMarker
-    extends       SimplifiedVisitor
-    implements    MemberVisitor
-    {
-        // Implementations for MemberVisitor.
-
-        public void visitProgramField(ProgramClass programClass, ProgramField programField)
-        {
-            // Has the method already been referenced?
-            if (isPossiblyUsed(programField))
-            {
-                markAsUsed(programField);
-
-                // Mark the name and descriptor.
-                markConstant(programClass, programField.u2nameIndex);
-                markConstant(programClass, programField.u2descriptorIndex);
-
-                // Mark the attributes.
-                programField.attributesAccept(programClass, UsageMarker.this);
-
-                // Mark the classes referenced in the descriptor string.
-                programField.referencedClassesAccept(UsageMarker.this);
-            }
-        }
-
-
-        public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
-        {
-            // Has the method already been referenced?
-            if (isPossiblyUsed(programMethod))
-            {
-                markAsUsed(programMethod);
-
-                // Mark the method body.
-                markProgramMethodBody(programClass, programMethod);
-
-                // Note that, if the method has been marked as possibly used,
-                // the method hierarchy has already been marked (cfr. below).
-            }
-        }
-    }
-
-
-    /**
-     * This AttributeVisitor marks ProgramMethod objects of non-empty methods.
-     */
-    private class MyNonEmptyMethodUsageMarker
-    extends       SimplifiedVisitor
-    implements    AttributeVisitor
-    {
-        // Implementations for AttributeVisitor.
-
-        public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-
-
-        public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
-        {
-            if (codeAttribute.u4codeLength > 1)
-            {
-                method.accept(clazz, UsageMarker.this);
-            }
-        }
-    }
-
-
-    // Implementations for MemberVisitor.
-
-    public void visitProgramField(ProgramClass programClass, ProgramField programField)
-    {
-        if (shouldBeMarkedAsUsed(programField))
-        {
-            // Is the field's class used?
-            if (isUsed(programClass))
-            {
-                markAsUsed(programField);
-
-                // Mark the field body.
-                markProgramFieldBody(programClass, programField);
-            }
-
-            // Hasn't the field been marked as possibly being used yet?
-            else if (shouldBeMarkedAsPossiblyUsed(programField))
-            {
-                // We can't process the field yet, because the class isn't
-                // marked as being used (yet). Give it a preliminary mark.
-                markAsPossiblyUsed(programField);
-            }
-        }
-    }
-
-
-    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
-    {
-        if (shouldBeMarkedAsUsed(programMethod))
-        {
-            // Is the method's class used?
-            if (isUsed(programClass))
-            {
-                markAsUsed(programMethod);
-
-                // Mark the method body.
-                markProgramMethodBody(programClass, programMethod);
-
-                // Mark the method hierarchy.
-                markMethodHierarchy(programClass, programMethod);
-            }
-
-            // Hasn't the method been marked as possibly being used yet?
-            else if (shouldBeMarkedAsPossiblyUsed(programMethod))
-            {
-                // We can't process the method yet, because the class isn't
-                // marked as being used (yet). Give it a preliminary mark.
-                markAsPossiblyUsed(programMethod);
-
-                // Mark the method hierarchy.
-                markMethodHierarchy(programClass, programMethod);
-            }
-        }
-    }
-
-
-    public void visitLibraryField(LibraryClass programClass, LibraryField programField) {}
-
-
-    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
-    {
-        if (shouldBeMarkedAsUsed(libraryMethod))
-        {
-            markAsUsed(libraryMethod);
-
-            // Mark the method hierarchy.
-            markMethodHierarchy(libraryClass, libraryMethod);
-        }
-    }
-
-
-    protected void markProgramFieldBody(ProgramClass programClass, ProgramField programField)
-    {
-        // Mark the name and descriptor.
-        markConstant(programClass, programField.u2nameIndex);
-        markConstant(programClass, programField.u2descriptorIndex);
-
-        // Mark the attributes.
-        programField.attributesAccept(programClass, this);
-
-        // Mark the classes referenced in the descriptor string.
-        programField.referencedClassesAccept(this);
-    }
-
-
-    protected void markProgramMethodBody(ProgramClass programClass, ProgramMethod programMethod)
-    {
-        // Mark the name and descriptor.
-        markConstant(programClass, programMethod.u2nameIndex);
-        markConstant(programClass, programMethod.u2descriptorIndex);
-
-        // Mark the attributes.
-        programMethod.attributesAccept(programClass, this);
-
-        // Mark the classes referenced in the descriptor string.
-        programMethod.referencedClassesAccept(this);
-    }
-
-
-    /**
-     * Marks the hierarchy of implementing or overriding methods corresponding
-     * to the given method, if any.
-     */
-    protected void markMethodHierarchy(Clazz clazz, Method method)
-    {
-        if ((method.getAccessFlags() &
-             (ClassConstants.INTERNAL_ACC_PRIVATE |
-              ClassConstants.INTERNAL_ACC_STATIC)) == 0 &&
-            !ClassUtil.isInitializer(method.getName(clazz)))
-        {
-            clazz.accept(new ConcreteClassDownTraveler(
-                         new ClassHierarchyTraveler(true, true, false, true,
-                         new NamedMethodVisitor(method.getName(clazz),
-                                                method.getDescriptor(clazz),
-                         new MemberAccessFilter(0, ClassConstants.INTERNAL_ACC_PRIVATE | ClassConstants.INTERNAL_ACC_STATIC | ClassConstants.INTERNAL_ACC_ABSTRACT,
-                         this)))));
-        }
-    }
-
-
-    // Implementations for ConstantVisitor.
-
-    public void visitIntegerConstant(Clazz clazz, IntegerConstant integerConstant)
-    {
-        if (shouldBeMarkedAsUsed(integerConstant))
-        {
-            markAsUsed(integerConstant);
-        }
-    }
-
-
-    public void visitLongConstant(Clazz clazz, LongConstant longConstant)
-    {
-        if (shouldBeMarkedAsUsed(longConstant))
-        {
-            markAsUsed(longConstant);
-        }
-    }
-
-
-    public void visitFloatConstant(Clazz clazz, FloatConstant floatConstant)
-    {
-        if (shouldBeMarkedAsUsed(floatConstant))
-        {
-            markAsUsed(floatConstant);
-        }
-    }
-
-
-    public void visitDoubleConstant(Clazz clazz, DoubleConstant doubleConstant)
-    {
-        if (shouldBeMarkedAsUsed(doubleConstant))
-        {
-            markAsUsed(doubleConstant);
-        }
-    }
-
-
-    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
-    {
-        if (shouldBeMarkedAsUsed(stringConstant))
-        {
-            markAsUsed(stringConstant);
-
-            markConstant(clazz, stringConstant.u2stringIndex);
-
-            // Mark the referenced class and class member, if any.
-            stringConstant.referencedClassAccept(this);
-            stringConstant.referencedMemberAccept(this);
-        }
-    }
-
-
-    public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant)
-    {
-        if (shouldBeMarkedAsUsed(utf8Constant))
-        {
-            markAsUsed(utf8Constant);
-        }
-    }
-
-
-    public void visitInvokeDynamicConstant(Clazz clazz, InvokeDynamicConstant invokeDynamicConstant)
-    {
-        if (shouldBeMarkedAsUsed(invokeDynamicConstant))
-        {
-            markAsUsed(invokeDynamicConstant);
-
-            markConstant(clazz, invokeDynamicConstant.u2nameAndTypeIndex);
-
-            // Mark the bootstrap methods attribute.
-            clazz.attributesAccept(new MyBootStrapMethodUsageMarker(invokeDynamicConstant.u2bootstrapMethodAttributeIndex));
-        }
-    }
-
-
-    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
-    {
-        if (shouldBeMarkedAsUsed(methodHandleConstant))
-        {
-            markAsUsed(methodHandleConstant);
-
-            markConstant(clazz, methodHandleConstant.u2referenceIndex);
-        }
-    }
-
-
-    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
-    {
-        if (shouldBeMarkedAsUsed(refConstant))
-        {
-            markAsUsed(refConstant);
-
-            markConstant(clazz, refConstant.u2classIndex);
-            markConstant(clazz, refConstant.u2nameAndTypeIndex);
-
-            // When compiled with "-target 1.2" or higher, the class or
-            // interface actually containing the referenced class member may
-            // be higher up the hierarchy. Make sure it's marked, in case it
-            // isn't used elsewhere.
-            refConstant.referencedClassAccept(this);
-
-            // Mark the referenced class member itself.
-            refConstant.referencedMemberAccept(this);
-        }
-    }
-
-
-    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
-    {
-        if (shouldBeMarkedAsUsed(classConstant))
-        {
-            markAsUsed(classConstant);
-
-            markConstant(clazz, classConstant.u2nameIndex);
-
-            // Mark the referenced class itself.
-            classConstant.referencedClassAccept(this);
-        }
-    }
-
-
-    public void visitMethodTypeConstant(Clazz clazz, MethodTypeConstant methodTypeConstant)
-    {
-        if (shouldBeMarkedAsUsed(methodTypeConstant))
-        {
-            markAsUsed(methodTypeConstant);
-
-            markConstant(clazz, methodTypeConstant.u2descriptorIndex);
-        }
-    }
-
-
-    public void visitNameAndTypeConstant(Clazz clazz, NameAndTypeConstant nameAndTypeConstant)
-    {
-        if (shouldBeMarkedAsUsed(nameAndTypeConstant))
-        {
-            markAsUsed(nameAndTypeConstant);
-
-            markConstant(clazz, nameAndTypeConstant.u2nameIndex);
-            markConstant(clazz, nameAndTypeConstant.u2descriptorIndex);
-        }
-    }
-
-
-    /**
-     * This AttributeVisitor marks the bootstrap methods attributes, their
-     * method entries, their method handles, and their arguments.
-     */
-    private class MyBootStrapMethodUsageMarker
-    extends       SimplifiedVisitor
-    implements    AttributeVisitor,
-                  BootstrapMethodInfoVisitor
-    {
-        private int bootstrapMethodIndex;
-
-
-        private MyBootStrapMethodUsageMarker(int bootstrapMethodIndex)
-        {
-            this.bootstrapMethodIndex = bootstrapMethodIndex;
-        }
-
-
-        // Implementations for AttributeVisitor.
-
-        public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-
-
-        public void visitBootstrapMethodsAttribute(Clazz clazz, BootstrapMethodsAttribute bootstrapMethodsAttribute)
-        {
-            if (shouldBeMarkedAsUsed(bootstrapMethodsAttribute))
-            {
-                markAsUsed(bootstrapMethodsAttribute);
-
-                markConstant(clazz, bootstrapMethodsAttribute.u2attributeNameIndex);
-
-                bootstrapMethodsAttribute.bootstrapMethodEntryAccept(clazz,
-                                                                     bootstrapMethodIndex,
-                                                                     this);
-            }
-        }
-
-
-        // Implementations for BootstrapMethodInfoVisitor.
-
-        public void visitBootstrapMethodInfo(Clazz clazz, BootstrapMethodInfo bootstrapMethodInfo)
-        {
-            markAsUsed(bootstrapMethodInfo);
-
-            markConstant(clazz, bootstrapMethodInfo.u2methodHandleIndex);
-
-            // Mark the constant pool entries referenced by the arguments.
-            bootstrapMethodInfo.methodArgumentsAccept(clazz, UsageMarker.this);
-        }
-    }
-
-
-    // Implementations for AttributeVisitor.
-    // Note that attributes are typically only referenced once, so we don't
-    // test if they have been marked already.
-
-    public void visitUnknownAttribute(Clazz clazz, UnknownAttribute unknownAttribute)
-    {
-        // This is the best we can do for unknown attributes.
-        markAsUsed(unknownAttribute);
-
-        markConstant(clazz, unknownAttribute.u2attributeNameIndex);
-    }
-
-
-    public void visitBootstrapMethodsAttribute(Clazz clazz, BootstrapMethodsAttribute bootstrapMethodsAttribute)
-    {
-        // Don't mark the attribute and its name here. We may mark it in
-        // MyBootStrapMethodsAttributeUsageMarker.
-    }
-
-
-    public void visitSourceFileAttribute(Clazz clazz, SourceFileAttribute sourceFileAttribute)
-    {
-        markAsUsed(sourceFileAttribute);
-
-        markConstant(clazz, sourceFileAttribute.u2attributeNameIndex);
-        markConstant(clazz, sourceFileAttribute.u2sourceFileIndex);
-    }
-
-
-    public void visitSourceDirAttribute(Clazz clazz, SourceDirAttribute sourceDirAttribute)
-    {
-        markAsUsed(sourceDirAttribute);
-
-        markConstant(clazz, sourceDirAttribute.u2attributeNameIndex);
-        markConstant(clazz, sourceDirAttribute.u2sourceDirIndex);
-    }
-
-
-    public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
-    {
-        // Don't mark the attribute and its name yet. We may mark it later, in
-        // InnerUsageMarker.
-        //markAsUsed(innerClassesAttribute);
-
-        //markConstant(clazz, innerClassesAttribute.u2attrNameIndex);
-
-        // Do mark the outer class entries.
-        innerClassesAttribute.innerClassEntriesAccept(clazz, this);
-    }
-
-
-    public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute)
-    {
-        markAsUsed(enclosingMethodAttribute);
-
-        markConstant(clazz, enclosingMethodAttribute.u2attributeNameIndex);
-        markConstant(clazz, enclosingMethodAttribute.u2classIndex);
-
-        if (enclosingMethodAttribute.u2nameAndTypeIndex != 0)
-        {
-            markConstant(clazz, enclosingMethodAttribute.u2nameAndTypeIndex);
-        }
-    }
-
-
-    public void visitDeprecatedAttribute(Clazz clazz, DeprecatedAttribute deprecatedAttribute)
-    {
-        markAsUsed(deprecatedAttribute);
-
-        markConstant(clazz, deprecatedAttribute.u2attributeNameIndex);
-    }
-
-
-    public void visitSyntheticAttribute(Clazz clazz, SyntheticAttribute syntheticAttribute)
-    {
-        markAsUsed(syntheticAttribute);
-
-        markConstant(clazz, syntheticAttribute.u2attributeNameIndex);
-    }
-
-
-    public void visitSignatureAttribute(Clazz clazz, SignatureAttribute signatureAttribute)
-    {
-        markAsUsed(signatureAttribute);
-
-        markConstant(clazz, signatureAttribute.u2attributeNameIndex);
-        markConstant(clazz, signatureAttribute.u2signatureIndex);
-    }
-
-
-    public void visitConstantValueAttribute(Clazz clazz, Field field, ConstantValueAttribute constantValueAttribute)
-    {
-        markAsUsed(constantValueAttribute);
-
-        markConstant(clazz, constantValueAttribute.u2attributeNameIndex);
-        markConstant(clazz, constantValueAttribute.u2constantValueIndex);
-    }
-
-
-    public void visitExceptionsAttribute(Clazz clazz, Method method, ExceptionsAttribute exceptionsAttribute)
-    {
-        markAsUsed(exceptionsAttribute);
-
-        markConstant(clazz, exceptionsAttribute.u2attributeNameIndex);
-
-        // Mark the constant pool entries referenced by the exceptions.
-        exceptionsAttribute.exceptionEntriesAccept((ProgramClass)clazz, this);
-    }
-
-
-    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
-    {
-        markAsUsed(codeAttribute);
-
-        markConstant(clazz, codeAttribute.u2attributeNameIndex);
-
-        // Mark the constant pool entries referenced by the instructions,
-        // by the exceptions, and by the attributes.
-        codeAttribute.instructionsAccept(clazz, method, this);
-        codeAttribute.exceptionsAccept(clazz, method, this);
-        codeAttribute.attributesAccept(clazz, method, this);
-    }
-
-
-    public void visitStackMapAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, StackMapAttribute stackMapAttribute)
-    {
-        markAsUsed(stackMapAttribute);
-
-        markConstant(clazz, stackMapAttribute.u2attributeNameIndex);
-
-        // Mark the constant pool entries referenced by the stack map frames.
-        stackMapAttribute.stackMapFramesAccept(clazz, method, codeAttribute, this);
-    }
-
-
-    public void visitStackMapTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, StackMapTableAttribute stackMapTableAttribute)
-    {
-        markAsUsed(stackMapTableAttribute);
-
-        markConstant(clazz, stackMapTableAttribute.u2attributeNameIndex);
-
-        // Mark the constant pool entries referenced by the stack map frames.
-        stackMapTableAttribute.stackMapFramesAccept(clazz, method, codeAttribute, this);
-    }
-
-
-    public void visitLineNumberTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LineNumberTableAttribute lineNumberTableAttribute)
-    {
-        markAsUsed(lineNumberTableAttribute);
-
-        markConstant(clazz, lineNumberTableAttribute.u2attributeNameIndex);
-    }
-
-
-    public void visitLocalVariableTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTableAttribute localVariableTableAttribute)
-    {
-        markAsUsed(localVariableTableAttribute);
-
-        markConstant(clazz, localVariableTableAttribute.u2attributeNameIndex);
-
-        // Mark the constant pool entries referenced by the local variables.
-        localVariableTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
-    }
-
-
-    public void visitLocalVariableTypeTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeTableAttribute localVariableTypeTableAttribute)
-    {
-        markAsUsed(localVariableTypeTableAttribute);
-
-        markConstant(clazz, localVariableTypeTableAttribute.u2attributeNameIndex);
-
-        // Mark the constant pool entries referenced by the local variable types.
-        localVariableTypeTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
-    }
-
-
-    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
-    {
-        // Don't mark the attribute and its contents yet. We may mark them later,
-        // in AnnotationUsageMarker.
-//        markAsUsed(annotationsAttribute);
-//
-//        markConstant(clazz, annotationsAttribute.u2attributeNameIndex);
-//
-//        // Mark the constant pool entries referenced by the annotations.
-//        annotationsAttribute.annotationsAccept(clazz, this);
-    }
-
-
-    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
-    {
-        // Don't mark the attribute and its contents yet. We may mark them later,
-        // in AnnotationUsageMarker.
-//        markAsUsed(parameterAnnotationsAttribute);
-//
-//        markConstant(clazz, parameterAnnotationsAttribute.u2attributeNameIndex);
-//
-//        // Mark the constant pool entries referenced by the annotations.
-//        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
-    }
-
-
-    public void visitAnnotationDefaultAttribute(Clazz clazz, Method method, AnnotationDefaultAttribute annotationDefaultAttribute)
-    {
-        // Don't mark the attribute and its contents yet. We may mark them later,
-        // in AnnotationUsageMarker.
-//        markAsUsed(annotationDefaultAttribute);
-//
-//        markConstant(clazz, annotationDefaultAttribute.u2attributeNameIndex);
-//
-//        // Mark the constant pool entries referenced by the element value.
-//        annotationDefaultAttribute.defaultValueAccept(clazz, this);
-    }
-
-
-    // Implementations for ExceptionInfoVisitor.
-
-    public void visitExceptionInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, ExceptionInfo exceptionInfo)
-    {
-        markAsUsed(exceptionInfo);
-
-        if (exceptionInfo.u2catchType != 0)
-        {
-            markConstant(clazz, exceptionInfo.u2catchType);
-        }
-    }
-
-
-    // Implementations for InnerClassesInfoVisitor.
-
-    public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo)
-    {
-        // At this point, we only mark outer classes of this class.
-        // Inner class can be marked later, by InnerUsageMarker.
-        if (innerClassesInfo.u2innerClassIndex != 0 &&
-            clazz.getName().equals(clazz.getClassName(innerClassesInfo.u2innerClassIndex)))
-        {
-            markAsUsed(innerClassesInfo);
-
-            innerClassesInfo.innerClassConstantAccept(clazz, this);
-            innerClassesInfo.outerClassConstantAccept(clazz, this);
-            innerClassesInfo.innerNameConstantAccept(clazz, this);
-        }
-    }
-
-
-    // Implementations for StackMapFrameVisitor.
-
-    public void visitAnyStackMapFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, StackMapFrame stackMapFrame) {}
-
-
-    public void visitSameOneFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SameOneFrame sameOneFrame)
-    {
-        // Mark the constant pool entries referenced by the verification types.
-        sameOneFrame.stackItemAccept(clazz, method, codeAttribute, offset, this);
-    }
-
-
-    public void visitMoreZeroFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, MoreZeroFrame moreZeroFrame)
-    {
-        // Mark the constant pool entries referenced by the verification types.
-        moreZeroFrame.additionalVariablesAccept(clazz, method, codeAttribute, offset, this);
-    }
-
-
-    public void visitFullFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, FullFrame fullFrame)
-    {
-        // Mark the constant pool entries referenced by the verification types.
-        fullFrame.variablesAccept(clazz, method, codeAttribute, offset, this);
-        fullFrame.stackAccept(clazz, method, codeAttribute, offset, this);
-    }
-
-
-    // Implementations for VerificationTypeVisitor.
-
-    public void visitAnyVerificationType(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, VerificationType verificationType) {}
-
-
-    public void visitObjectType(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ObjectType objectType)
-    {
-        markConstant(clazz, objectType.u2classIndex);
-    }
-
-
-    // Implementations for LocalVariableInfoVisitor.
-
-    public void visitLocalVariableInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableInfo localVariableInfo)
-    {
-        markConstant(clazz, localVariableInfo.u2nameIndex);
-        markConstant(clazz, localVariableInfo.u2descriptorIndex);
-    }
-
-
-    // Implementations for LocalVariableTypeInfoVisitor.
-
-    public void visitLocalVariableTypeInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeInfo localVariableTypeInfo)
-    {
-        markConstant(clazz, localVariableTypeInfo.u2nameIndex);
-        markConstant(clazz, localVariableTypeInfo.u2signatureIndex);
-    }
-
-
-//    // Implementations for AnnotationVisitor.
-//
-//    public void visitAnnotation(Clazz clazz, Annotation annotation)
-//    {
-//        markConstant(clazz, annotation.u2typeIndex);
-//
-//        // Mark the constant pool entries referenced by the element values.
-//        annotation.elementValuesAccept(clazz, this);
-//    }
-//
-//
-//    // Implementations for ElementValueVisitor.
-//
-//    public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue)
-//    {
-//        if (constantElementValue.u2elementNameIndex != 0)
-//        {
-//            markConstant(clazz, constantElementValue.u2elementNameIndex);
-//        }
-//
-//        markConstant(clazz, constantElementValue.u2constantValueIndex);
-//    }
-//
-//
-//    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
-//    {
-//        if (enumConstantElementValue.u2elementNameIndex != 0)
-//        {
-//            markConstant(clazz, enumConstantElementValue.u2elementNameIndex);
-//        }
-//
-//        markConstant(clazz, enumConstantElementValue.u2typeNameIndex);
-//        markConstant(clazz, enumConstantElementValue.u2constantNameIndex);
-//    }
-//
-//
-//    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
-//    {
-//        if (classElementValue.u2elementNameIndex != 0)
-//        {
-//            markConstant(clazz, classElementValue.u2elementNameIndex);
-//        }
-//
-//        // Mark the referenced class constant pool entry.
-//        markConstant(clazz, classElementValue.u2classInfoIndex);
-//    }
-//
-//
-//    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
-//    {
-//        if (annotationElementValue.u2elementNameIndex != 0)
-//        {
-//            markConstant(clazz, annotationElementValue.u2elementNameIndex);
-//        }
-//
-//        // Mark the constant pool entries referenced by the annotation.
-//        annotationElementValue.annotationAccept(clazz, this);
-//    }
-//
-//
-//    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
-//    {
-//        if (arrayElementValue.u2elementNameIndex != 0)
-//        {
-//            markConstant(clazz, arrayElementValue.u2elementNameIndex);
-//        }
-//
-//        // Mark the constant pool entries referenced by the element values.
-//        arrayElementValue.elementValuesAccept(clazz, annotation, this);
-//    }
-
-
-    // Implementations for InstructionVisitor.
-
-    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
-
-
-    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
-    {
-        markConstant(clazz, constantInstruction.constantIndex);
-
-        // Also mark the parameterless constructor of the class, in case the
-        // string constant or class constant is being used in a Class.forName
-        // or a .class construct.
-        clazz.constantPoolEntryAccept(constantInstruction.constantIndex,
-                                      parameterlessConstructorMarker);
-    }
-
-
-    // Small utility methods.
-
-    /**
-     * Marks the given visitor accepter as being used.
-     */
-    protected void markAsUsed(VisitorAccepter visitorAccepter)
-    {
-        visitorAccepter.setVisitorInfo(USED);
-    }
-
-
-    /**
-     * Returns whether the given visitor accepter should still be marked as
-     * being used.
-     */
-    protected boolean shouldBeMarkedAsUsed(VisitorAccepter visitorAccepter)
-    {
-        return visitorAccepter.getVisitorInfo() != USED;
-    }
-
-
-    /**
-     * Returns whether the given visitor accepter has been marked as being used.
-     */
-    protected boolean isUsed(VisitorAccepter visitorAccepter)
-    {
-        return visitorAccepter.getVisitorInfo() == USED;
-    }
-
-
-    /**
-     * Marks the given visitor accepter as possibly being used.
-     */
-    protected void markAsPossiblyUsed(VisitorAccepter visitorAccepter)
-    {
-        visitorAccepter.setVisitorInfo(POSSIBLY_USED);
-    }
-
-
-    /**
-     * Returns whether the given visitor accepter should still be marked as
-     * possibly being used.
-     */
-    protected boolean shouldBeMarkedAsPossiblyUsed(VisitorAccepter visitorAccepter)
-    {
-        return visitorAccepter.getVisitorInfo() != USED &&
-               visitorAccepter.getVisitorInfo() != POSSIBLY_USED;
-    }
-
-
-    /**
-     * Returns whether the given visitor accepter has been marked as possibly
-     * being used.
-     */
-    protected boolean isPossiblyUsed(VisitorAccepter visitorAccepter)
-    {
-        return visitorAccepter.getVisitorInfo() == POSSIBLY_USED;
-    }
-
-
-    /**
-     * Clears any usage marks from the given visitor accepter.
-     */
-    protected void markAsUnused(VisitorAccepter visitorAccepter)
-    {
-        visitorAccepter.setVisitorInfo(null);
-    }
-
-
-    /**
-     * Marks the given constant pool entry of the given class. This includes
-     * visiting any referenced objects.
-     */
-    private void markConstant(Clazz clazz, int index)
-    {
-        clazz.constantPoolEntryAccept(index, this);
-    }
-}