proguard.shrink.UsageMarker Maven / Gradle / Ivy
Go to download
ProGuard is a free Java class file shrinker, optimizer, and obfuscator. It removes unused classes, fields, methods, and attributes. It then optimizes the bytecode. It then renames the remaining classes, fields, and methods using short meaningless names. Finally, it preverifies the processed code for Java 6 or for Java Micro Edition.
The newest version!
/*
* ProGuard -- shrinking, optimization, obfuscation, and preverification
* of Java bytecode.
*
* Copyright (c) 2002-2009 Eric Lafortune ([email protected])
*
* 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.ConstantVisitor;
import proguard.classfile.instruction.*;
import proguard.classfile.instruction.visitor.InstructionVisitor;
import proguard.classfile.util.SimplifiedVisitor;
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 ClassVisitor dynamicClassMarker =
// new MultiClassVisitor(
// new ClassVisitor[]
// {
// this,
// 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 method.
programClass.methodAccept(ClassConstants.INTERNAL_METHOD_NAME_CLINIT,
ClassConstants.INTERNAL_METHOD_TYPE_CLINIT,
this);
// Explicitly mark the parameterless method.
programClass.methodAccept(ClassConstants.INTERNAL_METHOD_NAME_INIT,
ClassConstants.INTERNAL_METHOD_TYPE_INIT,
this);
// 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);
}
}
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).
}
}
}
// 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)
{
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 its parameterless constructor,
// if the string is being used in a Class.forName construct.
//stringConstant.referencedClassAccept(dynamicClassMarker);
// Mark the referenced class or class member, if any.
stringConstant.referencedClassAccept(this);
stringConstant.referencedMemberAccept(this);
}
}
public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant)
{
if (shouldBeMarkedAsUsed(utf8Constant))
{
markAsUsed(utf8Constant);
}
}
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 visitNameAndTypeConstant(Clazz clazz, NameAndTypeConstant nameAndTypeConstant)
{
if (shouldBeMarkedAsUsed(nameAndTypeConstant))
{
markAsUsed(nameAndTypeConstant);
markConstant(clazz, nameAndTypeConstant.u2nameIndex);
markConstant(clazz, nameAndTypeConstant.u2descriptorIndex);
}
}
// 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 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);
}
// 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);
}
}