private MethodHandles() { } // do not instantiate

private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory();

static { MethodHandleImpl.initStatics(); }

// See IMPL_LOOKUP below.

//// Method handle creation from ordinary methods.

/**

@CallerSensitive

public static Lookup lookup() {

return new Lookup(Reflection.getCallerClass());

}

/**

public static Lookup publicLookup() {

return Lookup.PUBLIC_LOOKUP;

}

/**

public static <T extends Member> T

reflectAs(Class<T> expected, MethodHandle target) {

SecurityManager smgr = System.getSecurityManager();

if (smgr != null) smgr.checkPermission(ACCESS_PERMISSION);

Lookup lookup = Lookup.IMPL_LOOKUP; // use maximally privileged lookup

return lookup.revealDirect(target).reflectAs(expected, lookup);

}

// Copied from AccessibleObject, as used by Method.setAccessible, etc.:

static final private java.security.Permission ACCESS_PERMISSION =

new ReflectPermission("suppressAccessChecks");

/**

public static final

class Lookup {

/** The class on behalf of whom the lookup is being performed. */

private final Class<?> lookupClass;

/** The allowed sorts of members which may be looked up (PUBLIC, etc.). */

private final int allowedModes;

/** A single-bit mask representing {@code public} access,

public static final int PUBLIC = Modifier.PUBLIC;

/** A single-bit mask representing {@code private} access,

public static final int PRIVATE = Modifier.PRIVATE;

/** A single-bit mask representing {@code protected} access,

public static final int PROTECTED = Modifier.PROTECTED;

/** A single-bit mask representing {@code package} access (default access),

public static final int PACKAGE = Modifier.STATIC;

private static final int ALL_MODES = (PUBLIC | PRIVATE | PROTECTED | PACKAGE);

private static final int TRUSTED = -1;

private static int fixmods(int mods) {

mods &= (ALL_MODES - PACKAGE);

return (mods != 0) ? mods : PACKAGE;

}

/** Tells which class is performing the lookup. It is this class against

public Class<?> lookupClass() {

return lookupClass;

}

// This is just for calling out to MethodHandleImpl.

private Class<?> lookupClassOrNull() {

return (allowedModes == TRUSTED) ? null : lookupClass;

}

/** Tells which access-protection classes of members this lookup object can produce.

public int lookupModes() {

return allowedModes & ALL_MODES;

}

/** Embody the current class (the lookupClass) as a lookup class

Lookup(Class<?> lookupClass) {

this(lookupClass, ALL_MODES);

// make sure we haven't accidentally picked up a privileged class:

checkUnprivilegedlookupClass(lookupClass, ALL_MODES);

}

private Lookup(Class<?> lookupClass, int allowedModes) {

this.lookupClass = lookupClass;

this.allowedModes = allowedModes;

}

/**

public Lookup in(Class<?> requestedLookupClass) {

requestedLookupClass.getClass(); // null check

if (allowedModes == TRUSTED) // IMPL_LOOKUP can make any lookup at all

return new Lookup(requestedLookupClass, ALL_MODES);

if (requestedLookupClass == this.lookupClass)

return this; // keep same capabilities

int newModes = (allowedModes & (ALL_MODES & ~PROTECTED));

if ((newModes & PACKAGE) != 0

&& !VerifyAccess.isSamePackage(this.lookupClass, requestedLookupClass)) {

newModes &= ~(PACKAGE|PRIVATE);

}

// Allow nestmate lookups to be created without special privilege:

if ((newModes & PRIVATE) != 0

&& !VerifyAccess.isSamePackageMember(this.lookupClass, requestedLookupClass)) {

newModes &= ~PRIVATE;

}

if ((newModes & PUBLIC) != 0

&& !VerifyAccess.isClassAccessible(requestedLookupClass, this.lookupClass, allowedModes)) {

// The requested class it not accessible from the lookup class.

// No permissions.

newModes = 0;

}

checkUnprivilegedlookupClass(requestedLookupClass, newModes);

return new Lookup(requestedLookupClass, newModes);

}

// Make sure outer class is initialized first.

static { IMPL_NAMES.getClass(); }

/** Version of lookup which is trusted minimally.

static final Lookup PUBLIC_LOOKUP = new Lookup(Object.class, PUBLIC);

/** Package-private version of lookup which is trusted. */

static final Lookup IMPL_LOOKUP = new Lookup(Object.class, TRUSTED);

private static void checkUnprivilegedlookupClass(Class<?> lookupClass, int allowedModes) {

String name = lookupClass.getName();

if (name.startsWith("java.lang.invoke."))

throw newIllegalArgumentException("illegal lookupClass: "+lookupClass);

// For caller-sensitive MethodHandles.lookup()

// disallow lookup more restricted packages

if (allowedModes == ALL_MODES && lookupClass.getClassLoader() == null) {

if (name.startsWith("java.") ||

(name.startsWith("sun.") && !name.startsWith("sun.invoke."))) {

throw newIllegalArgumentException("illegal lookupClass: " + lookupClass);

}

}

}

/**

@Override

public String toString() {

String cname = lookupClass.getName();

switch (allowedModes) {

case 0: // no privileges

return cname + "/noaccess";

case PUBLIC:

return cname + "/public";

case PUBLIC|PACKAGE:

return cname + "/package";

case ALL_MODES & ~PROTECTED:

return cname + "/private";

case ALL_MODES:

return cname;

case TRUSTED:

return "/trusted"; // internal only; not exported

default: // Should not happen, but it's a bitfield...

cname = cname + "/" + Integer.toHexString(allowedModes);

assert(false) : cname;

return cname;

}

}

/**

public

MethodHandle findStatic(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {

MemberName method = resolveOrFail(REF_invokeStatic, refc, name, type);

return getDirectMethod(REF_invokeStatic, refc, method, findBoundCallerClass(method));

}

/**

public MethodHandle findVirtual(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {

if (refc == MethodHandle.class) {

MethodHandle mh = findVirtualForMH(name, type);

if (mh != null) return mh;

}

byte refKind = (refc.isInterface() ? REF_invokeInterface : REF_invokeVirtual);

MemberName method = resolveOrFail(refKind, refc, name, type);

return getDirectMethod(refKind, refc, method, findBoundCallerClass(method));

}

private MethodHandle findVirtualForMH(String name, MethodType type) {

// these names require special lookups because of the implicit MethodType argument

if ("invoke".equals(name))

return invoker(type);

if ("invokeExact".equals(name))

return exactInvoker(type);

if ("invokeBasic".equals(name))

return basicInvoker(type);

assert(!MemberName.isMethodHandleInvokeName(name));

return null;

}

/**

public MethodHandle findConstructor(Class<?> refc, MethodType type) throws NoSuchMethodException, IllegalAccessException {

String name = "<init>";

MemberName ctor = resolveOrFail(REF_newInvokeSpecial, refc, name, type);

return getDirectConstructor(refc, ctor);

}

/**

public MethodHandle findSpecial(Class<?> refc, String name, MethodType type,

Class<?> specialCaller) throws NoSuchMethodException, IllegalAccessException {

checkSpecialCaller(specialCaller);

Lookup specialLookup = this.in(specialCaller);

MemberName method = specialLookup.resolveOrFail(REF_invokeSpecial, refc, name, type);