Java Opcodes.ACC_PRIVATE属性代码示例

@Override
public MethodVisitor visitMethod(final int access, final String name,
        final String desc, final String signature, final String[] exceptions) {
    MethodVisitor mv;
    if ("<clinit>".equals(name)) {
        int a = Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC;
        String n = prefix + counter++;
        mv = cv.visitMethod(a, n, desc, signature, exceptions);

        if (clinit == null) {
            clinit = cv.visitMethod(a, name, desc, null, null);
        }
        clinit.visitMethodInsn(Opcodes.INVOKESTATIC, this.name, n, desc,
                false);
    } else {
        mv = cv.visitMethod(access, name, desc, signature, exceptions);
    }
    return mv;
}
 

/**
 * Checks that the given access flags do not contain invalid flags. This
 * method also checks that mutually incompatible flags are not set
 * simultaneously.
 * 
 * @param access
 *            the access flags to be checked
 * @param possibleAccess
 *            the valid access flags.
 */
static void checkAccess(final int access, final int possibleAccess) {
    if ((access & ~possibleAccess) != 0) {
        throw new IllegalArgumentException("Invalid access flags: "
                + access);
    }
    int pub = (access & Opcodes.ACC_PUBLIC) == 0 ? 0 : 1;
    int pri = (access & Opcodes.ACC_PRIVATE) == 0 ? 0 : 1;
    int pro = (access & Opcodes.ACC_PROTECTED) == 0 ? 0 : 1;
    if (pub + pri + pro > 1) {
        throw new IllegalArgumentException(
                "public private and protected are mutually exclusive: "
                        + access);
    }
    int fin = (access & Opcodes.ACC_FINAL) == 0 ? 0 : 1;
    int abs = (access & Opcodes.ACC_ABSTRACT) == 0 ? 0 : 1;
    if (fin + abs > 1) {
        throw new IllegalArgumentException(
                "final and abstract are mutually exclusive: " + access);
    }
}
 

@Override
public void visit(final int version, final int access, final String name,
    final String signature, final String superName, final String[] interfaces) {
  /*
   * Record the original access bits so we can restore them before the next
   * link in the visitor chain.
   */
  originalClassAccess = access;
  accessCaptured = true;

  // If we're checking an inner class, suppress access bits that ASM chokes on.
  int checkClassAccess = access;
  if (name.indexOf('$') >= 0) {
    checkClassAccess &= ~(Opcodes.ACC_PROTECTED | Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC);
  }
  super.visit(version, checkClassAccess, name, signature, superName, interfaces);
}
 

@Override
public int get_access() throws CompileException {
  if ((method_node.access & Opcodes.ACC_PUBLIC) != 0) {
    return Opcodes.ACC_PUBLIC;
  } else if ((method_node.access & Opcodes.ACC_PRIVATE) != 0) {
    return Opcodes.ACC_PRIVATE;
  } else if ((method_node.access & Opcodes.ACC_PROTECTED) != 0) {
    return Opcodes.ACC_PROTECTED;
  }
  throw new CompileException("Invalid access priviledge");
}
 

@Override
public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
    if (((access & PUBLIC_STATIC_FINAL) == PUBLIC_STATIC_FINAL) && Type.getDescriptor(String.class).equals(desc)) {
        missingStaticStringConstantGetters.put("get" + name, (String) value);
    }
    if (((access & Opcodes.ACC_PRIVATE) > 0) && !isStatic(access) && (Type.getDescriptor(boolean.class).equals(desc))) {
        booleanFields.add(name);
    }
    return super.visitField(access, name, desc, signature, value);
}
 

@Override
public MethodVisitor visitMethod(final int access, final String name,
        final String desc, final String signature, final String[] exceptions) {
    if (computeSVUID) {
        if ("<clinit>".equals(name)) {
            hasStaticInitializer = true;
        }
        /*
         * Remembers non private constructors and methods for SVUID
         * computation For constructor and method modifiers, only the
         * ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
         * ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT and ACC_STRICT flags
         * are used.
         */
        int mods = access
                & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
                        | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
                        | Opcodes.ACC_FINAL | Opcodes.ACC_SYNCHRONIZED
                        | Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_STRICT);

        // all non private methods
        if ((access & Opcodes.ACC_PRIVATE) == 0) {
            if ("<init>".equals(name)) {
                svuidConstructors.add(new Item(name, mods, desc));
            } else if (!"<clinit>".equals(name)) {
                svuidMethods.add(new Item(name, mods, desc));
            }
        }
    }

    return super.visitMethod(access, name, desc, signature, exceptions);
}
 

@Override
public FieldVisitor visitField(final int access, final String name,
        final String desc, final String signature, final Object value) {
    if (computeSVUID) {
        if ("serialVersionUID".equals(name)) {
            // since the class already has SVUID, we won't be computing it.
            computeSVUID = false;
            hasSVUID = true;
        }
        /*
         * Remember field for SVUID computation For field modifiers, only
         * the ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC,
         * ACC_FINAL, ACC_VOLATILE, and ACC_TRANSIENT flags are used when
         * computing serialVersionUID values.
         */
        if ((access & Opcodes.ACC_PRIVATE) == 0
                || (access & (Opcodes.ACC_STATIC | Opcodes.ACC_TRANSIENT)) == 0) {
            int mods = access
                    & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
                            | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
                            | Opcodes.ACC_FINAL | Opcodes.ACC_VOLATILE | Opcodes.ACC_TRANSIENT);
            svuidFields.add(new Item(name, mods, desc));
        }
    }

    return super.visitField(access, name, desc, signature, value);
}
 

