wd.dest.visit(v, access, wd.thisReference, signature, wd.superName, interfaces); final FieldVisitor fv = wd.dest.visitField(AsmUtil.ACC_PRIVATE | AsmUtil.ACC_FINAL, wd.wrapperRef, wd.wrapperType, null, null); fv.visitEnd(); final FieldVisitor fv = wd.dest.visitField(AsmUtil.ACC_PUBLIC, wd.wrapperRef, wd.wrapperType, null, null); fv.visitEnd();
/** * Visits an annotation of the class. * * @param descriptor the class descriptor of the annotation class. * @param visible {@literal true} if the annotation is visible at runtime. * @return a visitor to visit the annotation values, or {@literal null} if this visitor is not * interested in visiting this annotation. */ public AnnotationVisitor visitAnnotation(final String descriptor, final boolean visible) { if (cv != null) { return cv.visitAnnotation(descriptor, visible); } return null; }
/** * Visits a non standard attribute of the class. * * @param attribute an attribute. */ public void visitAttribute(final Attribute attribute) { if (cv != null) { cv.visitAttribute(attribute); } }
classVisitor.visit( readInt(cpInfoOffsets[1] - 7), accessFlags, thisClass, signature, superClass, interfaces); classVisitor.visitSource(sourceFile, sourceDebugExtension); classVisitor.visitNestHost(nestHostClass); String name = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex], charBuffer); String type = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex] + 2, charBuffer); classVisitor.visitOuterClass(className, name, type); classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true), currentAnnotationOffset, /* named = */ true, classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false), currentAnnotationOffset, /* named = */ true, classVisitor.visitTypeAnnotation( context.currentTypeAnnotationTarget, context.currentTypeAnnotationTargetPath, classVisitor.visitTypeAnnotation( context.currentTypeAnnotationTarget, context.currentTypeAnnotationTargetPath, classVisitor.visitAttribute(attributes); attributes = nextAttribute;
/** * Visits a method of the class. This method <i>must</i> return a new {@link MethodVisitor} * instance (or {@literal null}) each time it is called, i.e., it should not return a previously * returned visitor. * * @param access the method's access flags (see {@link Opcodes}). This parameter also indicates if * the method is synthetic and/or deprecated. * @param name the method's name. * @param descriptor the method's descriptor (see {@link Type}). * @param signature the method's signature. May be {@literal null} if the method parameters, * return type and exceptions do not use generic types. * @param exceptions the internal names of the method's exception classes (see {@link * Type#getInternalName()}). May be {@literal null}. * @return an object to visit the byte code of the method, or {@literal null} if this class * visitor is not interested in visiting the code of this method. */ public MethodVisitor visitMethod( final int access, final String name, final String descriptor, final String signature, final String[] exceptions) { if (cv != null) { return cv.visitMethod(access, name, descriptor, signature, exceptions); } return null; }
/** * Visits a field of the class. * * @param access the field's access flags (see {@link Opcodes}). This parameter also indicates if * the field is synthetic and/or deprecated. * @param name the field's name. * @param descriptor the field's descriptor (see {@link Type}). * @param signature the field's signature. May be {@literal null} if the field's type does not use * generic types. * @param value the field's initial value. This parameter, which may be {@literal null} if the * field does not have an initial value, must be an {@link Integer}, a {@link Float}, a {@link * Long}, a {@link Double} or a {@link String} (for {@code int}, {@code float}, {@code long} * or {@code String} fields respectively). <i>This parameter is only used for static * fields</i>. Its value is ignored for non static fields, which must be initialized through * bytecode instructions in constructors or methods. * @return a visitor to visit field annotations and attributes, or {@literal null} if this class * visitor is not interested in visiting these annotations and attributes. */ public FieldVisitor visitField( final int access, final String name, final String descriptor, final String signature, final Object value) { if (cv != null) { return cv.visitField(access, name, descriptor, signature, value); } return null; }
/** * Visits the end of the class. This method, which is the last one to be called, is used to inform * the visitor that all the fields and methods of the class have been visited. */ public void visitEnd() { if (cv != null) { cv.visitEnd(); } } }
/** * Visits the header of the class. * * @param version the class version. The minor version is stored in the 16 most significant bits, * and the major version in the 16 least significant bits. * @param access the class's access flags (see {@link Opcodes}). This parameter also indicates if * the class is deprecated. * @param name the internal name of the class (see {@link Type#getInternalName()}). * @param signature the signature of this class. May be {@literal null} if the class is not a * generic one, and does not extend or implement generic classes or interfaces. * @param superName the internal of name of the super class (see {@link Type#getInternalName()}). * For interfaces, the super class is {@link Object}. May be {@literal null}, but only for the * {@link Object} class. * @param interfaces the internal names of the class's interfaces (see {@link * Type#getInternalName()}). May be {@literal null}. */ public void visit( final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) { if (cv != null) { cv.visit(version, access, name, signature, superName, interfaces); } }
/** * Visit the module corresponding to the class. * * @param name the fully qualified name (using dots) of the module. * @param access the module access flags, among {@code ACC_OPEN}, {@code ACC_SYNTHETIC} and {@code * ACC_MANDATED}. * @param version the module version, or {@literal null}. * @return a visitor to visit the module values, or {@literal null} if this visitor is not * interested in visiting this module. */ public ModuleVisitor visitModule(final String name, final int access, final String version) { if (api < Opcodes.ASM6) { throw new UnsupportedOperationException("This feature requires ASM6"); } if (cv != null) { return cv.visitModule(name, access, version); } return null; }
/** * Visits a member of the nest. A nest is a set of classes of the same package that share access * to their private members. One of these classes, called the host, lists the other members of the * nest, which in turn should link to the host of their nest. This method must be called only if * the visited class is the host of a nest. A nest host is implicitly a member of its own nest, so * it's invalid to call this method with the visited class name as argument. * * @param nestMember the internal name of a nest member. */ public void visitNestMember(final String nestMember) { if (api < Opcodes.ASM7) { throw new UnsupportedOperationException("This feature requires ASM7"); } if (cv != null) { cv.visitNestMember(nestMember); } }
/** * Visits information about an inner class. This inner class is not necessarily a member of the * class being visited. * * @param name the internal name of an inner class (see {@link Type#getInternalName()}). * @param outerName the internal name of the class to which the inner class belongs (see {@link * Type#getInternalName()}). May be {@literal null} for not member classes. * @param innerName the (simple) name of the inner class inside its enclosing class. May be * {@literal null} for anonymous inner classes. * @param access the access flags of the inner class as originally declared in the enclosing * class. */ public void visitInnerClass( final String name, final String outerName, final String innerName, final int access) { if (cv != null) { cv.visitInnerClass(name, outerName, innerName, access); } }
/** * Visits the nest host class of the class. A nest is a set of classes of the same package that * share access to their private members. One of these classes, called the host, lists the other * members of the nest, which in turn should link to the host of their nest. This method must be * called only once and only if the visited class is a non-host member of a nest. A class is * implicitly its own nest, so it's invalid to call this method with the visited class name as * argument. * * @param nestHost the internal name of the host class of the nest. */ public void visitNestHost(final String nestHost) { if (api < Opcodes.ASM7) { throw new UnsupportedOperationException("This feature requires ASM7"); } if (cv != null) { cv.visitNestHost(nestHost); } }
classVisitor.visit( readInt(cpInfoOffsets[1] - 7), accessFlags, thisClass, signature, superClass, interfaces); classVisitor.visitSource(sourceFile, sourceDebugExtension); classVisitor.visitNestHost(nestHostClass); String name = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex], charBuffer); String type = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex] + 2, charBuffer); classVisitor.visitOuterClass(className, name, type); classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true), currentAnnotationOffset, /* named = */ true, classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false), currentAnnotationOffset, /* named = */ true, classVisitor.visitTypeAnnotation( context.currentTypeAnnotationTarget, context.currentTypeAnnotationTargetPath, classVisitor.visitTypeAnnotation( context.currentTypeAnnotationTarget, context.currentTypeAnnotationTargetPath, classVisitor.visitAttribute(attributes); attributes = nextAttribute;
/** * Creates proxified methods and constructors. * Destination proxy will have all constructors as a target class, using {@link jodd.proxetta.asm.ProxettaCtorBuilder}. * Static initializers are removed, since they will be execute in target anyway. * For each method, {@link ProxettaMethodBuilder} determines if method matches pointcut. If so, method will be proxified. */ @Override public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { final MethodSignatureVisitor msign = targetClassInfo.lookupMethodSignatureVisitor(access, name, desc, wd.superReference); if (msign == null) { return null; } if (msign.isFinal && !wd.allowFinalMethods) { return null; } // destination constructors [A1] if (name.equals(INIT)) { MethodVisitor mv = wd.dest.visitMethod(access, name, desc, msign.getAsmMethodSignature(), null); return new ProxettaCtorBuilder(mv, msign, wd); } // ignore destination static block if (name.equals(CLINIT)) { return null; } return applyProxy(msign); }
/** * Clones advices fields to destination. */ @Override public FieldVisitor visitField(final int access, final String name, final String desc, final String signature, final Object value) { wd.dest.visitField(access, adviceFieldName(name, aspectIndex), desc, signature, value); // [A5] return super.visitField(access, name, desc, signature, value); }
@Override public void visitEnd() { makeStaticInitBlock(); processSuperMethods(); wd.dest.visitEnd(); } }
/** * Creates destination subclass header from current target class. Destination name is created from targets by * adding a suffix and, optionally, a number. Destination extends the target. */ @Override public void visit(final int version, int access, final String name, final String signature, final String superName, final String[] interfaces) { wd.init(name, superName, this.suffix, this.reqProxyClassName); // change access of destination access &= ~AsmUtil.ACC_ABSTRACT; // write destination class final int v = ProxettaAsmUtil.resolveJavaVersion(version); wd.dest.visit(v, access, wd.thisReference, signature, wd.superName, null); wd.proxyAspects = new ProxyAspectData[aspects.length]; for (int i = 0; i < aspects.length; i++) { wd.proxyAspects[i] = new ProxyAspectData(wd, aspects[i], i); } }
String moduleVersion = readUTF8(currentOffset + 4, buffer); currentOffset += 6; ModuleVisitor moduleVisitor = classVisitor.visitModule(moduleName, moduleFlags, moduleVersion); if (moduleVisitor == null) { return;
/** * Visits a member of the nest. A nest is a set of classes of the same package that share access * to their private members. One of these classes, called the host, lists the other members of the * nest, which in turn should link to the host of their nest. This method must be called only if * the visited class is the host of a nest. A nest host is implicitly a member of its own nest, so * it's invalid to call this method with the visited class name as argument. * * @param nestMember the internal name of a nest member. */ public void visitNestMember(final String nestMember) { if (api < Opcodes.ASM7) { throw new UnsupportedOperationException("This feature requires ASM7"); } if (cv != null) { cv.visitNestMember(nestMember); } }
/** * Visits information about an inner class. This inner class is not necessarily a member of the * class being visited. * * @param name the internal name of an inner class (see {@link Type#getInternalName()}). * @param outerName the internal name of the class to which the inner class belongs (see {@link * Type#getInternalName()}). May be {@literal null} for not member classes. * @param innerName the (simple) name of the inner class inside its enclosing class. May be * {@literal null} for anonymous inner classes. * @param access the access flags of the inner class as originally declared in the enclosing * class. */ public void visitInnerClass( final String name, final String outerName, final String innerName, final int access) { if (cv != null) { cv.visitInnerClass(name, outerName, innerName, access); } }