/** * Lets the referenced class accept the given visitor. */ public void referencedClassAccept(ClassVisitor classVisitor) { if (referencedClass != null) { referencedClass.accept(classVisitor); } }
public void visitLibraryClass(LibraryClass libraryClass) { targetClass.addSubClass(libraryClass); } }
public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo) { // Make sure the outer class name is kept as well. int innerClassIndex = innerClassesInfo.u2innerClassIndex; int outerClassIndex = innerClassesInfo.u2outerClassIndex; if (innerClassIndex != 0 && outerClassIndex != 0 && clazz.getClassName(innerClassIndex).equals(clazz.getName())) { clazz.constantPoolEntryAccept(outerClassIndex, this); } }
public void visitClassConstant(Clazz clazz, ClassConstant classConstant) { Clazz referencedClass = classConstant.referencedClass; if (referencedClass != null) { // Put the actual class's name string in the class pool. name = referencedClass.getName(); clazz.constantPoolEntryAccept(classConstant.u2nameIndex, this); } }
/** * Returns the retargeted class member of the given class member. */ private Member updateReferencedMember(Member referencedMember, String name, String type, Clazz newReferencedClass) { if (referencedMember == null) { return null; } return referencedMember instanceof Field ? (Member)newReferencedClass.findField(name, type) : (Member)newReferencedClass.findMethod(name, type); }
public void visitFieldrefConstant(Clazz clazz, FieldrefConstant fieldrefConstant) { println(visitorInfo(fieldrefConstant) + " Fieldref [" + clazz.getClassName(fieldrefConstant.u2classIndex) + "." + clazz.getName(fieldrefConstant.u2nameAndTypeIndex) + " " + clazz.getType(fieldrefConstant.u2nameAndTypeIndex) + "]"); }
private boolean accepted(Clazz clazz, int memberAccessFlags) { int accessLevel = AccessUtil.accessLevel(memberAccessFlags); return (accessLevel >= AccessUtil.PUBLIC ) || (accessLevel >= AccessUtil.PRIVATE && referencingClass.equals(clazz) ) || (accessLevel >= AccessUtil.PACKAGE_VISIBLE && (ClassUtil.internalPackageName(referencingClass.getName()).equals( ClassUtil.internalPackageName(clazz.getName())))) || (accessLevel >= AccessUtil.PROTECTED && (referencingClass.extends_(clazz) || referencingClass.extendsOrImplements(clazz)) ); } }
public void visitAnyClass(Clazz clazz) { // Check the class itself. if ((clazz.getAccessFlags() & ClassConstants.ACC_PUBLIC) == 0) { setPackageVisibleMembers(clazz); } else { // Check the members. clazz.fieldsAccept(this); clazz.methodsAccept(this); } }
enumConstantName = enumConstantElementValue.getConstantName(clazz); referencedEnumField = null; referencedEnumClass.methodAccept(ClassConstants.METHOD_NAME_CLINIT, ClassConstants.METHOD_TYPE_CLINIT, enumFieldFinder); referencedEnumClass.findField(enumConstantName, enumTypeName);
/** * Returns whether the invoked method is a static interface method. */ public boolean invokesStaticInterfaceMethod() { // We assume unknown classes are not interfaces. return invokedReferenceKind == ClassConstants.REF_invokeStatic && referencedInvokedClass != null && (referencedInvokedClass.getAccessFlags() & ClassConstants.ACC_INTERFACE) != 0; }
public boolean extends_(Clazz clazz) { if (this.equals(clazz)) { return true; } return superClass != null && superClass.extends_(clazz); }
public void visitClassConstant(Clazz clazz, ClassConstant classConstant) { Clazz referencedClass = classConstant.referencedClass; if (referencedClass == null || !implementingClass.extendsOrImplements(referencedClass)) { constantVisitor.visitClassConstant(clazz, classConstant); } } }
/** * Initializes the referenced method of an element value, if any. */ private void initializeElementValue(Clazz clazz, Annotation annotation, ElementValue elementValue) { // See if we have a referenced class. if (annotation != null && annotation.referencedClasses != null && elementValue.u2elementNameIndex != 0) { // See if we can find the method in the referenced class // (ignoring the descriptor). String name = clazz.getString(elementValue.u2elementNameIndex); Clazz referencedClass = annotation.referencedClasses[0]; elementValue.referencedClass = referencedClass; elementValue.referencedMethod = referencedClass.findMethod(name, null); } }
public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction) { if (constantInstruction.opcode == InstructionConstants.OP_LDC || constantInstruction.opcode == InstructionConstants.OP_LDC_W) { clazz.constantPoolEntryAccept(constantInstruction.constantIndex, this); } }
public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute) { // Make sure the enclosing class has a name. enclosingMethodAttribute.referencedClassAccept(this); String innerClassName = clazz.getName(); String outerClassName = clazz.getClassName(enclosingMethodAttribute.u2classIndex); numericClassName = isNumericClassName(innerClassName, outerClassName); }
public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue) { println(visitorInfo(constantElementValue) + " Constant element value [" + (constantElementValue.u2elementNameIndex == 0 ? "(default)" : clazz.getString(constantElementValue.u2elementNameIndex)) + " '" + constantElementValue.u1tag + "']"); indent(); clazz.constantPoolEntryAccept(constantElementValue.u2constantValueIndex, this); outdent(); }
/** * Initializes the referenced method of an element value, if any. */ private void initializeElementValue(Clazz clazz, Annotation annotation, ElementValue elementValue) { // See if we have a referenced class. if (annotation != null && annotation.referencedClasses != null && elementValue.u2elementNameIndex != 0) { // See if we can find the method in the referenced class // (ignoring the descriptor). String name = elementValue.getMethodName(clazz); Clazz referencedClass = annotation.referencedClasses[0]; elementValue.referencedClass = referencedClass; elementValue.referencedMethod = referencedClass.findMethod(name, null); } }
/** * Returns the class name. */ public String getClassName(Clazz clazz) { return clazz.getClassName(u2classIndex); }
String descriptor = ClassUtil.internalType(fieldType); Field field = clazz.findField(name, descriptor); if (field != null)