/** Writes the function to given ClassVisitor. */
void write (ClassVisitor writer, CompilerSettings settings, Globals globals) {
    int access = Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC;
    if (synthetic) {
        access |= Opcodes.ACC_SYNTHETIC;
    }
    final MethodWriter function = new MethodWriter(access, method.method, writer, globals.getStatements(), settings);
    function.visitCode();
    write(function, globals);
    function.endMethod();
}
 

public static int getOpcodeVisibility(String visibility) {
  if ("public".equals(visibility)) {
    return Opcodes.ACC_PUBLIC;
  }
  if ("protected".equals(visibility)) {
    return Opcodes.ACC_PROTECTED;
  }
  if ("private".equals(visibility)) {
    return Opcodes.ACC_PRIVATE;
  }
  return 0;
}
 

private static boolean isPrivate(int access) {
    return (access & Opcodes.ACC_PRIVATE) != 0;
}
 

static void appendAccess(final int access, final StringBuilder sb) {
    if ((access & Opcodes.ACC_PUBLIC) != 0) {
        sb.append("public ");
    }
    if ((access & Opcodes.ACC_PRIVATE) != 0) {
        sb.append("private ");
    }
    if ((access & Opcodes.ACC_PROTECTED) != 0) {
        sb.append("protected ");
    }
    if ((access & Opcodes.ACC_FINAL) != 0) {
        sb.append("final ");
    }
    if ((access & Opcodes.ACC_STATIC) != 0) {
        sb.append("static ");
    }
    if ((access & Opcodes.ACC_SUPER) != 0) {
        if ((access & ACCESS_CLASS) == 0) {
            sb.append("synchronized ");
        } else {
            sb.append("super ");
        }
    }
    if ((access & Opcodes.ACC_VOLATILE) != 0) {
        if ((access & ACCESS_FIELD) == 0) {
            sb.append("bridge ");
        } else {
            sb.append("volatile ");
        }
    }
    if ((access & Opcodes.ACC_TRANSIENT) != 0) {
        if ((access & ACCESS_FIELD) == 0) {
            sb.append("varargs ");
        } else {
            sb.append("transient ");
        }
    }
    if ((access & Opcodes.ACC_NATIVE) != 0) {
        sb.append("native ");
    }
    if ((access & Opcodes.ACC_STRICT) != 0) {
        sb.append("strict ");
    }
    if ((access & Opcodes.ACC_INTERFACE) != 0) {
        sb.append("interface ");
    }
    if ((access & Opcodes.ACC_ABSTRACT) != 0) {
        sb.append("abstract ");
    }
    if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
        sb.append("synthetic ");
    }
    if ((access & Opcodes.ACC_ANNOTATION) != 0) {
        sb.append("annotation ");
    }
    if ((access & Opcodes.ACC_ENUM) != 0) {
        sb.append("enum ");
    }
    if ((access & Opcodes.ACC_DEPRECATED) != 0) {
        sb.append("deprecated ");
    }
    if ((access & Opcodes.ACC_MANDATED) != 0) {
        sb.append("mandated ");
    }
}
 

private static int publicize(int access) {
	access &= ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED);
	access |= Opcodes.ACC_PUBLIC;
	return access;
}
 

private static boolean isHierarchyBarrier(int access) {
	return (access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC)) != 0;
}
 

/**
 * Appends a string representation of the given access modifiers to
 * {@link #buf buf}.
 *
 * @param access
 *            some access modifiers.
 */
private void appendAccess(final int access) {
    if ((access & Opcodes.ACC_PUBLIC) != 0) {
        buf.append("public ");
    }
    if ((access & Opcodes.ACC_PRIVATE) != 0) {
        buf.append("private ");
    }
    if ((access & Opcodes.ACC_PROTECTED) != 0) {
        buf.append("protected ");
    }
    if ((access & Opcodes.ACC_FINAL) != 0) {
        buf.append("final ");
    }
    if ((access & Opcodes.ACC_STATIC) != 0) {
        buf.append("static ");
    }
    if ((access & Opcodes.ACC_SYNCHRONIZED) != 0) {
        buf.append("synchronized ");
    }
    if ((access & Opcodes.ACC_VOLATILE) != 0) {
        buf.append("volatile ");
    }
    if ((access & Opcodes.ACC_TRANSIENT) != 0) {
        buf.append("transient ");
    }
    if ((access & Opcodes.ACC_ABSTRACT) != 0) {
        buf.append("abstract ");
    }
    if ((access & Opcodes.ACC_STRICT) != 0) {
        buf.append("strictfp ");
    }
    if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
        buf.append("synthetic ");
    }
    if ((access & Opcodes.ACC_MANDATED) != 0) {
        buf.append("mandated ");
    }
    if ((access & Opcodes.ACC_ENUM) != 0) {
        buf.append("enum ");
    }
}
 

public static boolean isCustomDeserializationMethod(int access, String name, String desc) {
  return access == Opcodes.ACC_PRIVATE && READ_OBJECT_NAME.equals(name) && desc.contains(READ_OBJECT_ARGUMENT);
}