public void visitInnerClass( final String name, final String outerName, final String innerName, final int access) { cv.visitInnerClass(name, outerName, innerName, access); }
/** * Makes the given class visitor visit this inner class. * * @param cv * a class visitor. */ public void accept(final ClassVisitor cv) { cv.visitInnerClass(name, outerName, innerName, access); } }
/** * 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 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() getInternalName}). * @param outerName * the internal name of the class to which the inner class * belongs (see {@link Type#getInternalName() getInternalName}). * May be <tt>null</tt> for not member classes. * @param innerName * the (simple) name of the inner class inside its enclosing * class. May be <tt>null</tt> for anonymous inner classes. * @param access * the access flags of the inner class as originally declared in * the enclosing class. */ public void visitInnerClass(String name, String outerName, String innerName, int access) { if (cv != null) { cv.visitInnerClass(name, outerName, innerName, access); } }
/** * Handle a bizarre special case. Nested classes (static classes declared * inside another class) that are protected have their access bit set to * public in their class files to deal with some odd reflection situation. * Our SVUID computation must do as the JVM does and ignore access bits in * the class file in favor of the access bits InnerClass attribute. */ @Override public void visitInnerClass(final String aname, final String outerName, final String innerName, final int attr_access) { if ((name != null) && name.equals(aname)) { this.access = attr_access; } super.visitInnerClass(aname, outerName, innerName, attr_access); }
@Override public void visitInnerClass(final String name, final String outerName, final String innerName, final int access) { p.visitInnerClass(name, outerName, innerName, access); super.visitInnerClass(name, outerName, innerName, access); }
@Override public final void begin(final String element, final Attributes attrs) { int access = getAccess(attrs.getValue("access")); String name = attrs.getValue("name"); String outerName = attrs.getValue("outerName"); String innerName = attrs.getValue("innerName"); cv.visitInnerClass(name, outerName, innerName, access); } }
@Override public void visitInnerClass(String name, String outerName, String innerName, int access) { // TODO should innerName be changed? super.visitInnerClass(remapper.mapType(name), outerName == null ? null : remapper.mapType(outerName), innerName, access); }
@Override public void visitInnerClass(String name, String outerName, String innerName, int access) { // TODO should innerName be changed? super.visitInnerClass(remapper.mapType(name), outerName == null ? null : remapper.mapType(outerName), innerName, access); }
public void visitInnerClass( final String name, final String outerName, final String innerName, final int access) { buf.setLength(0); buf.append(tab).append("// access flags "); buf.append(access & ~Opcodes.ACC_SUPER).append('\n'); buf.append(tab); appendAccess(access); buf.append("INNERCLASS "); appendDescriptor(INTERNAL_NAME, name); buf.append(' '); appendDescriptor(INTERNAL_NAME, outerName); buf.append(' '); appendDescriptor(INTERNAL_NAME, innerName); buf.append('\n'); text.add(buf.toString()); if (cv != null) { cv.visitInnerClass(name, outerName, innerName, access); } }
@Override public void visitInnerClass(final String name, final String outerName, final String innerName, final int access) { checkState(); CheckMethodAdapter.checkInternalName(name, "class name"); if (outerName != null) { CheckMethodAdapter.checkInternalName(outerName, "outer class name"); } if (innerName != null) { int start = 0; while (start < innerName.length() && Character.isDigit(innerName.charAt(start))) { start++; } if (start == 0 || start < innerName.length()) { CheckMethodAdapter.checkIdentifier(innerName, start, -1, "inner class name"); } } checkAccess(access, Opcodes.ACC_PUBLIC + Opcodes.ACC_PRIVATE + Opcodes.ACC_PROTECTED + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL + Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT + Opcodes.ACC_SYNTHETIC + Opcodes.ACC_ANNOTATION + Opcodes.ACC_ENUM); super.visitInnerClass(name, outerName, innerName, access); }
int currentClassesOffset = innerClassesOffset + 2; while (numberOfClasses-- > 0) { classVisitor.visitInnerClass( readClass(currentClassesOffset, charBuffer), readClass(currentClassesOffset + 2, charBuffer),
int v = innerClasses + 2; for (int i = readUnsignedShort(innerClasses); i > 0; --i) { classVisitor.visitInnerClass(readClass(v, c), readClass(v + 2, c), readUTF8(v + 4, c), readUnsignedShort(v + 6));
w += 2; for (; i > 0; --i) { classVisitor.visitInnerClass(readUnsignedShort(w) == 0 ? null : readClass(w, c), readUnsignedShort(w + 2) == 0