6839872: remove implementation inheritance from JSR 292 APIs
Summary: move everything into a single package; remove all multi-package machinery
Reviewed-by: twisti, forax
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/AdapterMethodHandle.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,943 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.util.VerifyType;
+import sun.dyn.util.Wrapper;
+import java.util.Arrays;
+import static java.dyn.MethodHandleNatives.Constants.*;
+import static java.dyn.MethodHandleStatics.*;
+
+/**
+ * This method handle performs simple conversion or checking of a single argument.
+ * @author jrose
+ */
+class AdapterMethodHandle extends BoundMethodHandle {
+
+ //MethodHandle vmtarget; // next AMH or BMH in chain or final DMH
+ //Object argument; // parameter to the conversion if needed
+ //int vmargslot; // which argument slot is affected
+ private final int conversion; // the type of conversion: RETYPE_ONLY, etc.
+
+ // Constructors in this class *must* be package scoped or private.
+ private AdapterMethodHandle(MethodHandle target, MethodType newType,
+ long conv, Object convArg) {
+ super(newType, convArg, newType.parameterSlotDepth(1+convArgPos(conv)));
+ this.conversion = convCode(conv);
+ // JVM might update VM-specific bits of conversion (ignore)
+ MethodHandleNatives.init(this, target, convArgPos(conv));
+ }
+ private AdapterMethodHandle(MethodHandle target, MethodType newType,
+ long conv) {
+ this(target, newType, conv, null);
+ }
+
+ // TO DO: When adapting another MH with a null conversion, clone
+ // the target and change its type, instead of adding another layer.
+
+ /** Can a JVM-level adapter directly implement the proposed
+ * argument conversions, as if by MethodHandles.convertArguments?
+ */
+ static boolean canPairwiseConvert(MethodType newType, MethodType oldType) {
+ // same number of args, of course
+ int len = newType.parameterCount();
+ if (len != oldType.parameterCount())
+ return false;
+
+ // Check return type. (Not much can be done with it.)
+ Class<?> exp = newType.returnType();
+ Class<?> ret = oldType.returnType();
+ if (!VerifyType.isNullConversion(ret, exp))
+ return false;
+
+ // Check args pairwise.
+ for (int i = 0; i < len; i++) {
+ Class<?> src = newType.parameterType(i); // source type
+ Class<?> dst = oldType.parameterType(i); // destination type
+ if (!canConvertArgument(src, dst))
+ return false;
+ }
+
+ return true;
+ }
+
+ /** Can a JVM-level adapter directly implement the proposed
+ * argument conversion, as if by MethodHandles.convertArguments?
+ */
+ static boolean canConvertArgument(Class<?> src, Class<?> dst) {
+ // ? Retool this logic to use RETYPE_ONLY, CHECK_CAST, etc., as opcodes,
+ // so we don't need to repeat so much decision making.
+ if (VerifyType.isNullConversion(src, dst)) {
+ return true;
+ } else if (src.isPrimitive()) {
+ if (dst.isPrimitive())
+ return canPrimCast(src, dst);
+ else
+ return canBoxArgument(src, dst);
+ } else {
+ if (dst.isPrimitive())
+ return canUnboxArgument(src, dst);
+ else
+ return true; // any two refs can be interconverted
+ }
+ }
+
+ /**
+ * Create a JVM-level adapter method handle to conform the given method
+ * handle to the similar newType, using only pairwise argument conversions.
+ * For each argument, convert incoming argument to the exact type needed.
+ * Only null conversions are allowed on the return value (until
+ * the JVM supports ricochet adapters).
+ * The argument conversions allowed are casting, unboxing,
+ * integral widening or narrowing, and floating point widening or narrowing.
+ * @param newType required call type
+ * @param target original method handle
+ * @return an adapter to the original handle with the desired new type,
+ * or the original target if the types are already identical
+ * or null if the adaptation cannot be made
+ */
+ static MethodHandle makePairwiseConvert(MethodType newType, MethodHandle target) {
+ MethodType oldType = target.type();
+ if (newType == oldType) return target;
+
+ if (!canPairwiseConvert(newType, oldType))
+ return null;
+ // (after this point, it is an assertion error to fail to convert)
+
+ // Find last non-trivial conversion (if any).
+ int lastConv = newType.parameterCount()-1;
+ while (lastConv >= 0) {
+ Class<?> src = newType.parameterType(lastConv); // source type
+ Class<?> dst = oldType.parameterType(lastConv); // destination type
+ if (VerifyType.isNullConversion(src, dst)) {
+ --lastConv;
+ } else {
+ break;
+ }
+ }
+ // Now build a chain of one or more adapters.
+ MethodHandle adapter = target;
+ MethodType midType = oldType.changeReturnType(newType.returnType());
+ for (int i = 0; i <= lastConv; i++) {
+ Class<?> src = newType.parameterType(i); // source type
+ Class<?> dst = midType.parameterType(i); // destination type
+ if (VerifyType.isNullConversion(src, dst)) {
+ // do nothing: difference is trivial
+ continue;
+ }
+ // Work the current type backward toward the desired caller type:
+ if (i != lastConv) {
+ midType = midType.changeParameterType(i, src);
+ } else {
+ // When doing the last (or only) real conversion,
+ // force all remaining null conversions to happen also.
+ assert(VerifyType.isNullConversion(newType, midType.changeParameterType(i, src)));
+ midType = newType;
+ }
+
+ // Tricky case analysis follows.
+ // It parallels canConvertArgument() above.
+ if (src.isPrimitive()) {
+ if (dst.isPrimitive()) {
+ adapter = makePrimCast(midType, adapter, i, dst);
+ } else {
+ adapter = makeBoxArgument(midType, adapter, i, dst);
+ }
+ } else {
+ if (dst.isPrimitive()) {
+ // Caller has boxed a primitive. Unbox it for the target.
+ // The box type must correspond exactly to the primitive type.
+ // This is simpler than the powerful set of widening
+ // conversions supported by reflect.Method.invoke.
+ // Those conversions require a big nest of if/then/else logic,
+ // which we prefer to make a user responsibility.
+ adapter = makeUnboxArgument(midType, adapter, i, dst);
+ } else {
+ // Simple reference conversion.
+ // Note: Do not check for a class hierarchy relation
+ // between src and dst. In all cases a 'null' argument
+ // will pass the cast conversion.
+ adapter = makeCheckCast(midType, adapter, i, dst);
+ }
+ }
+ assert(adapter != null);
+ assert(adapter.type() == midType);
+ }
+ if (adapter.type() != newType) {
+ // Only trivial conversions remain.
+ adapter = makeRetypeOnly(newType, adapter);
+ assert(adapter != null);
+ // Actually, that's because there were no non-trivial ones:
+ assert(lastConv == -1);
+ }
+ assert(adapter.type() == newType);
+ return adapter;
+ }
+
+ /**
+ * Create a JVM-level adapter method handle to permute the arguments
+ * of the given method.
+ * @param newType required call type
+ * @param target original method handle
+ * @param argumentMap for each target argument, position of its source in newType
+ * @return an adapter to the original handle with the desired new type,
+ * or the original target if the types are already identical
+ * and the permutation is null
+ * @throws IllegalArgumentException if the adaptation cannot be made
+ * directly by a JVM-level adapter, without help from Java code
+ */
+ static MethodHandle makePermutation(MethodType newType, MethodHandle target,
+ int[] argumentMap) {
+ MethodType oldType = target.type();
+ boolean nullPermutation = true;
+ for (int i = 0; i < argumentMap.length; i++) {
+ int pos = argumentMap[i];
+ if (pos != i)
+ nullPermutation = false;
+ if (pos < 0 || pos >= newType.parameterCount()) {
+ argumentMap = new int[0]; break;
+ }
+ }
+ if (argumentMap.length != oldType.parameterCount())
+ throw newIllegalArgumentException("bad permutation: "+Arrays.toString(argumentMap));
+ if (nullPermutation) {
+ MethodHandle res = makePairwiseConvert(newType, target);
+ // well, that was easy
+ if (res == null)
+ throw newIllegalArgumentException("cannot convert pairwise: "+newType);
+ return res;
+ }
+
+ // Check return type. (Not much can be done with it.)
+ Class<?> exp = newType.returnType();
+ Class<?> ret = oldType.returnType();
+ if (!VerifyType.isNullConversion(ret, exp))
+ throw newIllegalArgumentException("bad return conversion for "+newType);
+
+ // See if the argument types match up.
+ for (int i = 0; i < argumentMap.length; i++) {
+ int j = argumentMap[i];
+ Class<?> src = newType.parameterType(j);
+ Class<?> dst = oldType.parameterType(i);
+ if (!VerifyType.isNullConversion(src, dst))
+ throw newIllegalArgumentException("bad argument #"+j+" conversion for "+newType);
+ }
+
+ // Now figure out a nice mix of SWAP, ROT, DUP, and DROP adapters.
+ // A workable greedy algorithm is as follows:
+ // Drop unused outgoing arguments (right to left: shallowest first).
+ // Duplicate doubly-used outgoing arguments (left to right: deepest first).
+ // Then the remaining problem is a true argument permutation.
+ // Marshal the outgoing arguments as required from left to right.
+ // That is, find the deepest outgoing stack position that does not yet
+ // have the correct argument value, and correct at least that position
+ // by swapping or rotating in the misplaced value (from a shallower place).
+ // If the misplaced value is followed by one or more consecutive values
+ // (also misplaced) issue a rotation which brings as many as possible
+ // into position. Otherwise make progress with either a swap or a
+ // rotation. Prefer the swap as cheaper, but do not use it if it
+ // breaks a slot pair. Prefer the rotation over the swap if it would
+ // preserve more consecutive values shallower than the target position.
+ // When more than one rotation will work (because the required value
+ // is already adjacent to the target position), then use a rotation
+ // which moves the old value in the target position adjacent to
+ // one of its consecutive values. Also, prefer shorter rotation
+ // spans, since they use fewer memory cycles for shuffling.
+
+ throw new UnsupportedOperationException("NYI");
+ }
+
+ private static byte basicType(Class<?> type) {
+ if (type == null) return T_VOID;
+ switch (Wrapper.forBasicType(type)) {
+ case BOOLEAN: return T_BOOLEAN;
+ case CHAR: return T_CHAR;
+ case FLOAT: return T_FLOAT;
+ case DOUBLE: return T_DOUBLE;
+ case BYTE: return T_BYTE;
+ case SHORT: return T_SHORT;
+ case INT: return T_INT;
+ case LONG: return T_LONG;
+ case OBJECT: return T_OBJECT;
+ case VOID: return T_VOID;
+ }
+ return 99; // T_ILLEGAL or some such
+ }
+
+ /** Number of stack slots for the given type.
+ * Two for T_DOUBLE and T_FLOAT, one for the rest.
+ */
+ private static int type2size(int type) {
+ assert(type >= T_BOOLEAN && type <= T_OBJECT);
+ return (type == T_LONG || type == T_DOUBLE) ? 2 : 1;
+ }
+ private static int type2size(Class<?> type) {
+ return type2size(basicType(type));
+ }
+
+ /** The given stackMove is the number of slots pushed.
+ * It might be negative. Scale it (multiply) by the
+ * VM's notion of how an address changes with a push,
+ * to get the raw SP change for stackMove.
+ * Then shift and mask it into the correct field.
+ */
+ private static long insertStackMove(int stackMove) {
+ // following variable must be long to avoid sign extension after '<<'
+ long spChange = stackMove * MethodHandleNatives.JVM_STACK_MOVE_UNIT;
+ return (spChange & CONV_STACK_MOVE_MASK) << CONV_STACK_MOVE_SHIFT;
+ }
+
+ /** Construct an adapter conversion descriptor for a single-argument conversion. */
+ private static long makeConv(int convOp, int argnum, int src, int dest) {
+ assert(src == (src & 0xF));
+ assert(dest == (dest & 0xF));
+ assert(convOp >= OP_CHECK_CAST && convOp <= OP_PRIM_TO_REF);
+ int stackMove = type2size(dest) - type2size(src);
+ return ((long) argnum << 32 |
+ (long) convOp << CONV_OP_SHIFT |
+ (int) src << CONV_SRC_TYPE_SHIFT |
+ (int) dest << CONV_DEST_TYPE_SHIFT |
+ insertStackMove(stackMove)
+ );
+ }
+ private static long makeConv(int convOp, int argnum, int stackMove) {
+ assert(convOp >= OP_DUP_ARGS && convOp <= OP_SPREAD_ARGS);
+ byte src = 0, dest = 0;
+ if (convOp >= OP_COLLECT_ARGS && convOp <= OP_SPREAD_ARGS)
+ src = dest = T_OBJECT;
+ return ((long) argnum << 32 |
+ (long) convOp << CONV_OP_SHIFT |
+ (int) src << CONV_SRC_TYPE_SHIFT |
+ (int) dest << CONV_DEST_TYPE_SHIFT |
+ insertStackMove(stackMove)
+ );
+ }
+ private static long makeSwapConv(int convOp, int srcArg, byte type, int destSlot) {
+ assert(convOp >= OP_SWAP_ARGS && convOp <= OP_ROT_ARGS);
+ return ((long) srcArg << 32 |
+ (long) convOp << CONV_OP_SHIFT |
+ (int) type << CONV_SRC_TYPE_SHIFT |
+ (int) type << CONV_DEST_TYPE_SHIFT |
+ (int) destSlot << CONV_VMINFO_SHIFT
+ );
+ }
+ private static long makeConv(int convOp) {
+ assert(convOp == OP_RETYPE_ONLY || convOp == OP_RETYPE_RAW);
+ return ((long)-1 << 32) | (convOp << CONV_OP_SHIFT); // stackMove, src, dst all zero
+ }
+ private static int convCode(long conv) {
+ return (int)conv;
+ }
+ private static int convArgPos(long conv) {
+ return (int)(conv >>> 32);
+ }
+ private static boolean convOpSupported(int convOp) {
+ assert(convOp >= 0 && convOp <= CONV_OP_LIMIT);
+ return ((1<<convOp) & MethodHandleNatives.CONV_OP_IMPLEMENTED_MASK) != 0;
+ }
+
+ /** One of OP_RETYPE_ONLY, etc. */
+ int conversionOp() { return (conversion & CONV_OP_MASK) >> CONV_OP_SHIFT; }
+
+ /* Return one plus the position of the first non-trivial difference
+ * between the given types. This is not a symmetric operation;
+ * we are considering adapting the targetType to adapterType.
+ * Trivial differences are those which could be ignored by the JVM
+ * without subverting the verifier. Otherwise, adaptable differences
+ * are ones for which we could create an adapter to make the type change.
+ * Return zero if there are no differences (other than trivial ones).
+ * Return 1+N if N is the only adaptable argument difference.
+ * Return the -2-N where N is the first of several adaptable
+ * argument differences.
+ * Return -1 if there there are differences which are not adaptable.
+ */
+ private static int diffTypes(MethodType adapterType,
+ MethodType targetType,
+ boolean raw) {
+ int diff;
+ diff = diffReturnTypes(adapterType, targetType, raw);
+ if (diff != 0) return diff;
+ int nargs = adapterType.parameterCount();
+ if (nargs != targetType.parameterCount())
+ return -1;
+ diff = diffParamTypes(adapterType, 0, targetType, 0, nargs, raw);
+ //System.out.println("diff "+adapterType);
+ //System.out.println(" "+diff+" "+targetType);
+ return diff;
+ }
+ private static int diffReturnTypes(MethodType adapterType,
+ MethodType targetType,
+ boolean raw) {
+ Class<?> src = targetType.returnType();
+ Class<?> dst = adapterType.returnType();
+ if ((!raw
+ ? VerifyType.canPassUnchecked(src, dst)
+ : VerifyType.canPassRaw(src, dst)
+ ) > 0)
+ return 0; // no significant difference
+ if (raw && !src.isPrimitive() && !dst.isPrimitive())
+ return 0; // can force a reference return (very carefully!)
+ //if (false) return 1; // never adaptable!
+ return -1; // some significant difference
+ }
+ private static int diffParamTypes(MethodType adapterType, int astart,
+ MethodType targetType, int tstart,
+ int nargs, boolean raw) {
+ assert(nargs >= 0);
+ int res = 0;
+ for (int i = 0; i < nargs; i++) {
+ Class<?> src = adapterType.parameterType(astart+i);
+ Class<?> dest = targetType.parameterType(tstart+i);
+ if ((!raw
+ ? VerifyType.canPassUnchecked(src, dest)
+ : VerifyType.canPassRaw(src, dest)
+ ) <= 0) {
+ // found a difference; is it the only one so far?
+ if (res != 0)
+ return -1-res; // return -2-i for prev. i
+ res = 1+i;
+ }
+ }
+ return res;
+ }
+
+ /** Can a retyping adapter (alone) validly convert the target to newType? */
+ static boolean canRetypeOnly(MethodType newType, MethodType targetType) {
+ return canRetype(newType, targetType, false);
+ }
+ /** Can a retyping adapter (alone) convert the target to newType?
+ * It is allowed to widen subword types and void to int, to make bitwise
+ * conversions between float/int and double/long, and to perform unchecked
+ * reference conversions on return. This last feature requires that the
+ * caller be trusted, and perform explicit cast conversions on return values.
+ */
+ static boolean canRetypeRaw(MethodType newType, MethodType targetType) {
+ return canRetype(newType, targetType, true);
+ }
+ static boolean canRetype(MethodType newType, MethodType targetType, boolean raw) {
+ if (!convOpSupported(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY)) return false;
+ int diff = diffTypes(newType, targetType, raw);
+ // %%% This assert is too strong. Factor diff into VerifyType and reconcile.
+ assert(raw || (diff == 0) == VerifyType.isNullConversion(newType, targetType));
+ return diff == 0;
+ }
+
+ /** Factory method: Performs no conversions; simply retypes the adapter.
+ * Allows unchecked argument conversions pairwise, if they are safe.
+ * Returns null if not possible.
+ */
+ static MethodHandle makeRetypeOnly(MethodType newType, MethodHandle target) {
+ return makeRetype(newType, target, false);
+ }
+ static MethodHandle makeRetypeRaw(MethodType newType, MethodHandle target) {
+ return makeRetype(newType, target, true);
+ }
+ static MethodHandle makeRetype(MethodType newType, MethodHandle target, boolean raw) {
+ MethodType oldType = target.type();
+ if (oldType == newType) return target;
+ if (!canRetype(newType, oldType, raw))
+ return null;
+ // TO DO: clone the target guy, whatever he is, with new type.
+ return new AdapterMethodHandle(target, newType, makeConv(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY));
+ }
+
+ static MethodHandle makeVarargsCollector(MethodHandle target, Class<?> arrayType) {
+ return new AsVarargsCollector(target, arrayType);
+ }
+
+ static class AsVarargsCollector extends AdapterMethodHandle {
+ final MethodHandle target;
+ final Class<?> arrayType;
+ MethodHandle cache;
+
+ AsVarargsCollector(MethodHandle target, Class<?> arrayType) {
+ super(target, target.type(), makeConv(OP_RETYPE_ONLY));
+ this.target = target;
+ this.arrayType = arrayType;
+ this.cache = target.asCollector(arrayType, 0);
+ }
+
+ @Override
+ public boolean isVarargsCollector() {
+ return true;
+ }
+
+ @Override
+ public MethodHandle asType(MethodType newType) {
+ MethodType type = this.type();
+ int collectArg = type.parameterCount() - 1;
+ int newArity = newType.parameterCount();
+ if (newArity == collectArg+1 &&
+ type.parameterType(collectArg).isAssignableFrom(newType.parameterType(collectArg))) {
+ // if arity and trailing parameter are compatible, do normal thing
+ return super.asType(newType);
+ }
+ // check cache
+ if (cache.type().parameterCount() == newArity)
+ return cache.asType(newType);
+ // build and cache a collector
+ int arrayLength = newArity - collectArg;
+ MethodHandle collector;
+ try {
+ collector = target.asCollector(arrayType, arrayLength);
+ } catch (IllegalArgumentException ex) {
+ throw new WrongMethodTypeException("cannot build collector");
+ }
+ cache = collector;
+ return collector.asType(newType);
+ }
+
+ @Override
+ public MethodHandle asVarargsCollector(Class<?> arrayType) {
+ MethodType type = this.type();
+ if (type.parameterType(type.parameterCount()-1) == arrayType)
+ return this;
+ return super.asVarargsCollector(arrayType);
+ }
+ }
+
+ /** Can a checkcast adapter validly convert the target to newType?
+ * The JVM supports all kind of reference casts, even silly ones.
+ */
+ static boolean canCheckCast(MethodType newType, MethodType targetType,
+ int arg, Class<?> castType) {
+ if (!convOpSupported(OP_CHECK_CAST)) return false;
+ Class<?> src = newType.parameterType(arg);
+ Class<?> dst = targetType.parameterType(arg);
+ if (!canCheckCast(src, castType)
+ || !VerifyType.isNullConversion(castType, dst))
+ return false;
+ int diff = diffTypes(newType, targetType, false);
+ return (diff == arg+1); // arg is sole non-trivial diff
+ }
+ /** Can an primitive conversion adapter validly convert src to dst? */
+ static boolean canCheckCast(Class<?> src, Class<?> dst) {
+ return (!src.isPrimitive() && !dst.isPrimitive());
+ }
+
+ /** Factory method: Forces a cast at the given argument.
+ * The castType is the target of the cast, and can be any type
+ * with a null conversion to the corresponding target parameter.
+ * Return null if this cannot be done.
+ */
+ static MethodHandle makeCheckCast(MethodType newType, MethodHandle target,
+ int arg, Class<?> castType) {
+ if (!canCheckCast(newType, target.type(), arg, castType))
+ return null;
+ long conv = makeConv(OP_CHECK_CAST, arg, T_OBJECT, T_OBJECT);
+ return new AdapterMethodHandle(target, newType, conv, castType);
+ }
+
+ /** Can an primitive conversion adapter validly convert the target to newType?
+ * The JVM currently supports all conversions except those between
+ * floating and integral types.
+ */
+ static boolean canPrimCast(MethodType newType, MethodType targetType,
+ int arg, Class<?> convType) {
+ if (!convOpSupported(OP_PRIM_TO_PRIM)) return false;
+ Class<?> src = newType.parameterType(arg);
+ Class<?> dst = targetType.parameterType(arg);
+ if (!canPrimCast(src, convType)
+ || !VerifyType.isNullConversion(convType, dst))
+ return false;
+ int diff = diffTypes(newType, targetType, false);
+ return (diff == arg+1); // arg is sole non-trivial diff
+ }
+ /** Can an primitive conversion adapter validly convert src to dst? */
+ static boolean canPrimCast(Class<?> src, Class<?> dst) {
+ if (src == dst || !src.isPrimitive() || !dst.isPrimitive()) {
+ return false;
+ } else if (Wrapper.forPrimitiveType(dst).isFloating()) {
+ // both must be floating types
+ return Wrapper.forPrimitiveType(src).isFloating();
+ } else {
+ // both are integral, and all combinations work fine
+ assert(Wrapper.forPrimitiveType(src).isIntegral() &&
+ Wrapper.forPrimitiveType(dst).isIntegral());
+ return true;
+ }
+ }
+
+ /** Factory method: Truncate the given argument with zero or sign extension,
+ * and/or convert between single and doubleword versions of integer or float.
+ * The convType is the target of the conversion, and can be any type
+ * with a null conversion to the corresponding target parameter.
+ * Return null if this cannot be done.
+ */
+ static MethodHandle makePrimCast(MethodType newType, MethodHandle target,
+ int arg, Class<?> convType) {
+ MethodType oldType = target.type();
+ if (!canPrimCast(newType, oldType, arg, convType))
+ return null;
+ Class<?> src = newType.parameterType(arg);
+ long conv = makeConv(OP_PRIM_TO_PRIM, arg, basicType(src), basicType(convType));
+ return new AdapterMethodHandle(target, newType, conv);
+ }
+
+ /** Can an unboxing conversion validly convert src to dst?
+ * The JVM currently supports all kinds of casting and unboxing.
+ * The convType is the unboxed type; it can be either a primitive or wrapper.
+ */
+ static boolean canUnboxArgument(MethodType newType, MethodType targetType,
+ int arg, Class<?> convType) {
+ if (!convOpSupported(OP_REF_TO_PRIM)) return false;
+ Class<?> src = newType.parameterType(arg);
+ Class<?> dst = targetType.parameterType(arg);
+ Class<?> boxType = Wrapper.asWrapperType(convType);
+ convType = Wrapper.asPrimitiveType(convType);
+ if (!canCheckCast(src, boxType)
+ || boxType == convType
+ || !VerifyType.isNullConversion(convType, dst))
+ return false;
+ int diff = diffTypes(newType, targetType, false);
+ return (diff == arg+1); // arg is sole non-trivial diff
+ }
+ /** Can an primitive unboxing adapter validly convert src to dst? */
+ static boolean canUnboxArgument(Class<?> src, Class<?> dst) {
+ return (!src.isPrimitive() && Wrapper.asPrimitiveType(dst).isPrimitive());
+ }
+
+ /** Factory method: Unbox the given argument.
+ * Return null if this cannot be done.
+ */
+ static MethodHandle makeUnboxArgument(MethodType newType, MethodHandle target,
+ int arg, Class<?> convType) {
+ MethodType oldType = target.type();
+ Class<?> src = newType.parameterType(arg);
+ Class<?> dst = oldType.parameterType(arg);
+ Class<?> boxType = Wrapper.asWrapperType(convType);
+ Class<?> primType = Wrapper.asPrimitiveType(convType);
+ if (!canUnboxArgument(newType, oldType, arg, convType))
+ return null;
+ MethodType castDone = newType;
+ if (!VerifyType.isNullConversion(src, boxType))
+ castDone = newType.changeParameterType(arg, boxType);
+ long conv = makeConv(OP_REF_TO_PRIM, arg, T_OBJECT, basicType(primType));
+ MethodHandle adapter = new AdapterMethodHandle(target, castDone, conv, boxType);
+ if (castDone == newType)
+ return adapter;
+ return makeCheckCast(newType, adapter, arg, boxType);
+ }
+
+ /** Can an primitive boxing adapter validly convert src to dst? */
+ static boolean canBoxArgument(Class<?> src, Class<?> dst) {
+ if (!convOpSupported(OP_PRIM_TO_REF)) return false;
+ throw new UnsupportedOperationException("NYI");
+ }
+
+ /** Factory method: Unbox the given argument.
+ * Return null if this cannot be done.
+ */
+ static MethodHandle makeBoxArgument(MethodType newType, MethodHandle target,
+ int arg, Class<?> convType) {
+ // this is difficult to do in the JVM because it must GC
+ return null;
+ }
+
+ /** Can an adapter simply drop arguments to convert the target to newType? */
+ static boolean canDropArguments(MethodType newType, MethodType targetType,
+ int dropArgPos, int dropArgCount) {
+ if (dropArgCount == 0)
+ return canRetypeOnly(newType, targetType);
+ if (!convOpSupported(OP_DROP_ARGS)) return false;
+ if (diffReturnTypes(newType, targetType, false) != 0)
+ return false;
+ int nptypes = newType.parameterCount();
+ // parameter types must be the same up to the drop point
+ if (dropArgPos != 0 && diffParamTypes(newType, 0, targetType, 0, dropArgPos, false) != 0)
+ return false;
+ int afterPos = dropArgPos + dropArgCount;
+ int afterCount = nptypes - afterPos;
+ if (dropArgPos < 0 || dropArgPos >= nptypes ||
+ dropArgCount < 1 || afterPos > nptypes ||
+ targetType.parameterCount() != nptypes - dropArgCount)
+ return false;
+ // parameter types after the drop point must also be the same
+ if (afterCount != 0 && diffParamTypes(newType, afterPos, targetType, dropArgPos, afterCount, false) != 0)
+ return false;
+ return true;
+ }
+
+ /** Factory method: Drop selected arguments.
+ * Allow unchecked retyping of remaining arguments, pairwise.
+ * Return null if this is not possible.
+ */
+ static MethodHandle makeDropArguments(MethodType newType, MethodHandle target,
+ int dropArgPos, int dropArgCount) {
+ if (dropArgCount == 0)
+ return makeRetypeOnly(newType, target);
+ if (!canDropArguments(newType, target.type(), dropArgPos, dropArgCount))
+ return null;
+ // in arglist: [0: ...keep1 | dpos: drop... | dpos+dcount: keep2... ]
+ // out arglist: [0: ...keep1 | dpos: keep2... ]
+ int keep2InPos = dropArgPos + dropArgCount;
+ int dropSlot = newType.parameterSlotDepth(keep2InPos);
+ int keep1InSlot = newType.parameterSlotDepth(dropArgPos);
+ int slotCount = keep1InSlot - dropSlot;
+ assert(slotCount >= dropArgCount);
+ assert(target.type().parameterSlotCount() + slotCount == newType.parameterSlotCount());
+ long conv = makeConv(OP_DROP_ARGS, dropArgPos + dropArgCount - 1, -slotCount);
+ return new AdapterMethodHandle(target, newType, conv);
+ }
+
+ /** Can an adapter duplicate an argument to convert the target to newType? */
+ static boolean canDupArguments(MethodType newType, MethodType targetType,
+ int dupArgPos, int dupArgCount) {
+ if (!convOpSupported(OP_DUP_ARGS)) return false;
+ if (diffReturnTypes(newType, targetType, false) != 0)
+ return false;
+ int nptypes = newType.parameterCount();
+ if (dupArgCount < 0 || dupArgPos + dupArgCount > nptypes)
+ return false;
+ if (targetType.parameterCount() != nptypes + dupArgCount)
+ return false;
+ // parameter types must be the same up to the duplicated arguments
+ if (diffParamTypes(newType, 0, targetType, 0, nptypes, false) != 0)
+ return false;
+ // duplicated types must be, well, duplicates
+ if (diffParamTypes(newType, dupArgPos, targetType, nptypes, dupArgCount, false) != 0)
+ return false;
+ return true;
+ }
+
+ /** Factory method: Duplicate the selected argument.
+ * Return null if this is not possible.
+ */
+ static MethodHandle makeDupArguments(MethodType newType, MethodHandle target,
+ int dupArgPos, int dupArgCount) {
+ if (!canDupArguments(newType, target.type(), dupArgPos, dupArgCount))
+ return null;
+ if (dupArgCount == 0)
+ return target;
+ // in arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... ]
+ // out arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... | dup... ]
+ int keep2InPos = dupArgPos + dupArgCount;
+ int dupSlot = newType.parameterSlotDepth(keep2InPos);
+ int keep1InSlot = newType.parameterSlotDepth(dupArgPos);
+ int slotCount = keep1InSlot - dupSlot;
+ assert(target.type().parameterSlotCount() - slotCount == newType.parameterSlotCount());
+ long conv = makeConv(OP_DUP_ARGS, dupArgPos + dupArgCount - 1, slotCount);
+ return new AdapterMethodHandle(target, newType, conv);
+ }
+
+ /** Can an adapter swap two arguments to convert the target to newType? */
+ static boolean canSwapArguments(MethodType newType, MethodType targetType,
+ int swapArg1, int swapArg2) {
+ if (!convOpSupported(OP_SWAP_ARGS)) return false;
+ if (diffReturnTypes(newType, targetType, false) != 0)
+ return false;
+ if (swapArg1 >= swapArg2) return false; // caller resp
+ int nptypes = newType.parameterCount();
+ if (targetType.parameterCount() != nptypes)
+ return false;
+ if (swapArg1 < 0 || swapArg2 >= nptypes)
+ return false;
+ if (diffParamTypes(newType, 0, targetType, 0, swapArg1, false) != 0)
+ return false;
+ if (diffParamTypes(newType, swapArg1, targetType, swapArg2, 1, false) != 0)
+ return false;
+ if (diffParamTypes(newType, swapArg1+1, targetType, swapArg1+1, swapArg2-swapArg1-1, false) != 0)
+ return false;
+ if (diffParamTypes(newType, swapArg2, targetType, swapArg1, 1, false) != 0)
+ return false;
+ if (diffParamTypes(newType, swapArg2+1, targetType, swapArg2+1, nptypes-swapArg2-1, false) != 0)
+ return false;
+ return true;
+ }
+
+ /** Factory method: Swap the selected arguments.
+ * Return null if this is not possible.
+ */
+ static MethodHandle makeSwapArguments(MethodType newType, MethodHandle target,
+ int swapArg1, int swapArg2) {
+ if (swapArg1 == swapArg2)
+ return target;
+ if (swapArg1 > swapArg2) { int t = swapArg1; swapArg1 = swapArg2; swapArg2 = t; }
+ if (!canSwapArguments(newType, target.type(), swapArg1, swapArg2))
+ return null;
+ Class<?> swapType = newType.parameterType(swapArg1);
+ // in arglist: [0: ...keep1 | pos1: a1 | pos1+1: keep2... | pos2: a2 | pos2+1: keep3... ]
+ // out arglist: [0: ...keep1 | pos1: a2 | pos1+1: keep2... | pos2: a1 | pos2+1: keep3... ]
+ int swapSlot2 = newType.parameterSlotDepth(swapArg2 + 1);
+ long conv = makeSwapConv(OP_SWAP_ARGS, swapArg1, basicType(swapType), swapSlot2);
+ return new AdapterMethodHandle(target, newType, conv);
+ }
+
+ static int positiveRotation(int argCount, int rotateBy) {
+ assert(argCount > 0);
+ if (rotateBy >= 0) {
+ if (rotateBy < argCount)
+ return rotateBy;
+ return rotateBy % argCount;
+ } else if (rotateBy >= -argCount) {
+ return rotateBy + argCount;
+ } else {
+ return (-1-((-1-rotateBy) % argCount)) + argCount;
+ }
+ }
+
+ final static int MAX_ARG_ROTATION = 1;
+
+ /** Can an adapter rotate arguments to convert the target to newType? */
+ static boolean canRotateArguments(MethodType newType, MethodType targetType,
+ int firstArg, int argCount, int rotateBy) {
+ if (!convOpSupported(OP_ROT_ARGS)) return false;
+ if (argCount <= 2) return false; // must be a swap, not a rotate
+ rotateBy = positiveRotation(argCount, rotateBy);
+ if (rotateBy == 0) return false; // no rotation
+ if (rotateBy > MAX_ARG_ROTATION && rotateBy < argCount - MAX_ARG_ROTATION)
+ return false; // too many argument positions
+ // Rotate incoming args right N to the out args, N in 1..(argCouunt-1).
+ if (diffReturnTypes(newType, targetType, false) != 0)
+ return false;
+ int nptypes = newType.parameterCount();
+ if (targetType.parameterCount() != nptypes)
+ return false;
+ if (firstArg < 0 || firstArg >= nptypes) return false;
+ int argLimit = firstArg + argCount;
+ if (argLimit > nptypes) return false;
+ if (diffParamTypes(newType, 0, targetType, 0, firstArg, false) != 0)
+ return false;
+ int newChunk1 = argCount - rotateBy, newChunk2 = rotateBy;
+ // swap new chunk1 with target chunk2
+ if (diffParamTypes(newType, firstArg, targetType, argLimit-newChunk1, newChunk1, false) != 0)
+ return false;
+ // swap new chunk2 with target chunk1
+ if (diffParamTypes(newType, firstArg+newChunk1, targetType, firstArg, newChunk2, false) != 0)
+ return false;
+ return true;
+ }
+
+ /** Factory method: Rotate the selected argument range.
+ * Return null if this is not possible.
+ */
+ static MethodHandle makeRotateArguments(MethodType newType, MethodHandle target,
+ int firstArg, int argCount, int rotateBy) {
+ rotateBy = positiveRotation(argCount, rotateBy);
+ if (!canRotateArguments(newType, target.type(), firstArg, argCount, rotateBy))
+ return null;
+ // Decide whether it should be done as a right or left rotation,
+ // on the JVM stack. Return the number of stack slots to rotate by,
+ // positive if right, negative if left.
+ int limit = firstArg + argCount;
+ int depth0 = newType.parameterSlotDepth(firstArg);
+ int depth1 = newType.parameterSlotDepth(limit-rotateBy);
+ int depth2 = newType.parameterSlotDepth(limit);
+ int chunk1Slots = depth0 - depth1; assert(chunk1Slots > 0);
+ int chunk2Slots = depth1 - depth2; assert(chunk2Slots > 0);
+ // From here on out, it assumes a single-argument shift.
+ assert(MAX_ARG_ROTATION == 1);
+ int srcArg, dstArg;
+ byte basicType;
+ if (chunk2Slots <= chunk1Slots) {
+ // Rotate right/down N (rotateBy = +N, N small, c2 small):
+ // in arglist: [0: ...keep1 | arg1: c1... | limit-N: c2 | limit: keep2... ]
+ // out arglist: [0: ...keep1 | arg1: c2 | arg1+N: c1... | limit: keep2... ]
+ srcArg = limit-1;
+ dstArg = firstArg;
+ basicType = basicType(newType.parameterType(srcArg));
+ assert(chunk2Slots == type2size(basicType));
+ } else {
+ // Rotate left/up N (rotateBy = -N, N small, c1 small):
+ // in arglist: [0: ...keep1 | arg1: c1 | arg1+N: c2... | limit: keep2... ]
+ // out arglist: [0: ...keep1 | arg1: c2 ... | limit-N: c1 | limit: keep2... ]
+ srcArg = firstArg;
+ dstArg = limit-1;
+ basicType = basicType(newType.parameterType(srcArg));
+ assert(chunk1Slots == type2size(basicType));
+ }
+ int dstSlot = newType.parameterSlotDepth(dstArg + 1);
+ long conv = makeSwapConv(OP_ROT_ARGS, srcArg, basicType, dstSlot);
+ return new AdapterMethodHandle(target, newType, conv);
+ }
+
+ /** Can an adapter spread an argument to convert the target to newType? */
+ static boolean canSpreadArguments(MethodType newType, MethodType targetType,
+ Class<?> spreadArgType, int spreadArgPos, int spreadArgCount) {
+ if (!convOpSupported(OP_SPREAD_ARGS)) return false;
+ if (diffReturnTypes(newType, targetType, false) != 0)
+ return false;
+ int nptypes = newType.parameterCount();
+ // parameter types must be the same up to the spread point
+ if (spreadArgPos != 0 && diffParamTypes(newType, 0, targetType, 0, spreadArgPos, false) != 0)
+ return false;
+ int afterPos = spreadArgPos + spreadArgCount;
+ int afterCount = nptypes - (spreadArgPos + 1);
+ if (spreadArgPos < 0 || spreadArgPos >= nptypes ||
+ spreadArgCount < 0 ||
+ targetType.parameterCount() != afterPos + afterCount)
+ return false;
+ // parameter types after the spread point must also be the same
+ if (afterCount != 0 && diffParamTypes(newType, spreadArgPos+1, targetType, afterPos, afterCount, false) != 0)
+ return false;
+ // match the array element type to the spread arg types
+ Class<?> rawSpreadArgType = newType.parameterType(spreadArgPos);
+ if (rawSpreadArgType != spreadArgType && !canCheckCast(rawSpreadArgType, spreadArgType))
+ return false;
+ for (int i = 0; i < spreadArgCount; i++) {
+ Class<?> src = VerifyType.spreadArgElementType(spreadArgType, i);
+ Class<?> dst = targetType.parameterType(spreadArgPos + i);
+ if (src == null || !VerifyType.isNullConversion(src, dst))
+ return false;
+ }
+ return true;
+ }
+
+
+ /** Factory method: Spread selected argument. */
+ static MethodHandle makeSpreadArguments(MethodType newType, MethodHandle target,
+ Class<?> spreadArgType, int spreadArgPos, int spreadArgCount) {
+ MethodType targetType = target.type();
+ if (!canSpreadArguments(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount))
+ return null;
+ // in arglist: [0: ...keep1 | spos: spreadArg | spos+1: keep2... ]
+ // out arglist: [0: ...keep1 | spos: spread... | spos+scount: keep2... ]
+ int keep2OutPos = spreadArgPos + spreadArgCount;
+ int spreadSlot = targetType.parameterSlotDepth(keep2OutPos);
+ int keep1OutSlot = targetType.parameterSlotDepth(spreadArgPos);
+ int slotCount = keep1OutSlot - spreadSlot;
+ assert(spreadSlot == newType.parameterSlotDepth(spreadArgPos+1));
+ assert(slotCount >= spreadArgCount);
+ long conv = makeConv(OP_SPREAD_ARGS, spreadArgPos, slotCount-1);
+ MethodHandle res = new AdapterMethodHandle(target, newType, conv, spreadArgType);
+ assert(res.type().parameterType(spreadArgPos) == spreadArgType);
+ return res;
+ }
+
+ // TO DO: makeCollectArguments, makeFlyby, makeRicochet
+
+ @Override
+ public String toString() {
+ return getNameString(nonAdapter((MethodHandle)vmtarget), this);
+ }
+
+ private static MethodHandle nonAdapter(MethodHandle mh) {
+ while (mh instanceof AdapterMethodHandle) {
+ mh = (MethodHandle) mh.vmtarget;
+ }
+ return mh;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/BoundMethodHandle.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.util.VerifyType;
+import sun.dyn.util.Wrapper;
+import static java.dyn.MethodHandleStatics.*;
+
+/**
+ * The flavor of method handle which emulates an invoke instruction
+ * on a predetermined argument. The JVM dispatches to the correct method
+ * when the handle is created, not when it is invoked.
+ * @author jrose
+ */
+class BoundMethodHandle extends MethodHandle {
+ //MethodHandle vmtarget; // next BMH or final DMH or methodOop
+ private final Object argument; // argument to insert
+ private final int vmargslot; // position at which it is inserted
+
+ // Constructors in this class *must* be package scoped or private.
+
+ /** Bind a direct MH to its receiver (or first ref. argument).
+ * The JVM will pre-dispatch the MH if it is not already static.
+ */
+ /*non-public*/ BoundMethodHandle(DirectMethodHandle mh, Object argument) {
+ super(mh.type().dropParameterTypes(0, 1));
+ // check the type now, once for all:
+ this.argument = checkReferenceArgument(argument, mh, 0);
+ this.vmargslot = this.type().parameterSlotCount();
+ initTarget(mh, 0);
+ }
+
+ /** Insert an argument into an arbitrary method handle.
+ * If argnum is zero, inserts the first argument, etc.
+ * The argument type must be a reference.
+ */
+ /*non-public*/ BoundMethodHandle(MethodHandle mh, Object argument, int argnum) {
+ this(mh.type().dropParameterTypes(argnum, argnum+1),
+ mh, argument, argnum);
+ }
+
+ /** Insert an argument into an arbitrary method handle.
+ * If argnum is zero, inserts the first argument, etc.
+ */
+ /*non-public*/ BoundMethodHandle(MethodType type, MethodHandle mh, Object argument, int argnum) {
+ super(type);
+ if (mh.type().parameterType(argnum).isPrimitive())
+ this.argument = bindPrimitiveArgument(argument, mh, argnum);
+ else {
+ this.argument = checkReferenceArgument(argument, mh, argnum);
+ }
+ this.vmargslot = type.parameterSlotDepth(argnum);
+ initTarget(mh, argnum);
+ }
+
+ private void initTarget(MethodHandle mh, int argnum) {
+ //this.vmtarget = mh; // maybe updated by JVM
+ MethodHandleNatives.init(this, mh, argnum);
+ }
+
+ /** For the AdapterMethodHandle subclass.
+ */
+ /*non-public*/ BoundMethodHandle(MethodType type, Object argument, int vmargslot) {
+ super(type);
+ this.argument = argument;
+ this.vmargslot = vmargslot;
+ assert(this instanceof AdapterMethodHandle);
+ }
+
+ /** Initialize the current object as a self-bound method handle, binding it
+ * as the first argument of the method handle {@code entryPoint}.
+ * The invocation type of the resulting method handle will be the
+ * same as {@code entryPoint}, except that the first argument
+ * type will be dropped.
+ */
+ /*non-public*/ BoundMethodHandle(MethodHandle entryPoint) {
+ super(entryPoint.type().dropParameterTypes(0, 1));
+ this.argument = this; // kludge; get rid of
+ this.vmargslot = this.type().parameterSlotDepth(0);
+ initTarget(entryPoint, 0);
+ }
+
+ /** Make sure the given {@code argument} can be used as {@code argnum}-th
+ * parameter of the given method handle {@code mh}, which must be a reference.
+ * <p>
+ * If this fails, throw a suitable {@code WrongMethodTypeException},
+ * which will prevent the creation of an illegally typed bound
+ * method handle.
+ */
+ final static Object checkReferenceArgument(Object argument, MethodHandle mh, int argnum) {
+ Class<?> ptype = mh.type().parameterType(argnum);
+ if (ptype.isPrimitive()) {
+ // fail
+ } else if (argument == null) {
+ return null;
+ } else if (VerifyType.isNullReferenceConversion(argument.getClass(), ptype)) {
+ return argument;
+ }
+ throw badBoundArgumentException(argument, mh, argnum);
+ }
+
+ /** Make sure the given {@code argument} can be used as {@code argnum}-th
+ * parameter of the given method handle {@code mh}, which must be a primitive.
+ * <p>
+ * If this fails, throw a suitable {@code WrongMethodTypeException},
+ * which will prevent the creation of an illegally typed bound
+ * method handle.
+ */
+ final static Object bindPrimitiveArgument(Object argument, MethodHandle mh, int argnum) {
+ Class<?> ptype = mh.type().parameterType(argnum);
+ Wrapper wrap = Wrapper.forPrimitiveType(ptype);
+ Object zero = wrap.zero();
+ if (zero == null) {
+ // fail
+ } else if (argument == null) {
+ if (ptype != int.class && wrap.isSubwordOrInt())
+ return Integer.valueOf(0);
+ else
+ return zero;
+ } else if (VerifyType.isNullReferenceConversion(argument.getClass(), zero.getClass())) {
+ if (ptype != int.class && wrap.isSubwordOrInt())
+ return Wrapper.INT.wrap(argument);
+ else
+ return argument;
+ }
+ throw badBoundArgumentException(argument, mh, argnum);
+ }
+
+ final static RuntimeException badBoundArgumentException(Object argument, MethodHandle mh, int argnum) {
+ String atype = (argument == null) ? "null" : argument.getClass().toString();
+ return new WrongMethodTypeException("cannot bind "+atype+" argument to parameter #"+argnum+" of "+mh.type());
+ }
+
+ @Override
+ public String toString() {
+ return addTypeString(baseName(), this);
+ }
+
+ /** Component of toString() before the type string. */
+ protected String baseName() {
+ MethodHandle mh = this;
+ while (mh instanceof BoundMethodHandle) {
+ Object info = MethodHandleNatives.getTargetInfo(mh);
+ if (info instanceof MethodHandle) {
+ mh = (MethodHandle) info;
+ } else {
+ String name = null;
+ if (info instanceof MemberName)
+ name = ((MemberName)info).getName();
+ if (name != null)
+ return name;
+ else
+ return noParens(super.toString()); // "invoke", probably
+ }
+ assert(mh != this);
+ }
+ return noParens(mh.toString());
+ }
+
+ private static String noParens(String str) {
+ int paren = str.indexOf('(');
+ if (paren >= 0) str = str.substring(0, paren);
+ return str;
+ }
+}
--- a/jdk/src/share/classes/java/dyn/CallSite.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/CallSite.java Fri Mar 18 00:03:24 2011 -0700
@@ -25,10 +25,10 @@
package java.dyn;
-import sun.dyn.*;
import sun.dyn.empty.Empty;
import sun.misc.Unsafe;
-import java.util.Collection;
+import static java.dyn.MethodHandleStatics.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
/**
* A {@code CallSite} is a holder for a variable {@link MethodHandle},
@@ -85,7 +85,6 @@
*/
abstract
public class CallSite {
- private static final Access IMPL_TOKEN = Access.getToken();
static { MethodHandleImpl.initStatics(); }
// Fields used only by the JVM. Do not use or change.
@@ -111,7 +110,7 @@
*/
/*package-private*/
CallSite(MethodType type) {
- target = MethodHandles.invokers(type).uninitializedCallSite();
+ target = type.invokers().uninitializedCallSite();
}
/**
@@ -218,7 +217,7 @@
public abstract MethodHandle dynamicInvoker();
/*non-public*/ MethodHandle makeDynamicInvoker() {
- MethodHandle getTarget = MethodHandleImpl.bindReceiver(IMPL_TOKEN, GET_TARGET, this);
+ MethodHandle getTarget = MethodHandleImpl.bindReceiver(GET_TARGET, this);
MethodHandle invoker = MethodHandles.exactInvoker(this.type());
return MethodHandles.foldArguments(invoker, getTarget);
}
@@ -226,7 +225,7 @@
private static final MethodHandle GET_TARGET;
static {
try {
- GET_TARGET = MethodHandles.Lookup.IMPL_LOOKUP.
+ GET_TARGET = IMPL_LOOKUP.
findVirtual(CallSite.class, "getTarget", MethodType.methodType(MethodHandle.class));
} catch (ReflectiveOperationException ignore) {
throw new InternalError();
@@ -252,7 +251,6 @@
/*package-private*/
void setTargetNormal(MethodHandle newTarget) {
target = newTarget;
- //CallSiteImpl.setCallSiteTarget(IMPL_TOKEN, this, newTarget);
}
/*package-private*/
MethodHandle getTargetVolatile() {
@@ -261,6 +259,105 @@
/*package-private*/
void setTargetVolatile(MethodHandle newTarget) {
unsafe.putObjectVolatile(this, TARGET_OFFSET, newTarget);
- //CallSiteImpl.setCallSiteTarget(IMPL_TOKEN, this, newTarget);
+ }
+
+ // this implements the upcall from the JVM, MethodHandleNatives.makeDynamicCallSite:
+ static CallSite makeSite(MethodHandle bootstrapMethod,
+ // Callee information:
+ String name, MethodType type,
+ // Extra arguments for BSM, if any:
+ Object info,
+ // Caller information:
+ MemberName callerMethod, int callerBCI) {
+ Class<?> callerClass = callerMethod.getDeclaringClass();
+ Object caller;
+ if (bootstrapMethod.type().parameterType(0) == Class.class && TRANSITIONAL_BEFORE_PFD)
+ caller = callerClass; // remove for PFD
+ else
+ caller = IMPL_LOOKUP.in(callerClass);
+ if (bootstrapMethod == null && TRANSITIONAL_BEFORE_PFD) {
+ // If there is no bootstrap method, throw IncompatibleClassChangeError.
+ // This is a valid generic error type for resolution (JLS 12.3.3).
+ throw new IncompatibleClassChangeError
+ ("Class "+callerClass.getName()+" has not declared a bootstrap method for invokedynamic");
+ }
+ CallSite site;
+ try {
+ Object binding;
+ info = maybeReBox(info);
+ if (info == null) {
+ binding = bootstrapMethod.invokeGeneric(caller, name, type);
+ } else if (!info.getClass().isArray()) {
+ binding = bootstrapMethod.invokeGeneric(caller, name, type, info);
+ } else {
+ Object[] argv = (Object[]) info;
+ maybeReBoxElements(argv);
+ if (3 + argv.length > 255)
+ throw new InvokeDynamicBootstrapError("too many bootstrap method arguments");
+ MethodType bsmType = bootstrapMethod.type();
+ if (bsmType.parameterCount() == 4 && bsmType.parameterType(3) == Object[].class)
+ binding = bootstrapMethod.invokeGeneric(caller, name, type, argv);
+ else
+ binding = MethodHandles.spreadInvoker(bsmType, 3)
+ .invokeGeneric(bootstrapMethod, caller, name, type, argv);
+ }
+ //System.out.println("BSM for "+name+type+" => "+binding);
+ if (binding instanceof CallSite) {
+ site = (CallSite) binding;
+ } else if (binding instanceof MethodHandle && TRANSITIONAL_BEFORE_PFD) {
+ // Transitional!
+ MethodHandle target = (MethodHandle) binding;
+ site = new ConstantCallSite(target);
+ } else {
+ throw new ClassCastException("bootstrap method failed to produce a CallSite");
+ }
+ if (TRANSITIONAL_BEFORE_PFD)
+ PRIVATE_INITIALIZE_CALL_SITE.invokeExact(site, name, type,
+ callerMethod, callerBCI);
+ assert(site.getTarget() != null);
+ assert(site.getTarget().type().equals(type));
+ } catch (Throwable ex) {
+ InvokeDynamicBootstrapError bex;
+ if (ex instanceof InvokeDynamicBootstrapError)
+ bex = (InvokeDynamicBootstrapError) ex;
+ else
+ bex = new InvokeDynamicBootstrapError("call site initialization exception", ex);
+ throw bex;
+ }
+ return site;
+ }
+
+ private static final boolean TRANSITIONAL_BEFORE_PFD = true; // FIXME: remove for PFD
+ // booby trap to force removal after package rename:
+ static { if (TRANSITIONAL_BEFORE_PFD) assert(CallSite.class.getName().startsWith("java.dyn.")); }
+
+ private static Object maybeReBox(Object x) {
+ if (x instanceof Integer) {
+ int xi = (int) x;
+ if (xi == (byte) xi)
+ x = xi; // must rebox; see JLS 5.1.7
+ }
+ return x;
+ }
+ private static void maybeReBoxElements(Object[] xa) {
+ for (int i = 0; i < xa.length; i++) {
+ xa[i] = maybeReBox(xa[i]);
+ }
+ }
+
+ // This method is private in CallSite because it touches private fields in CallSite.
+ // These private fields (vmmethod, vmindex) are specific to the JVM.
+ private static final MethodHandle PRIVATE_INITIALIZE_CALL_SITE;
+ static {
+ try {
+ PRIVATE_INITIALIZE_CALL_SITE =
+ !TRANSITIONAL_BEFORE_PFD ? null :
+ IMPL_LOOKUP.findVirtual(CallSite.class, "initializeFromJVM",
+ MethodType.methodType(void.class,
+ String.class, MethodType.class,
+ MemberName.class, int.class));
+ } catch (ReflectiveOperationException ex) {
+ throw uncaughtException(ex);
+ }
}
}
--- a/jdk/src/share/classes/java/dyn/ClassValue.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/ClassValue.java Fri Mar 18 00:03:24 2011 -0700
@@ -27,8 +27,6 @@
import java.util.WeakHashMap;
import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-import java.lang.reflect.UndeclaredThrowableException;
/**
* Lazily associate a computed value with (potentially) every type.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/DirectMethodHandle.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import static java.dyn.MethodHandleNatives.Constants.*;
+
+/**
+ * The flavor of method handle which emulates invokespecial or invokestatic.
+ * @author jrose
+ */
+class DirectMethodHandle extends MethodHandle {
+ //inherited oop vmtarget; // methodOop or virtual class/interface oop
+ private final int vmindex; // method index within class or interface
+ { vmindex = VM_INDEX_UNINITIALIZED; } // JVM may change this
+
+ // Constructors in this class *must* be package scoped or private.
+ DirectMethodHandle(MethodType mtype, MemberName m, boolean doDispatch, Class<?> lookupClass) {
+ super(mtype);
+
+ assert(m.isMethod() || !doDispatch && m.isConstructor());
+ if (!m.isResolved())
+ throw new InternalError();
+
+ MethodHandleNatives.init(this, (Object) m, doDispatch, lookupClass);
+ }
+
+ boolean isValid() {
+ return (vmindex != VM_INDEX_UNINITIALIZED);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/FilterGeneric.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,4496 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import java.lang.reflect.*;
+import static java.dyn.MethodHandleStatics.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * These adapters apply arbitrary conversions to arguments
+ * on the way to a ultimate target.
+ * For simplicity, these are all generically typed.
+ * @author jrose
+ */
+class FilterGeneric {
+ // type for the incoming call (will be generic)
+ private final MethodType entryType;
+ // prototype adapters (clone and customize for each new target & conversion!)
+ private final Adapter[] adapters;
+
+ /** Compute and cache information common to all filtering adapters
+ * with the given generic type
+ */
+ FilterGeneric(MethodType entryType) {
+ this.entryType = entryType;
+ int tableSize = Kind.LIMIT.invokerIndex(1 + entryType.parameterCount());
+ this.adapters = new Adapter[tableSize];
+ }
+
+ Adapter getAdapter(Kind kind, int pos) {
+ int index = kind.invokerIndex(pos);
+ Adapter ad = adapters[index];
+ if (ad != null) return ad;
+ ad = findAdapter(entryType, kind, pos);
+ if (ad == null)
+ ad = buildAdapterFromBytecodes(entryType, kind, pos);
+ adapters[index] = ad;
+ return ad;
+ }
+
+ Adapter makeInstance(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
+ Adapter ad = getAdapter(kind, pos);
+ return ad.makeInstance(ad.prototypeEntryPoint(), filter, target);
+ }
+
+ /** Build an adapter of the given generic type, which invokes filter
+ * on the selected incoming argument before passing it to the target.
+ * @param pos the argument to filter
+ * @param filter the function to call on the argument
+ * @param target the target to call with the modified argument list
+ * @return an adapter method handle
+ */
+ public static MethodHandle makeArgumentFilter(int pos, MethodHandle filter, MethodHandle target) {
+ return make(Kind.value, pos, filter, target);
+ }
+
+ /** Build an adapter of the given generic type, which invokes a combiner
+ * on a selected group of leading arguments.
+ * The result of the combiner is prepended before all those arguments.
+ * @param combiner the function to call on the selected leading arguments
+ * @param target the target to call with the modified argument list
+ * @return an adapter method handle
+ */
+ public static MethodHandle makeArgumentFolder(MethodHandle combiner, MethodHandle target) {
+ int num = combiner.type().parameterCount();
+ return make(Kind.fold, num, combiner, target);
+ }
+
+ /** Build an adapter of the given generic type, which invokes a filter
+ * on the incoming arguments, reified as a group.
+ * The argument may be modified (by side effects in the filter).
+ * The arguments, possibly modified, are passed on to the target.
+ * @param filter the function to call on the arguments
+ * @param target the target to call with the possibly-modified argument list
+ * @return an adapter method handle
+ */
+ public static MethodHandle makeFlyby(MethodHandle filter, MethodHandle target) {
+ return make(Kind.flyby, 0, filter, target);
+ }
+
+ /** Build an adapter of the given generic type, which invokes a collector
+ * on the selected incoming argument and all following arguments.
+ * The result of the collector replaces all those arguments.
+ * @param collector the function to call on the selected trailing arguments
+ * @param target the target to call with the modified argument list
+ * @return an adapter method handle
+ */
+ public static MethodHandle makeArgumentCollector(MethodHandle collector, MethodHandle target) {
+ int pos = target.type().parameterCount() - 1;
+ return make(Kind.collect, pos, collector, target);
+ }
+
+ static MethodHandle make(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
+ FilterGeneric fgen = of(kind, pos, filter.type(), target.type());
+ return fgen.makeInstance(kind, pos, filter, target);
+ }
+
+ /** Return the adapter information for this target and filter type. */
+ static FilterGeneric of(Kind kind, int pos, MethodType filterType, MethodType targetType) {
+ MethodType entryType = entryType(kind, pos, filterType, targetType);
+ if (entryType.generic() != entryType)
+ throw newIllegalArgumentException("must be generic: "+entryType);
+ MethodTypeForm form = entryType.form();
+ FilterGeneric filterGen = form.filterGeneric;
+ if (filterGen == null)
+ form.filterGeneric = filterGen = new FilterGeneric(entryType);
+ return filterGen;
+ }
+
+ public String toString() {
+ return "FilterGeneric/"+entryType;
+ }
+
+ static MethodType targetType(MethodType entryType, Kind kind, int pos, MethodType filterType) {
+ MethodType type = entryType;
+ switch (kind) {
+ case value:
+ case flyby:
+ break; // no change
+ case fold:
+ type = type.insertParameterTypes(0, filterType.returnType());
+ break;
+ case collect:
+ type = type.dropParameterTypes(pos, type.parameterCount());
+ type = type.insertParameterTypes(pos, filterType.returnType());
+ break;
+ default:
+ throw new InternalError();
+ }
+ return type;
+ }
+
+ static MethodType entryType(Kind kind, int pos, MethodType filterType, MethodType targetType) {
+ MethodType type = targetType;
+ switch (kind) {
+ case value:
+ case flyby:
+ break; // no change
+ case fold:
+ type = type.dropParameterTypes(0, 1);
+ break;
+ case collect:
+ type = type.dropParameterTypes(pos, pos+1);
+ type = type.insertParameterTypes(pos, filterType.parameterList());
+ break;
+ default:
+ throw new InternalError();
+ }
+ return type;
+ }
+
+ /* Create an adapter that handles spreading calls for the given type. */
+ static Adapter findAdapter(MethodType entryType, Kind kind, int pos) {
+ int argc = entryType.parameterCount();
+ String cname0 = "F"+argc;
+ String cname1 = "F"+argc+kind.key;
+ String[] cnames = { cname0, cname1 };
+ String iname = kind.invokerName(pos);
+ // e.g., F5; invoke_C3
+ for (String cname : cnames) {
+ Class<? extends Adapter> acls = Adapter.findSubClass(cname);
+ if (acls == null) continue;
+ // see if it has the required invoke method
+ MethodHandle entryPoint = null;
+ try {
+ entryPoint = IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
+ } catch (ReflectiveOperationException ex) {
+ }
+ if (entryPoint == null) continue;
+ Constructor<? extends Adapter> ctor = null;
+ try {
+ ctor = acls.getDeclaredConstructor(MethodHandle.class);
+ } catch (NoSuchMethodException ex) {
+ } catch (SecurityException ex) {
+ }
+ if (ctor == null) continue;
+ try {
+ // Produce an instance configured as a prototype.
+ return ctor.newInstance(entryPoint);
+ } catch (IllegalArgumentException ex) {
+ } catch (InvocationTargetException wex) {
+ Throwable ex = wex.getTargetException();
+ if (ex instanceof Error) throw (Error)ex;
+ if (ex instanceof RuntimeException) throw (RuntimeException)ex;
+ } catch (InstantiationException ex) {
+ } catch (IllegalAccessException ex) {
+ }
+ }
+ return null;
+ }
+
+ static Adapter buildAdapterFromBytecodes(MethodType entryType, Kind kind, int pos) {
+ throw new UnsupportedOperationException("NYI");
+ }
+
+ /**
+ * This adapter takes some untyped arguments, and returns an untyped result.
+ * Internally, it applies the invoker to the target, which causes the
+ * objects to be unboxed; the result is a raw type in L/I/J/F/D.
+ * This result is passed to convert, which is responsible for
+ * converting the raw result into a boxed object.
+ * The invoker is kept separate from the target because it can be
+ * generated once per type erasure family, and reused across adapters.
+ */
+ static abstract class Adapter extends BoundMethodHandle {
+ protected final MethodHandle filter; // transforms one or more arguments
+ protected final MethodHandle target; // ultimate target
+
+ @Override
+ public String toString() {
+ return addTypeString(target, this);
+ }
+
+ protected boolean isPrototype() { return target == null; }
+ protected Adapter(MethodHandle entryPoint) {
+ this(entryPoint, entryPoint, null);
+ assert(isPrototype());
+ }
+ protected MethodHandle prototypeEntryPoint() {
+ if (!isPrototype()) throw new InternalError();
+ return filter;
+ }
+
+ protected Adapter(MethodHandle entryPoint,
+ MethodHandle filter, MethodHandle target) {
+ super(entryPoint);
+ this.filter = filter;
+ this.target = target;
+ }
+
+ /** Make a copy of self, with new fields. */
+ protected abstract Adapter makeInstance(MethodHandle entryPoint,
+ MethodHandle filter, MethodHandle target);
+ // { return new ThisType(entryPoint, filter, target); }
+
+ static private final String CLASS_PREFIX; // "java.dyn.FilterGeneric$"
+ static {
+ String aname = Adapter.class.getName();
+ String sname = Adapter.class.getSimpleName();
+ if (!aname.endsWith(sname)) throw new InternalError();
+ CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
+ }
+ /** Find a sibing class of Adapter. */
+ static Class<? extends Adapter> findSubClass(String name) {
+ String cname = Adapter.CLASS_PREFIX + name;
+ try {
+ return Class.forName(cname).asSubclass(Adapter.class);
+ } catch (ClassNotFoundException ex) {
+ return null;
+ } catch (ClassCastException ex) {
+ return null;
+ }
+ }
+ }
+
+ static enum Kind {
+ value('V'), // filter and replace Nth argument value
+ fold('F'), // fold first N arguments, prepend result
+ collect('C'), // collect last N arguments, replace with result
+ flyby('Y'), // reify entire argument list, filter, pass to target
+ LIMIT('?');
+ static final int COUNT = LIMIT.ordinal();
+
+ final char key;
+ Kind(char key) { this.key = key; }
+ String invokerName(int pos) { return "invoke_"+key+""+pos; }
+ int invokerIndex(int pos) { return pos * COUNT + ordinal(); }
+ }
+
+ /* generated classes follow this pattern:
+ static class F1X extends Adapter {
+ protected F1X(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F1X(MethodHandle e, MethodHandle f, MethodHandle t)
+ { super(e, f, t); }
+ protected F1X makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
+ { return new F1X(e, f, t); }
+ protected Object invoke_V0(Object a0) { return target.invokeExact(filter.invokeExact(a0)); }
+ protected Object invoke_F0(Object a0) { return target.invokeExact(filter.invokeExact(), a0); }
+ protected Object invoke_F1(Object a0) { return target.invokeExact(filter.invokeExact(a0), a0); }
+ protected Object invoke_C0(Object a0) { return target.invokeExact(filter.invokeExact(a0)); }
+ protected Object invoke_C1(Object a0) { return target.invokeExact(a0, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0) { Object[] av = { a0 };
+ filter.invokeExact(av); return target.invokeExact(av[0]); }
+ }
+ static class F2X extends Adapter {
+ protected F2X(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F2X(MethodHandle e, MethodHandle f, MethodHandle t)
+ { super(e, f, t); }
+ protected F2X makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
+ { return new F2X(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0), a1); }
+ protected Object invoke_V1(Object a0, Object a1) { return target.invokeExact(a0, filter.invokeExact(a1)); }
+ protected Object invoke_F0(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(), a0, a1); }
+ protected Object invoke_F1(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0), a0, a1); }
+ protected Object invoke_F2(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0, a1), a0, a1); }
+ protected Object invoke_C0(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0, a1)); }
+ protected Object invoke_C1(Object a0, Object a1) { return target.invokeExact(a0, filter.invokeExact(a1)); }
+ protected Object invoke_C2(Object a0, Object a1) { return target.invokeExact(a0, a1, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1) { Object[] av = { a0, a1 };
+ filter.invokeExact(av); return target.invokeExact(av[0], av[1]); }
+ }
+ // */
+
+ // This one is written by hand:
+ static class F0 extends Adapter {
+ protected F0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F0(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F0 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F0(e, f, t); }
+ protected Object invoke_F0() throws Throwable {
+ return target.invokeExact(filter.invokeExact()); }
+ protected Object invoke_C0() throws Throwable {
+ return target.invokeExact(filter.invokeExact()); }
+ static final Object[] NO_ARGS = { };
+ protected Object invoke_Y0() throws Throwable {
+ filter.invokeExact(NO_ARGS); // make the flyby
+ return target.invokeExact(); }
+ }
+
+/*
+ : SHELL; n=FilterGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -ea -cp . genclasses | sed 's| *[/]/ *$||') >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
+//{{{
+import java.util.*;
+class genclasses {
+ static String[][] TEMPLATES = { {
+ "@for@ N=1..20",
+ " //@each-cat@",
+ " static class @cat@ extends Adapter {",
+ " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
+ " protected @cat@(MethodHandle e, MethodHandle f, MethodHandle t) {",
+ " super(e, f, t); }",
+ " protected @cat@ makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {",
+ " return new @cat@(e, f, t); }",
+ " //@each-P@",
+ " protected Object invoke_V@P@(@Tvav@) throws Throwable {",
+ " return target.invokeExact(@a0_@@Psp@filter.invokeExact(a@P@)@_aN@); }",
+ " //@end-P@",
+ " //@each-P@",
+ " protected Object invoke_F@P@(@Tvav@) throws Throwable {",
+ " return target.invokeExact(filter.invokeExact(@a0@),",
+ " @av@); }",
+ " //@end-P@",
+ " protected Object invoke_F@N@(@Tvav@) throws Throwable {",
+ " return target.invokeExact(filter.invokeExact(@av@),",
+ " @av@); }",
+ " //@each-P@",
+ " protected Object invoke_C@P@(@Tvav@) throws Throwable {",
+ " return target.invokeExact(@a0_@filter.invokeExact(a@P@@_aN@)); }",
+ " //@end-P@",
+ " protected Object invoke_C@N@(@Tvav@) throws Throwable {",
+ " return target.invokeExact(@av@, filter.invokeExact()); }",
+ " protected Object invoke_Y0(@Tvav@) throws Throwable {",
+ " Object[] av = { @av@ };",
+ " filter.invokeExact(av); // make the flyby",
+ " return target.invokeExact(@av[i]@); }",
+ " }",
+ } };
+ static final String NEWLINE_INDENT = " //\n ";
+ enum VAR {
+ cat, N, P, Tvav, av, a0, a0_, _aN, Psp, av_i_;
+ public final String pattern = "@"+toString().replace('_','.')+"@";
+ public String binding = toString();
+ static void makeBindings(boolean topLevel, int inargs, int pos) {
+ assert(-1 <= pos && pos < inargs);
+ VAR.cat.binding = "F"+inargs;
+ VAR.N.binding = String.valueOf(inargs); // incoming arg count
+ VAR.P.binding = String.valueOf(pos); // selected arg position
+ String[] av = new String[inargs];
+ String[] Tvav = new String[inargs];
+ String[] av_i_ = new String[inargs];
+ for (int i = 0; i < inargs; i++) {
+ av[i] = arg(i);
+ av_i_[i] = "av["+i+"]";
+ String spc = "";
+ if (i > 0 && i % 4 == 0) spc = NEWLINE_INDENT+(pos>9?" ":"")+" ";
+ Tvav[i] = spc+param("Object", av[i]);
+ }
+ VAR.av.binding = comma(av);
+ VAR.av_i_.binding = comma(av_i_);
+ VAR.Tvav.binding = comma(Tvav);
+ if (pos >= 0) {
+ VAR.Psp.binding = (pos > 0 && pos % 10 == 0) ? NEWLINE_INDENT : "";
+ String[] a0 = new String[pos];
+ String[] aN = new String[inargs - (pos+1)];
+ for (int i = 0; i < pos; i++) {
+ String spc = "";
+ if (i > 0 && i % 10 == 0) spc = NEWLINE_INDENT;
+ a0[i] = spc+av[i];
+ }
+ VAR.a0.binding = comma(a0);
+ VAR.a0_.binding = comma(a0, ", ");
+ for (int i = pos+1; i < inargs; i++) {
+ String spc = "";
+ if (i > 0 && i % 10 == 0) spc = NEWLINE_INDENT;
+ aN[i - (pos+1)] = spc+av[i];
+ }
+ VAR._aN.binding = comma(", ", aN);
+ }
+ }
+ static String arg(int i) { return "a"+i; }
+ static String param(String t, String a) { return t+" "+a; }
+ static String comma(String[] v) { return comma(v, ""); }
+ static String comma(String[] v, String sep) { return comma("", v, sep); }
+ static String comma(String sep, String[] v) { return comma(sep, v, ""); }
+ static String comma(String sep1, String[] v, String sep2) {
+ if (v.length == 0) return "";
+ String res = v[0];
+ for (int i = 1; i < v.length; i++) res += ", "+v[i];
+ return sep1 + res + sep2;
+ }
+ static String transform(String string) {
+ for (VAR var : values())
+ string = string.replaceAll(var.pattern, var.binding);
+ return string;
+ }
+ }
+ static String[] stringsIn(String[] strings, int beg, int end) {
+ return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
+ }
+ static String[] stringsBefore(String[] strings, int pos) {
+ return stringsIn(strings, 0, pos);
+ }
+ static String[] stringsAfter(String[] strings, int pos) {
+ return stringsIn(strings, pos, strings.length);
+ }
+ static int indexAfter(String[] strings, int pos, String tag) {
+ return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
+ }
+ static int indexBefore(String[] strings, int pos, String tag) {
+ for (int i = pos, end = strings.length; ; i++) {
+ if (i == end || strings[i].endsWith(tag)) return i;
+ }
+ }
+ static int MIN_ARITY, MAX_ARITY;
+ public static void main(String... av) {
+ for (String[] template : TEMPLATES) {
+ int forLinesLimit = indexBefore(template, 0, "@each-cat@");
+ String[] forLines = stringsBefore(template, forLinesLimit);
+ template = stringsAfter(template, forLinesLimit);
+ for (String forLine : forLines)
+ expandTemplate(forLine, template);
+ }
+ }
+ static void expandTemplate(String forLine, String[] template) {
+ String[] params = forLine.split("[^0-9]+");
+ if (params[0].length() == 0) params = stringsAfter(params, 1);
+ System.out.println("//params="+Arrays.asList(params));
+ int pcur = 0;
+ MIN_ARITY = Integer.valueOf(params[pcur++]);
+ MAX_ARITY = Integer.valueOf(params[pcur++]);
+ if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
+ for (int inargs = MIN_ARITY; inargs <= MAX_ARITY; inargs++) {
+ expandTemplate(template, true, inargs, -1);
+ }
+ }
+ static void expandTemplate(String[] template, boolean topLevel, int inargs, int pos) {
+ VAR.makeBindings(topLevel, inargs, pos);
+ for (int i = 0; i < template.length; i++) {
+ String line = template[i];
+ if (line.endsWith("@each-cat@")) {
+ // ignore
+ } else if (line.endsWith("@each-P@")) {
+ int blockEnd = indexAfter(template, i, "@end-P@");
+ String[] block = stringsIn(template, i+1, blockEnd-1);
+ for (int pos1 = Math.max(0,pos); pos1 < inargs; pos1++)
+ expandTemplate(block, false, inargs, pos1);
+ VAR.makeBindings(topLevel, inargs, pos);
+ i = blockEnd-1; continue;
+ } else {
+ System.out.println(VAR.transform(line));
+ }
+ }
+ }
+}
+//}}} */
+//params=[1, 20]
+ static class F1 extends Adapter {
+ protected F1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F1(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F1 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F1(e, f, t); }
+ protected Object invoke_V0(Object a0) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0)); }
+ protected Object invoke_F0(Object a0) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0); }
+ protected Object invoke_F1(Object a0) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0); }
+ protected Object invoke_C0(Object a0) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0)); }
+ protected Object invoke_C1(Object a0) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0) throws Throwable {
+ Object[] av = { a0 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0]); }
+ }
+ static class F2 extends Adapter {
+ protected F2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F2(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F2 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F2(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1); }
+ protected Object invoke_V1(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1)); }
+ protected Object invoke_F0(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1); }
+ protected Object invoke_F1(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1); }
+ protected Object invoke_F2(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1); }
+ protected Object invoke_C0(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1)); }
+ protected Object invoke_C1(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1)); }
+ protected Object invoke_C2(Object a0, Object a1) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1) throws Throwable {
+ Object[] av = { a0, a1 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1]); }
+ }
+ static class F3 extends Adapter {
+ protected F3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F3(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F3 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F3(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2) throws Throwable {
+ Object[] av = { a0, a1, a2 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2]); }
+ }
+ static class F4 extends Adapter {
+ protected F4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F4(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F4 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F4(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ Object[] av = { a0, a1, a2, a3 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3]); }
+ }
+ static class F5 extends Adapter {
+ protected F5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F5(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F5 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F5(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4]); }
+ }
+ static class F6 extends Adapter {
+ protected F6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F6(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F6 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F6(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5]); }
+ }
+ static class F7 extends Adapter {
+ protected F7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F7(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F7 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F7(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6]); }
+ }
+ static class F8 extends Adapter {
+ protected F8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F8(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F8 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F8(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7]); }
+ }
+ static class F9 extends Adapter {
+ protected F9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F9(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F9 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F9(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8]); }
+ }
+ static class F10 extends Adapter {
+ protected F10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F10(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F10 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F10(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9]); }
+ }
+ static class F11 extends Adapter {
+ protected F11(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F11(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F11 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F11(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10]); }
+ }
+ static class F12 extends Adapter {
+ protected F12(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F12(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F12 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F12(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11]); }
+ }
+ static class F13 extends Adapter {
+ protected F13(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F13(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F13 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F13(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12]); }
+ }
+ static class F14 extends Adapter {
+ protected F14(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F14(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F14 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F14(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12, a13); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12, a13); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12, a13); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12, a13); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12), a13); }
+ protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12, a13)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12, a13)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12, a13)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13)); }
+ protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13]); }
+ }
+ static class F15 extends Adapter {
+ protected F15(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F15(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F15 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F15(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12, a13, a14); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12, a13, a14); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12, a13, a14); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12), a13, a14); }
+ protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13), a14); }
+ protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12, a13, a14)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12, a13, a14)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12, a13, a14)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13, a14)); }
+ protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14)); }
+ protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14]); }
+ }
+ static class F16 extends Adapter {
+ protected F16(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F16(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F16 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F16(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12, a13, a14, a15); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12, a13, a14, a15); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12), a13, a14, a15); }
+ protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13), a14, a15); }
+ protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14), a15); }
+ protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12, a13, a14, a15)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12, a13, a14, a15)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13, a14, a15)); }
+ protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14, a15)); }
+ protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15)); }
+ protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15]); }
+ }
+ static class F17 extends Adapter {
+ protected F17(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F17(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F17 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F17(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12, a13, a14, a15, a16); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12), a13, a14, a15, a16); }
+ protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13), a14, a15, a16); }
+ protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14), a15, a16); }
+ protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15), a16); }
+ protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12, a13, a14, a15, a16)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12, a13, a14, a15, a16)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13, a14, a15, a16)); }
+ protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14, a15, a16)); }
+ protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15, a16)); }
+ protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16)); }
+ protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16]); }
+ }
+ static class F18 extends Adapter {
+ protected F18(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F18(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F18 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F18(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12), a13, a14, a15, a16, a17); }
+ protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13), a14, a15, a16, a17); }
+ protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14), a15, a16, a17); }
+ protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15), a16, a17); }
+ protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16), a17); }
+ protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12, a13, a14, a15, a16, a17)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13, a14, a15, a16, a17)); }
+ protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14, a15, a16, a17)); }
+ protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15, a16, a17)); }
+ protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16, a17)); }
+ protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17)); }
+ protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17]); }
+ }
+ static class F19 extends Adapter {
+ protected F19(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F19(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F19 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F19(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12), a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13), a14, a15, a16, a17, a18); }
+ protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14), a15, a16, a17, a18); }
+ protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15), a16, a17, a18); }
+ protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16), a17, a18); }
+ protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17), a18); }
+ protected Object invoke_V18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_F19(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12, a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13, a14, a15, a16, a17, a18)); }
+ protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14, a15, a16, a17, a18)); }
+ protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15, a16, a17, a18)); }
+ protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16, a17, a18)); }
+ protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17, a18)); }
+ protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18)); }
+ protected Object invoke_C19(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17], av[18]); }
+ }
+ static class F20 extends Adapter {
+ protected F20(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected F20(MethodHandle e, MethodHandle f, MethodHandle t) {
+ super(e, f, t); }
+ protected F20 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
+ return new F20(e, f, t); }
+ protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ filter.invokeExact(a10), a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11), a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12), a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13), a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14), a15, a16, a17, a18, a19); }
+ protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15), a16, a17, a18, a19); }
+ protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16), a17, a18, a19); }
+ protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17), a18, a19); }
+ protected Object invoke_V18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18), a19); }
+ protected Object invoke_V19(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invokeExact(a19)); }
+ protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F19(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_F20(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19),
+ a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
+ protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, filter.invokeExact(a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, filter.invokeExact(a12, a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, filter.invokeExact(a13, a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, filter.invokeExact(a14, a15, a16, a17, a18, a19)); }
+ protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, filter.invokeExact(a15, a16, a17, a18, a19)); }
+ protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, filter.invokeExact(a16, a17, a18, a19)); }
+ protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17, a18, a19)); }
+ protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18, a19)); }
+ protected Object invoke_C19(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invokeExact(a19)); }
+ protected Object invoke_C20(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, filter.invokeExact()); }
+ protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
+ Object a4, Object a5, Object a6, Object a7,
+ Object a8, Object a9, Object a10, Object a11,
+ Object a12, Object a13, Object a14, Object a15,
+ Object a16, Object a17, Object a18, Object a19) throws Throwable {
+ Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19 };
+ filter.invokeExact(av); // make the flyby
+ return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17], av[18], av[19]); }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/FilterOneArgument.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import static java.dyn.MethodHandleStatics.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * Unary function composition, useful for many small plumbing jobs.
+ * The invoke method takes a single reference argument, and returns a reference
+ * Internally, it first calls the {@code filter} method on the argument,
+ * Making up the difference between the raw method type and the
+ * final method type is the responsibility of a JVM-level adapter.
+ * @author jrose
+ */
+class FilterOneArgument extends BoundMethodHandle {
+ protected final MethodHandle filter; // Object -> Object
+ protected final MethodHandle target; // Object -> Object
+
+ @Override
+ public String toString() {
+ return target.toString();
+ }
+
+ protected Object invoke(Object argument) throws Throwable {
+ Object filteredArgument = filter.invokeExact(argument);
+ return target.invokeExact(filteredArgument);
+ }
+
+ private static final MethodHandle INVOKE;
+ static {
+ try {
+ INVOKE =
+ IMPL_LOOKUP.findVirtual(FilterOneArgument.class, "invoke",
+ MethodType.genericMethodType(1));
+ } catch (ReflectiveOperationException ex) {
+ throw uncaughtException(ex);
+ }
+ }
+
+ protected FilterOneArgument(MethodHandle filter, MethodHandle target) {
+ super(INVOKE);
+ this.filter = filter;
+ this.target = target;
+ }
+
+ public static MethodHandle make(MethodHandle filter, MethodHandle target) {
+ if (filter == null) return target;
+ if (target == null) return filter;
+ return new FilterOneArgument(filter, target);
+ }
+
+// MethodHandle make(MethodHandle filter1, MethodHandle filter2, MethodHandle target) {
+// MethodHandle filter = make(filter1, filter2);
+// return make(filter, target);
+// }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/FromGeneric.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,630 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.util.ValueConversions;
+import sun.dyn.util.Wrapper;
+import java.lang.reflect.*;
+import static java.dyn.MethodHandleStatics.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * Adapters which mediate between incoming calls which are generic
+ * and outgoing calls which are not. Any call can be represented generically
+ * boxing up its arguments, and (on return) unboxing the return value.
+ * <p>
+ * A call is "generic" (in MethodHandle terms) if its MethodType features
+ * only Object arguments. A non-generic call therefore features
+ * primitives and/or reference types other than Object.
+ * An adapter has types for its incoming and outgoing calls.
+ * The incoming call type is simply determined by the adapter's type
+ * (the MethodType it presents to callers). The outgoing call type
+ * is determined by the adapter's target (a MethodHandle that the adapter
+ * either binds internally or else takes as a leading argument).
+ * (To stretch the term, adapter-like method handles may have multiple
+ * targets or be polymorphic across multiple call types.)
+ * @author jrose
+ */
+class FromGeneric {
+ // type for the outgoing call (may have primitives, etc.)
+ private final MethodType targetType;
+ // type of the outgoing call internal to the adapter
+ private final MethodType internalType;
+ // prototype adapter (clone and customize for each new target!)
+ private final Adapter adapter;
+ // entry point for adapter (Adapter mh, a...) => ...
+ private final MethodHandle entryPoint;
+ // unboxing invoker of type (MH, Object**N) => raw return value
+ // it makes up the difference of internalType => targetType
+ private final MethodHandle unboxingInvoker;
+ // conversion which boxes a the target's raw return value
+ private final MethodHandle returnConversion;
+
+ /** Compute and cache information common to all unboxing adapters
+ * that can call out to targets of the erasure-family of the given erased type.
+ */
+ private FromGeneric(MethodType targetType) {
+ this.targetType = targetType;
+ MethodType internalType0;
+ // the target invoker will generally need casts on reference arguments
+ Adapter ad = findAdapter(internalType0 = targetType.erase());
+ if (ad != null) {
+ // Immediate hit to exactly the adapter we want,
+ // with no monkeying around with primitive types.
+ this.internalType = internalType0;
+ this.adapter = ad;
+ this.entryPoint = ad.prototypeEntryPoint();
+ this.returnConversion = computeReturnConversion(targetType, internalType0);
+ this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
+ return;
+ }
+
+ // outgoing primitive arguments will be wrapped; unwrap them
+ MethodType primsAsObj = targetType.form().primArgsAsBoxes();
+ MethodType objArgsRawRet = primsAsObj.form().primsAsInts();
+ if (objArgsRawRet != targetType)
+ ad = findAdapter(internalType0 = objArgsRawRet);
+ if (ad == null) {
+ ad = buildAdapterFromBytecodes(internalType0 = targetType);
+ }
+ this.internalType = internalType0;
+ this.adapter = ad;
+ MethodType tepType = targetType.insertParameterTypes(0, adapter.getClass());
+ this.entryPoint = ad.prototypeEntryPoint();
+ this.returnConversion = computeReturnConversion(targetType, internalType0);
+ this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
+ }
+
+ /**
+ * The typed target will be called according to targetType.
+ * The adapter code will in fact see the raw result from internalType,
+ * and must box it into an object. Produce a converter for this.
+ */
+ private static MethodHandle computeReturnConversion(
+ MethodType targetType, MethodType internalType) {
+ Class<?> tret = targetType.returnType();
+ Class<?> iret = internalType.returnType();
+ Wrapper wrap = Wrapper.forBasicType(tret);
+ if (!iret.isPrimitive()) {
+ assert(iret == Object.class);
+ return ValueConversions.identity();
+ } else if (wrap.primitiveType() == iret) {
+ return ValueConversions.box(wrap, false);
+ } else {
+ assert(tret == double.class ? iret == long.class : iret == int.class);
+ return ValueConversions.boxRaw(wrap, false);
+ }
+ }
+
+ /**
+ * The typed target will need an exact invocation point; provide it here.
+ * The adapter will possibly need to make a slightly different call,
+ * so adapt the invoker. This way, the logic for making up the
+ * difference between what the adapter can call and what the target
+ * needs can be cached once per type.
+ */
+ private static MethodHandle computeUnboxingInvoker(
+ MethodType targetType, MethodType internalType) {
+ // All the adapters we have here have reference-untyped internal calls.
+ assert(internalType == internalType.erase());
+ MethodHandle invoker = targetType.invokers().exactInvoker();
+ // cast all narrow reference types, unbox all primitive arguments:
+ MethodType fixArgsType = internalType.changeReturnType(targetType.returnType());
+ MethodHandle fixArgs = MethodHandleImpl.convertArguments(
+ invoker, Invokers.invokerType(fixArgsType),
+ invoker.type(), null);
+ if (fixArgs == null)
+ throw new InternalError("bad fixArgs");
+ // reinterpret the calling sequence as raw:
+ MethodHandle retyper = AdapterMethodHandle.makeRetypeRaw(
+ Invokers.invokerType(internalType), fixArgs);
+ if (retyper == null)
+ throw new InternalError("bad retyper");
+ return retyper;
+ }
+
+ Adapter makeInstance(MethodHandle typedTarget) {
+ MethodType type = typedTarget.type();
+ if (type == targetType) {
+ return adapter.makeInstance(entryPoint, unboxingInvoker, returnConversion, typedTarget);
+ }
+ // my erased-type is not exactly the same as the desired type
+ assert(type.erase() == targetType); // else we are busted
+ MethodHandle invoker = computeUnboxingInvoker(type, internalType);
+ return adapter.makeInstance(entryPoint, invoker, returnConversion, typedTarget);
+ }
+
+ /** Build an adapter of the given generic type, which invokes typedTarget
+ * on the incoming arguments, after unboxing as necessary.
+ * The return value is boxed if necessary.
+ * @param genericType the required type of the result
+ * @param typedTarget the target
+ * @return an adapter method handle
+ */
+ public static MethodHandle make(MethodHandle typedTarget) {
+ MethodType type = typedTarget.type();
+ if (type == type.generic()) return typedTarget;
+ return FromGeneric.of(type).makeInstance(typedTarget);
+ }
+
+ /** Return the adapter information for this type's erasure. */
+ static FromGeneric of(MethodType type) {
+ MethodTypeForm form = type.form();
+ FromGeneric fromGen = form.fromGeneric;
+ if (fromGen == null)
+ form.fromGeneric = fromGen = new FromGeneric(form.erasedType());
+ return fromGen;
+ }
+
+ public String toString() {
+ return "FromGeneric"+targetType;
+ }
+
+ /* Create an adapter that handles spreading calls for the given type. */
+ static Adapter findAdapter(MethodType internalType) {
+ MethodType entryType = internalType.generic();
+ MethodTypeForm form = internalType.form();
+ Class<?> rtype = internalType.returnType();
+ int argc = form.parameterCount();
+ int lac = form.longPrimitiveParameterCount();
+ int iac = form.primitiveParameterCount() - lac;
+ String intsAndLongs = (iac > 0 ? "I"+iac : "")+(lac > 0 ? "J"+lac : "");
+ String rawReturn = String.valueOf(Wrapper.forPrimitiveType(rtype).basicTypeChar());
+ String cname0 = rawReturn + argc;
+ String cname1 = "A" + argc;
+ String[] cnames = { cname0+intsAndLongs, cname0, cname1+intsAndLongs, cname1 };
+ String iname = "invoke_"+cname0+intsAndLongs;
+ // e.g., D5I2, D5, L5I2, L5; invoke_D5
+ for (String cname : cnames) {
+ Class<? extends Adapter> acls = Adapter.findSubClass(cname);
+ if (acls == null) continue;
+ // see if it has the required invoke method
+ MethodHandle entryPoint = null;
+ try {
+ entryPoint = IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
+ } catch (ReflectiveOperationException ex) {
+ }
+ if (entryPoint == null) continue;
+ Constructor<? extends Adapter> ctor = null;
+ try {
+ ctor = acls.getDeclaredConstructor(MethodHandle.class);
+ } catch (NoSuchMethodException ex) {
+ } catch (SecurityException ex) {
+ }
+ if (ctor == null) continue;
+ try {
+ // Produce an instance configured as a prototype.
+ return ctor.newInstance(entryPoint);
+ } catch (IllegalArgumentException ex) {
+ } catch (InvocationTargetException wex) {
+ Throwable ex = wex.getTargetException();
+ if (ex instanceof Error) throw (Error)ex;
+ if (ex instanceof RuntimeException) throw (RuntimeException)ex;
+ } catch (InstantiationException ex) {
+ } catch (IllegalAccessException ex) {
+ }
+ }
+ return null;
+ }
+
+ static Adapter buildAdapterFromBytecodes(MethodType internalType) {
+ throw new UnsupportedOperationException("NYI");
+ }
+
+ /**
+ * This adapter takes some untyped arguments, and returns an untyped result.
+ * Internally, it applies the invoker to the target, which causes the
+ * objects to be unboxed; the result is a raw type in L/I/J/F/D.
+ * This result is passed to convert, which is responsible for
+ * converting the raw result into a boxed object.
+ * The invoker is kept separate from the target because it can be
+ * generated once per type erasure family, and reused across adapters.
+ */
+ static abstract class Adapter extends BoundMethodHandle {
+ /*
+ * class X<<R,int N>> extends Adapter {
+ * (MH, Object**N)=>raw(R) invoker;
+ * (any**N)=>R target;
+ * raw(R)=>Object convert;
+ * Object invoke(Object**N a) = convert(invoker(target, a...))
+ * }
+ */
+ protected final MethodHandle invoker; // (MH, Object**N) => raw(R)
+ protected final MethodHandle convert; // raw(R) => Object
+ protected final MethodHandle target; // (any**N) => R
+
+ @Override
+ public String toString() {
+ return addTypeString(target, this);
+ }
+
+ protected boolean isPrototype() { return target == null; }
+ protected Adapter(MethodHandle entryPoint) {
+ this(entryPoint, null, entryPoint, null);
+ assert(isPrototype());
+ }
+ protected MethodHandle prototypeEntryPoint() {
+ if (!isPrototype()) throw new InternalError();
+ return convert;
+ }
+
+ protected Adapter(MethodHandle entryPoint,
+ MethodHandle invoker, MethodHandle convert, MethodHandle target) {
+ super(entryPoint);
+ this.invoker = invoker;
+ this.convert = convert;
+ this.target = target;
+ }
+
+ /** Make a copy of self, with new fields. */
+ protected abstract Adapter makeInstance(MethodHandle entryPoint,
+ MethodHandle invoker, MethodHandle convert, MethodHandle target);
+ // { return new ThisType(entryPoint, convert, target); }
+
+ /// Conversions on the value returned from the target.
+ protected Object convert_L(Object result) throws Throwable { return convert.invokeExact(result); }
+ protected Object convert_I(int result) throws Throwable { return convert.invokeExact(result); }
+ protected Object convert_J(long result) throws Throwable { return convert.invokeExact(result); }
+ protected Object convert_F(float result) throws Throwable { return convert.invokeExact(result); }
+ protected Object convert_D(double result) throws Throwable { return convert.invokeExact(result); }
+
+ static private final String CLASS_PREFIX; // "java.dyn.FromGeneric$"
+ static {
+ String aname = Adapter.class.getName();
+ String sname = Adapter.class.getSimpleName();
+ if (!aname.endsWith(sname)) throw new InternalError();
+ CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
+ }
+ /** Find a sibing class of Adapter. */
+ static Class<? extends Adapter> findSubClass(String name) {
+ String cname = Adapter.CLASS_PREFIX + name;
+ try {
+ return Class.forName(cname).asSubclass(Adapter.class);
+ } catch (ClassNotFoundException ex) {
+ return null;
+ } catch (ClassCastException ex) {
+ return null;
+ }
+ }
+ }
+
+ /* generated classes follow this pattern:
+ static class xA2 extends Adapter {
+ protected xA2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected xA2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected xA2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new xA2(e, i, c, t); }
+ protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
+ }
+ // */
+
+/*
+: SHELL; n=FromGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
+//{{{
+import java.util.*;
+class genclasses {
+ static String[] TYPES = { "Object", "int ", "long ", "float ", "double" };
+ static String[] WRAPS = { " ", "(Integer)", "(Long) ", "(Float) ", "(Double) " };
+ static String[] TCHARS = { "L", "I", "J", "F", "D", "A" };
+ static String[][] TEMPLATES = { {
+ "@for@ arity=0..10 rcat<=4 nrefs<=99 nints=0 nlongs=0",
+ " //@each-cat@",
+ " static class @cat@ extends Adapter {",
+ " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
+ " protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
+ " { super(e, i, c, t); }",
+ " protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
+ " { return new @cat@(e, i, c, t); }",
+ " //@each-R@",
+ " protected Object invoke_@catN@(@Tvav@) throws Throwable { return convert_@Rc@((@R@)@W@invoker.invokeExact(target@av@)); }",
+ " //@end-R@",
+ " }",
+ } };
+ static final String NEWLINE_INDENT = "\n ";
+ enum VAR {
+ cat, catN, R, Rc, W, av, Tvav, Ovav;
+ public final String pattern = "@"+toString().replace('_','.')+"@";
+ public String binding;
+ static void makeBindings(boolean topLevel, int rcat, int nrefs, int nints, int nlongs) {
+ int nargs = nrefs + nints + nlongs;
+ if (topLevel)
+ VAR.cat.binding = catstr(ALL_RETURN_TYPES ? TYPES.length : rcat, nrefs, nints, nlongs);
+ VAR.catN.binding = catstr(rcat, nrefs, nints, nlongs);
+ VAR.R.binding = TYPES[rcat];
+ VAR.Rc.binding = TCHARS[rcat];
+ VAR.W.binding = WRAPS[rcat];
+ String[] Tv = new String[nargs];
+ String[] av = new String[nargs];
+ String[] Tvav = new String[nargs];
+ String[] Ovav = new String[nargs];
+ for (int i = 0; i < nargs; i++) {
+ int tcat = (i < nrefs) ? 0 : (i < nrefs + nints) ? 1 : 2;
+ Tv[i] = TYPES[tcat];
+ av[i] = arg(i);
+ Tvav[i] = param(Tv[i], av[i]);
+ Ovav[i] = param("Object", av[i]);
+ }
+ VAR.av.binding = comma(", ", av);
+ VAR.Tvav.binding = comma(Tvav);
+ VAR.Ovav.binding = comma(Ovav);
+ }
+ static String arg(int i) { return "a"+i; }
+ static String param(String t, String a) { return t+" "+a; }
+ static String comma(String[] v) { return comma("", v); }
+ static String comma(String sep, String[] v) {
+ if (v.length == 0) return "";
+ String res = sep+v[0];
+ for (int i = 1; i < v.length; i++) res += ", "+v[i];
+ return res;
+ }
+ static String transform(String string) {
+ for (VAR var : values())
+ string = string.replaceAll(var.pattern, var.binding);
+ return string;
+ }
+ }
+ static String[] stringsIn(String[] strings, int beg, int end) {
+ return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
+ }
+ static String[] stringsBefore(String[] strings, int pos) {
+ return stringsIn(strings, 0, pos);
+ }
+ static String[] stringsAfter(String[] strings, int pos) {
+ return stringsIn(strings, pos, strings.length);
+ }
+ static int indexAfter(String[] strings, int pos, String tag) {
+ return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
+ }
+ static int indexBefore(String[] strings, int pos, String tag) {
+ for (int i = pos, end = strings.length; ; i++) {
+ if (i == end || strings[i].endsWith(tag)) return i;
+ }
+ }
+ static int MIN_ARITY, MAX_ARITY, MAX_RCAT, MAX_REFS, MAX_INTS, MAX_LONGS;
+ static boolean ALL_ARG_TYPES, ALL_RETURN_TYPES;
+ static HashSet<String> done = new HashSet<String>();
+ public static void main(String... av) {
+ for (String[] template : TEMPLATES) {
+ int forLinesLimit = indexBefore(template, 0, "@each-cat@");
+ String[] forLines = stringsBefore(template, forLinesLimit);
+ template = stringsAfter(template, forLinesLimit);
+ for (String forLine : forLines)
+ expandTemplate(forLine, template);
+ }
+ }
+ static void expandTemplate(String forLine, String[] template) {
+ String[] params = forLine.split("[^0-9]+");
+ if (params[0].length() == 0) params = stringsAfter(params, 1);
+ System.out.println("//params="+Arrays.asList(params));
+ int pcur = 0;
+ MIN_ARITY = Integer.valueOf(params[pcur++]);
+ MAX_ARITY = Integer.valueOf(params[pcur++]);
+ MAX_RCAT = Integer.valueOf(params[pcur++]);
+ MAX_REFS = Integer.valueOf(params[pcur++]);
+ MAX_INTS = Integer.valueOf(params[pcur++]);
+ MAX_LONGS = Integer.valueOf(params[pcur++]);
+ if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
+ if (MAX_RCAT >= TYPES.length) MAX_RCAT = TYPES.length - 1;
+ ALL_ARG_TYPES = (indexBefore(template, 0, "@each-Tv@") < template.length);
+ ALL_RETURN_TYPES = (indexBefore(template, 0, "@each-R@") < template.length);
+ for (int nargs = MIN_ARITY; nargs <= MAX_ARITY; nargs++) {
+ for (int rcat = 0; rcat <= MAX_RCAT; rcat++) {
+ expandTemplate(template, true, rcat, nargs, 0, 0);
+ if (ALL_ARG_TYPES) break;
+ expandTemplateForPrims(template, true, rcat, nargs, 1, 1);
+ if (ALL_RETURN_TYPES) break;
+ }
+ }
+ }
+ static String catstr(int rcat, int nrefs, int nints, int nlongs) {
+ int nargs = nrefs + nints + nlongs;
+ String cat = TCHARS[rcat] + nargs;
+ if (!ALL_ARG_TYPES) cat += (nints==0?"":"I"+nints)+(nlongs==0?"":"J"+nlongs);
+ return cat;
+ }
+ static void expandTemplateForPrims(String[] template, boolean topLevel, int rcat, int nargs, int minints, int minlongs) {
+ for (int isLong = 0; isLong <= 1; isLong++) {
+ for (int nprims = 1; nprims <= nargs; nprims++) {
+ int nrefs = nargs - nprims;
+ int nints = ((1-isLong) * nprims);
+ int nlongs = (isLong * nprims);
+ expandTemplate(template, topLevel, rcat, nrefs, nints, nlongs);
+ }
+ }
+ }
+ static void expandTemplate(String[] template, boolean topLevel,
+ int rcat, int nrefs, int nints, int nlongs) {
+ int nargs = nrefs + nints + nlongs;
+ if (nrefs > MAX_REFS || nints > MAX_INTS || nlongs > MAX_LONGS) return;
+ VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
+ if (topLevel && !done.add(VAR.cat.binding)) {
+ System.out.println(" //repeat "+VAR.cat.binding);
+ return;
+ }
+ for (int i = 0; i < template.length; i++) {
+ String line = template[i];
+ if (line.endsWith("@each-cat@")) {
+ // ignore
+ } else if (line.endsWith("@each-R@")) {
+ int blockEnd = indexAfter(template, i, "@end-R@");
+ String[] block = stringsIn(template, i+1, blockEnd-1);
+ for (int rcat1 = rcat; rcat1 <= MAX_RCAT; rcat1++)
+ expandTemplate(block, false, rcat1, nrefs, nints, nlongs);
+ VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
+ i = blockEnd-1; continue;
+ } else if (line.endsWith("@each-Tv@")) {
+ int blockEnd = indexAfter(template, i, "@end-Tv@");
+ String[] block = stringsIn(template, i+1, blockEnd-1);
+ expandTemplate(block, false, rcat, nrefs, nints, nlongs);
+ expandTemplateForPrims(block, false, rcat, nargs, nints+1, nlongs+1);
+ VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
+ i = blockEnd-1; continue;
+ } else {
+ System.out.println(VAR.transform(line));
+ }
+ }
+ }
+}
+//}}} */
+//params=[0, 10, 4, 99, 0, 0]
+ static class A0 extends Adapter {
+ protected A0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A0(e, i, c, t); }
+ protected Object invoke_L0() throws Throwable { return convert_L((Object)invoker.invokeExact(target)); }
+ protected Object invoke_I0() throws Throwable { return convert_I((int) invoker.invokeExact(target)); }
+ protected Object invoke_J0() throws Throwable { return convert_J((long) invoker.invokeExact(target)); }
+ protected Object invoke_F0() throws Throwable { return convert_F((float) invoker.invokeExact(target)); }
+ protected Object invoke_D0() throws Throwable { return convert_D((double)invoker.invokeExact(target)); }
+ }
+ static class A1 extends Adapter {
+ protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A1(e, i, c, t); }
+ protected Object invoke_L1(Object a0) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0)); }
+ protected Object invoke_I1(Object a0) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0)); }
+ protected Object invoke_J1(Object a0) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0)); }
+ protected Object invoke_F1(Object a0) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0)); }
+ protected Object invoke_D1(Object a0) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0)); }
+ }
+ static class A2 extends Adapter {
+ protected A2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A2(e, i, c, t); }
+ protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
+ protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
+ }
+ static class A3 extends Adapter {
+ protected A3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A3(e, i, c, t); }
+ protected Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2)); }
+ protected Object invoke_I3(Object a0, Object a1, Object a2) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2)); }
+ protected Object invoke_J3(Object a0, Object a1, Object a2) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2)); }
+ protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2)); }
+ protected Object invoke_D3(Object a0, Object a1, Object a2) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2)); }
+ }
+ static class A4 extends Adapter {
+ protected A4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A4(e, i, c, t); }
+ protected Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3)); }
+ protected Object invoke_I4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3)); }
+ protected Object invoke_J4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3)); }
+ protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3)); }
+ protected Object invoke_D4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3)); }
+ }
+ static class A5 extends Adapter {
+ protected A5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A5(e, i, c, t); }
+ protected Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+ protected Object invoke_I5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+ protected Object invoke_J5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+ protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+ protected Object invoke_D5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
+ }
+ static class A6 extends Adapter {
+ protected A6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A6(e, i, c, t); }
+ protected Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_I6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_J6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_D6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
+ }
+ static class A7 extends Adapter {
+ protected A7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A7(e, i, c, t); }
+ protected Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_I7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_J7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_D7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
+ }
+ static class A8 extends Adapter {
+ protected A8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A8(e, i, c, t); }
+ protected Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_I8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_J8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_D8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
+ }
+ static class A9 extends Adapter {
+ protected A9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A9(e, i, c, t); }
+ protected Object invoke_L9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_I9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_J9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_D9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ }
+ static class A10 extends Adapter {
+ protected A10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { super(e, i, c, t); }
+ protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
+ { return new A10(e, i, c, t); }
+ protected Object invoke_L10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_I10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_J10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_D10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ }
+}
--- a/jdk/src/share/classes/java/dyn/InvokeDynamic.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/InvokeDynamic.java Fri Mar 18 00:03:24 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/InvokeGeneric.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.util.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * Adapters which manage MethodHandle.invokeGeneric calls.
+ * The JVM calls one of these when the exact type match fails.
+ * @author jrose
+ */
+class InvokeGeneric {
+ // erased type for the call, which originates from an invokeGeneric site
+ private final MethodType erasedCallerType;
+ // an invoker of type (MT, MH; A...) -> R
+ private final MethodHandle initialInvoker;
+
+ /** Compute and cache information for this adapter, so that it can
+ * call out to targets of the erasure-family of the given erased type.
+ */
+ /*non-public*/ InvokeGeneric(MethodType erasedCallerType) throws ReflectiveOperationException {
+ assert(erasedCallerType.equals(erasedCallerType.erase()));
+ this.erasedCallerType = erasedCallerType;
+ this.initialInvoker = makeInitialInvoker();
+ assert initialInvoker.type().equals(erasedCallerType
+ .insertParameterTypes(0, MethodType.class, MethodHandle.class))
+ : initialInvoker.type();
+ }
+
+ private static MethodHandles.Lookup lookup() {
+ return IMPL_LOOKUP;
+ }
+
+ /** Return the adapter information for this type's erasure. */
+ /*non-public*/ static MethodHandle genericInvokerOf(MethodType erasedCallerType) throws ReflectiveOperationException {
+ InvokeGeneric gen = new InvokeGeneric(erasedCallerType);
+ return gen.initialInvoker;
+ }
+
+ private MethodHandle makeInitialInvoker() throws ReflectiveOperationException {
+ // postDispatch = #(MH'; MT, MH; A...){MH'(MT, MH; A)}
+ MethodHandle postDispatch = makePostDispatchInvoker();
+ MethodHandle invoker;
+ if (returnConversionPossible()) {
+ invoker = MethodHandles.foldArguments(postDispatch,
+ dispatcher("dispatchWithConversion"));
+ } else {
+ invoker = MethodHandles.foldArguments(postDispatch, dispatcher("dispatch"));
+ }
+ return invoker;
+ }
+
+ private static final Class<?>[] EXTRA_ARGS = { MethodType.class, MethodHandle.class };
+ private MethodHandle makePostDispatchInvoker() {
+ // Take (MH'; MT, MH; A...) and run MH'(MT, MH; A...).
+ MethodType invokerType = erasedCallerType.insertParameterTypes(0, EXTRA_ARGS);
+ return invokerType.invokers().exactInvoker();
+ }
+ private MethodHandle dropDispatchArguments(MethodHandle targetInvoker) {
+ assert(targetInvoker.type().parameterType(0) == MethodHandle.class);
+ return MethodHandles.dropArguments(targetInvoker, 1, EXTRA_ARGS);
+ }
+
+ private MethodHandle dispatcher(String dispatchName) throws ReflectiveOperationException {
+ return lookup().bind(this, dispatchName,
+ MethodType.methodType(MethodHandle.class,
+ MethodType.class, MethodHandle.class));
+ }
+
+ static final boolean USE_AS_TYPE_PATH = true;
+
+ /** Return a method handle to invoke on the callerType, target, and remaining arguments.
+ * The method handle must finish the call.
+ * This is the first look at the caller type and target.
+ */
+ private MethodHandle dispatch(MethodType callerType, MethodHandle target) {
+ MethodType targetType = target.type();
+ if (USE_AS_TYPE_PATH || target.isVarargsCollector()) {
+ MethodHandle newTarget = target.asType(callerType);
+ targetType = callerType;
+ Invokers invokers = targetType.invokers();
+ MethodHandle invoker = invokers.erasedInvokerWithDrops;
+ if (invoker == null) {
+ invokers.erasedInvokerWithDrops = invoker =
+ dropDispatchArguments(invokers.erasedInvoker());
+ }
+ return invoker.bindTo(newTarget);
+ }
+ throw new RuntimeException("NYI");
+ }
+
+ private MethodHandle dispatchWithConversion(MethodType callerType, MethodHandle target) {
+ MethodHandle finisher = dispatch(callerType, target);
+ if (returnConversionNeeded(callerType, target))
+ finisher = addReturnConversion(finisher, callerType.returnType()); //FIXME: slow
+ return finisher;
+ }
+
+ private boolean returnConversionPossible() {
+ Class<?> needType = erasedCallerType.returnType();
+ return !needType.isPrimitive();
+ }
+ private boolean returnConversionNeeded(MethodType callerType, MethodHandle target) {
+ Class<?> needType = callerType.returnType();
+ if (needType == erasedCallerType.returnType())
+ return false; // no conversions possible, since must be primitive or Object
+ Class<?> haveType = target.type().returnType();
+ if (VerifyType.isNullConversion(haveType, needType))
+ return false;
+ return true;
+ }
+ private MethodHandle addReturnConversion(MethodHandle target, Class<?> type) {
+ if (true) throw new RuntimeException("NYI");
+ // FIXME: This is slow because it creates a closure node on every call that requires a return cast.
+ MethodType targetType = target.type();
+ MethodHandle caster = ValueConversions.identity(type);
+ caster = caster.asType(MethodType.methodType(type, targetType.returnType()));
+ // Drop irrelevant arguments, because we only care about the return value:
+ caster = MethodHandles.dropArguments(caster, 1, targetType.parameterList());
+ MethodHandle result = MethodHandles.foldArguments(caster, target);
+ return result.asType(target.type());
+ }
+
+ public String toString() {
+ return "InvokeGeneric"+erasedCallerType;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/Invokers.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.empty.Empty;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * Construction and caching of often-used invokers.
+ * @author jrose
+ */
+class Invokers {
+ // exact type (sans leading taget MH) for the outgoing call
+ private final MethodType targetType;
+
+ // exact invoker for the outgoing call
+ private /*lazy*/ MethodHandle exactInvoker;
+
+ // erased (partially untyped but with primitives) invoker for the outgoing call
+ private /*lazy*/ MethodHandle erasedInvoker;
+ /*lazy*/ MethodHandle erasedInvokerWithDrops; // for InvokeGeneric
+
+ // generic (untyped) invoker for the outgoing call
+ private /*lazy*/ MethodHandle genericInvoker;
+
+ // generic (untyped) invoker for the outgoing call; accepts a single Object[]
+ private final /*lazy*/ MethodHandle[] spreadInvokers;
+
+ // invoker for an unbound callsite
+ private /*lazy*/ MethodHandle uninitializedCallSite;
+
+ /** Compute and cache information common to all collecting adapters
+ * that implement members of the erasure-family of the given erased type.
+ */
+ /*non-public*/ Invokers(MethodType targetType) {
+ this.targetType = targetType;
+ this.spreadInvokers = new MethodHandle[targetType.parameterCount()+1];
+ }
+
+ /*non-public*/ static MethodType invokerType(MethodType targetType) {
+ return targetType.insertParameterTypes(0, MethodHandle.class);
+ }
+
+ /*non-public*/ MethodHandle exactInvoker() {
+ MethodHandle invoker = exactInvoker;
+ if (invoker != null) return invoker;
+ try {
+ invoker = IMPL_LOOKUP.findVirtual(MethodHandle.class, "invokeExact", targetType);
+ } catch (ReflectiveOperationException ex) {
+ throw new InternalError("JVM cannot find invoker for "+targetType);
+ }
+ assert(invokerType(targetType) == invoker.type());
+ exactInvoker = invoker;
+ return invoker;
+ }
+
+ /*non-public*/ MethodHandle genericInvoker() {
+ MethodHandle invoker1 = exactInvoker();
+ MethodHandle invoker = genericInvoker;
+ if (invoker != null) return invoker;
+ MethodType genericType = targetType.generic();
+ invoker = MethodHandles.convertArguments(invoker1, invokerType(genericType));
+ genericInvoker = invoker;
+ return invoker;
+ }
+
+ /*non-public*/ MethodHandle erasedInvoker() {
+ MethodHandle invoker1 = exactInvoker();
+ MethodHandle invoker = erasedInvoker;
+ if (invoker != null) return invoker;
+ MethodType erasedType = targetType.erase();
+ if (erasedType == targetType.generic())
+ invoker = genericInvoker();
+ else
+ invoker = MethodHandles.convertArguments(invoker1, invokerType(erasedType));
+ erasedInvoker = invoker;
+ return invoker;
+ }
+
+ /*non-public*/ MethodHandle spreadInvoker(int objectArgCount) {
+ MethodHandle vaInvoker = spreadInvokers[objectArgCount];
+ if (vaInvoker != null) return vaInvoker;
+ MethodHandle gInvoker = genericInvoker();
+ vaInvoker = gInvoker.asSpreader(Object[].class, targetType.parameterCount() - objectArgCount);
+ spreadInvokers[objectArgCount] = vaInvoker;
+ return vaInvoker;
+ }
+
+ private static MethodHandle THROW_UCS = null;
+
+ /*non-public*/ MethodHandle uninitializedCallSite() {
+ MethodHandle invoker = uninitializedCallSite;
+ if (invoker != null) return invoker;
+ if (targetType.parameterCount() > 0) {
+ MethodType type0 = targetType.dropParameterTypes(0, targetType.parameterCount());
+ Invokers invokers0 = type0.invokers();
+ invoker = MethodHandles.dropArguments(invokers0.uninitializedCallSite(),
+ 0, targetType.parameterList());
+ assert(invoker.type().equals(targetType));
+ uninitializedCallSite = invoker;
+ return invoker;
+ }
+ if (THROW_UCS == null) {
+ try {
+ THROW_UCS = IMPL_LOOKUP
+ .findStatic(CallSite.class, "uninitializedCallSite",
+ MethodType.methodType(Empty.class));
+ } catch (ReflectiveOperationException ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+ invoker = AdapterMethodHandle.makeRetypeRaw(targetType, THROW_UCS);
+ assert(invoker.type().equals(targetType));
+ uninitializedCallSite = invoker;
+ return invoker;
+ }
+
+ public String toString() {
+ return "Invokers"+targetType;
+ }
+}
--- a/jdk/src/share/classes/java/dyn/Linkage.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/Linkage.java Fri Mar 18 00:03:24 2011 -0700
@@ -25,13 +25,9 @@
package java.dyn;
+import sun.dyn.util.VerifyAccess;
import java.dyn.MethodHandles.Lookup;
-import java.util.WeakHashMap;
-import sun.dyn.Access;
-import sun.dyn.MethodHandleImpl;
-import sun.dyn.util.VerifyAccess;
import sun.reflect.Reflection;
-import static sun.dyn.MemberName.newIllegalArgumentException;
/**
* <em>CLASS WILL BE REMOVED FOR PFD:</em>
@@ -41,8 +37,6 @@
* @deprecated This class will be removed in the Public Final Draft.
*/
public class Linkage {
- private static final Access IMPL_TOKEN = Access.getToken();
-
private Linkage() {} // do not instantiate
/**
@@ -56,7 +50,7 @@
Class callc = Reflection.getCallerClass(2);
if (callc != null && !VerifyAccess.isSamePackage(callerClass, callc))
throw new IllegalArgumentException("cannot set bootstrap method on "+callerClass);
- MethodHandleImpl.registerBootstrap(IMPL_TOKEN, callerClass, bootstrapMethod);
+ MethodHandleImpl.registerBootstrap(callerClass, bootstrapMethod);
}
/**
@@ -84,14 +78,14 @@
private static
void registerBootstrapMethodLookup(Class<?> callerClass, Class<?> runtime, String name) {
- Lookup lookup = new Lookup(IMPL_TOKEN, callerClass);
+ Lookup lookup = new Lookup(callerClass);
MethodHandle bootstrapMethod;
try {
bootstrapMethod = lookup.findStatic(runtime, name, BOOTSTRAP_METHOD_TYPE);
} catch (ReflectiveOperationException ex) {
throw new IllegalArgumentException("no such bootstrap method in "+runtime+": "+name, ex);
}
- MethodHandleImpl.registerBootstrap(IMPL_TOKEN, callerClass, bootstrapMethod);
+ MethodHandleImpl.registerBootstrap(callerClass, bootstrapMethod);
}
private static final MethodType BOOTSTRAP_METHOD_TYPE
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/MemberName.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,718 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.util.BytecodeDescriptor;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import static java.dyn.MethodHandleNatives.Constants.*;
+import static java.dyn.MethodHandleStatics.*;
+
+/**
+ * A {@code MemberName} is a compact symbolic datum which fully characterizes
+ * a method or field reference.
+ * A member name refers to a field, method, constructor, or member type.
+ * Every member name has a simple name (a string) and a type (either a Class or MethodType).
+ * A member name may also have a non-null declaring class, or it may be simply
+ * a naked name/type pair.
+ * A member name may also have non-zero modifier flags.
+ * Finally, a member name may be either resolved or unresolved.
+ * If it is resolved, the existence of the named
+ * <p>
+ * Whether resolved or not, a member name provides no access rights or
+ * invocation capability to its possessor. It is merely a compact
+ * representation of all symbolic information necessary to link to
+ * and properly use the named member.
+ * <p>
+ * When resolved, a member name's internal implementation may include references to JVM metadata.
+ * This representation is stateless and only decriptive.
+ * It provides no private information and no capability to use the member.
+ * <p>
+ * By contrast, a {@linkplain java.lang.reflect.Method} contains fuller information
+ * about the internals of a method (except its bytecodes) and also
+ * allows invocation. A MemberName is much lighter than a Method,
+ * since it contains about 7 fields to the 16 of Method (plus its sub-arrays),
+ * and those seven fields omit much of the information in Method.
+ * @author jrose
+ */
+/*non-public*/ final class MemberName implements Member, Cloneable {
+ private Class<?> clazz; // class in which the method is defined
+ private String name; // may be null if not yet materialized
+ private Object type; // may be null if not yet materialized
+ private int flags; // modifier bits; see reflect.Modifier
+
+ private Object vmtarget; // VM-specific target value
+ private int vmindex; // method index within class or interface
+
+ { vmindex = VM_INDEX_UNINITIALIZED; }
+
+ /** Return the declaring class of this member.
+ * In the case of a bare name and type, the declaring class will be null.
+ */
+ public Class<?> getDeclaringClass() {
+ if (clazz == null && isResolved()) {
+ expandFromVM();
+ }
+ return clazz;
+ }
+
+ /** Utility method producing the class loader of the declaring class. */
+ public ClassLoader getClassLoader() {
+ return clazz.getClassLoader();
+ }
+
+ /** Return the simple name of this member.
+ * For a type, it is the same as {@link Class#getSimpleName}.
+ * For a method or field, it is the simple name of the member.
+ * For a constructor, it is always {@code "<init>"}.
+ */
+ public String getName() {
+ if (name == null) {
+ expandFromVM();
+ if (name == null) return null;
+ }
+ return name;
+ }
+
+ /** Return the declared type of this member, which
+ * must be a method or constructor.
+ */
+ public MethodType getMethodType() {
+ if (type == null) {
+ expandFromVM();
+ if (type == null) return null;
+ }
+ if (!isInvocable())
+ throw newIllegalArgumentException("not invocable, no method type");
+ if (type instanceof MethodType) {
+ return (MethodType) type;
+ }
+ if (type instanceof String) {
+ String sig = (String) type;
+ MethodType res = MethodType.fromMethodDescriptorString(sig, getClassLoader());
+ this.type = res;
+ return res;
+ }
+ if (type instanceof Object[]) {
+ Object[] typeInfo = (Object[]) type;
+ Class<?>[] ptypes = (Class<?>[]) typeInfo[1];
+ Class<?> rtype = (Class<?>) typeInfo[0];
+ MethodType res = MethodType.methodType(rtype, ptypes);
+ this.type = res;
+ return res;
+ }
+ throw new InternalError("bad method type "+type);
+ }
+
+ /** Return the actual type under which this method or constructor must be invoked.
+ * For non-static methods or constructors, this is the type with a leading parameter,
+ * a reference to declaring class. For static methods, it is the same as the declared type.
+ */
+ public MethodType getInvocationType() {
+ MethodType itype = getMethodType();
+ if (!isStatic())
+ itype = itype.insertParameterTypes(0, clazz);
+ return itype;
+ }
+
+ /** Utility method producing the parameter types of the method type. */
+ public Class<?>[] getParameterTypes() {
+ return getMethodType().parameterArray();
+ }
+
+ /** Utility method producing the return type of the method type. */
+ public Class<?> getReturnType() {
+ return getMethodType().returnType();
+ }
+
+ /** Return the declared type of this member, which
+ * must be a field or type.
+ * If it is a type member, that type itself is returned.
+ */
+ public Class<?> getFieldType() {
+ if (type == null) {
+ expandFromVM();
+ if (type == null) return null;
+ }
+ if (isInvocable())
+ throw newIllegalArgumentException("not a field or nested class, no simple type");
+ if (type instanceof Class<?>) {
+ return (Class<?>) type;
+ }
+ if (type instanceof String) {
+ String sig = (String) type;
+ MethodType mtype = MethodType.fromMethodDescriptorString("()"+sig, getClassLoader());
+ Class<?> res = mtype.returnType();
+ this.type = res;
+ return res;
+ }
+ throw new InternalError("bad field type "+type);
+ }
+
+ /** Utility method to produce either the method type or field type of this member. */
+ public Object getType() {
+ return (isInvocable() ? getMethodType() : getFieldType());
+ }
+
+ /** Utility method to produce the signature of this member,
+ * used within the class file format to describe its type.
+ */
+ public String getSignature() {
+ if (type == null) {
+ expandFromVM();
+ if (type == null) return null;
+ }
+ if (type instanceof String)
+ return (String) type;
+ if (isInvocable())
+ return BytecodeDescriptor.unparse(getMethodType());
+ else
+ return BytecodeDescriptor.unparse(getFieldType());
+ }
+
+ /** Return the modifier flags of this member.
+ * @see java.lang.reflect.Modifier
+ */
+ public int getModifiers() {
+ return (flags & RECOGNIZED_MODIFIERS);
+ }
+
+ private void setFlags(int flags) {
+ this.flags = flags;
+ assert(testAnyFlags(ALL_KINDS));
+ }
+
+ private boolean testFlags(int mask, int value) {
+ return (flags & mask) == value;
+ }
+ private boolean testAllFlags(int mask) {
+ return testFlags(mask, mask);
+ }
+ private boolean testAnyFlags(int mask) {
+ return !testFlags(mask, 0);
+ }
+
+ /** Utility method to query the modifier flags of this member. */
+ public boolean isStatic() {
+ return Modifier.isStatic(flags);
+ }
+ /** Utility method to query the modifier flags of this member. */
+ public boolean isPublic() {
+ return Modifier.isPublic(flags);
+ }
+ /** Utility method to query the modifier flags of this member. */
+ public boolean isPrivate() {
+ return Modifier.isPrivate(flags);
+ }
+ /** Utility method to query the modifier flags of this member. */
+ public boolean isProtected() {
+ return Modifier.isProtected(flags);
+ }
+ /** Utility method to query the modifier flags of this member. */
+ public boolean isFinal() {
+ return Modifier.isFinal(flags);
+ }
+ /** Utility method to query the modifier flags of this member. */
+ public boolean isAbstract() {
+ return Modifier.isAbstract(flags);
+ }
+ // let the rest (native, volatile, transient, etc.) be tested via Modifier.isFoo
+
+ // unofficial modifier flags, used by HotSpot:
+ static final int BRIDGE = 0x00000040;
+ static final int VARARGS = 0x00000080;
+ static final int SYNTHETIC = 0x00001000;
+ static final int ANNOTATION= 0x00002000;
+ static final int ENUM = 0x00004000;
+ /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
+ public boolean isBridge() {
+ return testAllFlags(IS_METHOD | BRIDGE);
+ }
+ /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
+ public boolean isVarargs() {
+ return testAllFlags(VARARGS) && isInvocable();
+ }
+ /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
+ public boolean isSynthetic() {
+ return testAllFlags(SYNTHETIC);
+ }
+
+ static final String CONSTRUCTOR_NAME = "<init>"; // the ever-popular
+
+ // modifiers exported by the JVM:
+ static final int RECOGNIZED_MODIFIERS = 0xFFFF;
+
+ // private flags, not part of RECOGNIZED_MODIFIERS:
+ static final int
+ IS_METHOD = MN_IS_METHOD, // method (not constructor)
+ IS_CONSTRUCTOR = MN_IS_CONSTRUCTOR, // constructor
+ IS_FIELD = MN_IS_FIELD, // field
+ IS_TYPE = MN_IS_TYPE; // nested type
+ static final int // for MethodHandleNatives.getMembers
+ SEARCH_SUPERCLASSES = MN_SEARCH_SUPERCLASSES,
+ SEARCH_INTERFACES = MN_SEARCH_INTERFACES;
+
+ static final int ALL_ACCESS = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED;
+ static final int ALL_KINDS = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE;
+ static final int IS_INVOCABLE = IS_METHOD | IS_CONSTRUCTOR;
+ static final int IS_FIELD_OR_METHOD = IS_METHOD | IS_FIELD;
+ static final int SEARCH_ALL_SUPERS = SEARCH_SUPERCLASSES | SEARCH_INTERFACES;
+
+ /** Utility method to query whether this member is a method or constructor. */
+ public boolean isInvocable() {
+ return testAnyFlags(IS_INVOCABLE);
+ }
+ /** Utility method to query whether this member is a method, constructor, or field. */
+ public boolean isFieldOrMethod() {
+ return testAnyFlags(IS_FIELD_OR_METHOD);
+ }
+ /** Query whether this member is a method. */
+ public boolean isMethod() {
+ return testAllFlags(IS_METHOD);
+ }
+ /** Query whether this member is a constructor. */
+ public boolean isConstructor() {
+ return testAllFlags(IS_CONSTRUCTOR);
+ }
+ /** Query whether this member is a field. */
+ public boolean isField() {
+ return testAllFlags(IS_FIELD);
+ }
+ /** Query whether this member is a type. */
+ public boolean isType() {
+ return testAllFlags(IS_TYPE);
+ }
+ /** Utility method to query whether this member is neither public, private, nor protected. */
+ public boolean isPackage() {
+ return !testAnyFlags(ALL_ACCESS);
+ }
+
+ /** Initialize a query. It is not resolved. */
+ private void init(Class<?> defClass, String name, Object type, int flags) {
+ // defining class is allowed to be null (for a naked name/type pair)
+ //name.toString(); // null check
+ //type.equals(type); // null check
+ // fill in fields:
+ this.clazz = defClass;
+ this.name = name;
+ this.type = type;
+ setFlags(flags);
+ assert(!isResolved());
+ }
+
+ private void expandFromVM() {
+ if (!isResolved()) return;
+ if (type instanceof Object[])
+ type = null; // don't saddle JVM w/ typeInfo
+ MethodHandleNatives.expand(this);
+ }
+
+ // Capturing information from the Core Reflection API:
+ private static int flagsMods(int flags, int mods) {
+ assert((flags & RECOGNIZED_MODIFIERS) == 0);
+ assert((mods & ~RECOGNIZED_MODIFIERS) == 0);
+ return flags | mods;
+ }
+ /** Create a name for the given reflected method. The resulting name will be in a resolved state. */
+ public MemberName(Method m) {
+ Object[] typeInfo = { m.getReturnType(), m.getParameterTypes() };
+ init(m.getDeclaringClass(), m.getName(), typeInfo, flagsMods(IS_METHOD, m.getModifiers()));
+ // fill in vmtarget, vmindex while we have m in hand:
+ MethodHandleNatives.init(this, m);
+ assert(isResolved());
+ }
+ /** Create a name for the given reflected constructor. The resulting name will be in a resolved state. */
+ public MemberName(Constructor ctor) {
+ Object[] typeInfo = { void.class, ctor.getParameterTypes() };
+ init(ctor.getDeclaringClass(), CONSTRUCTOR_NAME, typeInfo, flagsMods(IS_CONSTRUCTOR, ctor.getModifiers()));
+ // fill in vmtarget, vmindex while we have ctor in hand:
+ MethodHandleNatives.init(this, ctor);
+ assert(isResolved());
+ }
+ /** Create a name for the given reflected field. The resulting name will be in a resolved state. */
+ public MemberName(Field fld) {
+ init(fld.getDeclaringClass(), fld.getName(), fld.getType(), flagsMods(IS_FIELD, fld.getModifiers()));
+ // fill in vmtarget, vmindex while we have fld in hand:
+ MethodHandleNatives.init(this, fld);
+ assert(isResolved());
+ }
+ /** Create a name for the given class. The resulting name will be in a resolved state. */
+ public MemberName(Class<?> type) {
+ init(type.getDeclaringClass(), type.getSimpleName(), type, flagsMods(IS_TYPE, type.getModifiers()));
+ vmindex = 0; // isResolved
+ assert(isResolved());
+ }
+
+ // bare-bones constructor; the JVM will fill it in
+ MemberName() { }
+
+ // locally useful cloner
+ @Override protected MemberName clone() {
+ try {
+ return (MemberName) super.clone();
+ } catch (CloneNotSupportedException ex) {
+ throw new InternalError();
+ }
+ }
+
+ // %%% define equals/hashcode?
+
+ // Construction from symbolic parts, for queries:
+ /** Create a field or type name from the given components: Declaring class, name, type, modifiers.
+ * The declaring class may be supplied as null if this is to be a bare name and type.
+ * The resulting name will in an unresolved state.
+ */
+ public MemberName(Class<?> defClass, String name, Class<?> type, int modifiers) {
+ init(defClass, name, type, IS_FIELD | (modifiers & RECOGNIZED_MODIFIERS));
+ }
+ /** Create a field or type name from the given components: Declaring class, name, type.
+ * The declaring class may be supplied as null if this is to be a bare name and type.
+ * The modifier flags default to zero.
+ * The resulting name will in an unresolved state.
+ */
+ public MemberName(Class<?> defClass, String name, Class<?> type) {
+ this(defClass, name, type, 0);
+ }
+ /** Create a method or constructor name from the given components: Declaring class, name, type, modifiers.
+ * It will be a constructor if and only if the name is {@code "<init>"}.
+ * The declaring class may be supplied as null if this is to be a bare name and type.
+ * The resulting name will in an unresolved state.
+ */
+ public MemberName(Class<?> defClass, String name, MethodType type, int modifiers) {
+ int flagBit = (name.equals(CONSTRUCTOR_NAME) ? IS_CONSTRUCTOR : IS_METHOD);
+ init(defClass, name, type, flagBit | (modifiers & RECOGNIZED_MODIFIERS));
+ }
+ /** Create a method or constructor name from the given components: Declaring class, name, type, modifiers.
+ * It will be a constructor if and only if the name is {@code "<init>"}.
+ * The declaring class may be supplied as null if this is to be a bare name and type.
+ * The modifier flags default to zero.
+ * The resulting name will in an unresolved state.
+ */
+ public MemberName(Class<?> defClass, String name, MethodType type) {
+ this(defClass, name, type, 0);
+ }
+
+ /** Query whether this member name is resolved.
+ * A resolved member name is one for which the JVM has found
+ * a method, constructor, field, or type binding corresponding exactly to the name.
+ * (Document?)
+ */
+ public boolean isResolved() {
+ return (vmindex != VM_INDEX_UNINITIALIZED);
+ }
+
+ /** Query whether this member name is resolved to a non-static, non-final method.
+ */
+ public boolean hasReceiverTypeDispatch() {
+ return (isMethod() && getVMIndex() >= 0);
+ }
+
+ /** Produce a string form of this member name.
+ * For types, it is simply the type's own string (as reported by {@code toString}).
+ * For fields, it is {@code "DeclaringClass.name/type"}.
+ * For methods and constructors, it is {@code "DeclaringClass.name(ptype...)rtype"}.
+ * If the declaring class is null, the prefix {@code "DeclaringClass."} is omitted.
+ * If the member is unresolved, a prefix {@code "*."} is prepended.
+ */
+ @Override
+ public String toString() {
+ if (isType())
+ return type.toString(); // class java.lang.String
+ // else it is a field, method, or constructor
+ StringBuilder buf = new StringBuilder();
+ if (getDeclaringClass() != null) {
+ buf.append(getName(clazz));
+ buf.append('.');
+ }
+ String name = getName();
+ buf.append(name == null ? "*" : name);
+ Object type = getType();
+ if (!isInvocable()) {
+ buf.append('/');
+ buf.append(type == null ? "*" : getName(type));
+ } else {
+ buf.append(type == null ? "(*)*" : getName(type));
+ }
+ /*
+ buf.append('/');
+ // key: Public, private, pRotected, sTatic, Final, sYnchronized,
+ // transient/Varargs, native, (interface), abstract, sTrict, sYnthetic,
+ // (annotation), Enum, (unused)
+ final String FIELD_MOD_CHARS = "PprTF?vt????Y?E?";
+ final String METHOD_MOD_CHARS = "PprTFybVn?atY???";
+ String modChars = (isInvocable() ? METHOD_MOD_CHARS : FIELD_MOD_CHARS);
+ for (int i = 0; i < modChars.length(); i++) {
+ if ((flags & (1 << i)) != 0) {
+ char mc = modChars.charAt(i);
+ if (mc != '?')
+ buf.append(mc);
+ }
+ }
+ */
+ return buf.toString();
+ }
+ private static String getName(Object obj) {
+ if (obj instanceof Class<?>)
+ return ((Class<?>)obj).getName();
+ return String.valueOf(obj);
+ }
+
+ // Queries to the JVM:
+ /** Document? */
+ /*non-public*/ int getVMIndex() {
+ if (!isResolved())
+ throw newIllegalStateException("not resolved", this);
+ return vmindex;
+ }
+// /*non-public*/ Object getVMTarget() {
+// if (!isResolved())
+// throw newIllegalStateException("not resolved", this);
+// return vmtarget;
+// }
+
+ public IllegalAccessException makeAccessException(String message, Object from) {
+ message = message + ": "+ toString();
+ if (from != null) message += ", from " + from;
+ return new IllegalAccessException(message);
+ }
+ public ReflectiveOperationException makeAccessException(String message) {
+ message = message + ": "+ toString();
+ if (isResolved())
+ return new IllegalAccessException(message);
+ else if (isConstructor())
+ return new NoSuchMethodException(message);
+ else if (isMethod())
+ return new NoSuchMethodException(message);
+ else
+ return new NoSuchFieldException(message);
+ }
+
+ /** Actually making a query requires an access check. */
+ /*non-public*/ static Factory getFactory() {
+ return Factory.INSTANCE;
+ }
+ /** A factory type for resolving member names with the help of the VM.
+ * TBD: Define access-safe public constructors for this factory.
+ */
+ public static class Factory {
+ private Factory() { } // singleton pattern
+ static Factory INSTANCE = new Factory();
+
+ private static int ALLOWED_FLAGS = SEARCH_ALL_SUPERS | ALL_KINDS;
+
+ /// Queries
+ List<MemberName> getMembers(Class<?> defc,
+ String matchName, Object matchType,
+ int matchFlags, Class<?> lookupClass) {
+ matchFlags &= ALLOWED_FLAGS;
+ String matchSig = null;
+ if (matchType != null) {
+ matchSig = BytecodeDescriptor.unparse(matchType);
+ if (matchSig.startsWith("("))
+ matchFlags &= ~(ALL_KINDS & ~IS_INVOCABLE);
+ else
+ matchFlags &= ~(ALL_KINDS & ~IS_FIELD);
+ }
+ final int BUF_MAX = 0x2000;
+ int len1 = matchName == null ? 10 : matchType == null ? 4 : 1;
+ MemberName[] buf = newMemberBuffer(len1);
+ int totalCount = 0;
+ ArrayList<MemberName[]> bufs = null;
+ int bufCount = 0;
+ for (;;) {
+ bufCount = MethodHandleNatives.getMembers(defc,
+ matchName, matchSig, matchFlags,
+ lookupClass,
+ totalCount, buf);
+ if (bufCount <= buf.length) {
+ if (bufCount < 0) bufCount = 0;
+ totalCount += bufCount;
+ break;
+ }
+ // JVM returned to us with an intentional overflow!
+ totalCount += buf.length;
+ int excess = bufCount - buf.length;
+ if (bufs == null) bufs = new ArrayList<MemberName[]>(1);
+ bufs.add(buf);
+ int len2 = buf.length;
+ len2 = Math.max(len2, excess);
+ len2 = Math.max(len2, totalCount / 4);
+ buf = newMemberBuffer(Math.min(BUF_MAX, len2));
+ }
+ ArrayList<MemberName> result = new ArrayList<MemberName>(totalCount);
+ if (bufs != null) {
+ for (MemberName[] buf0 : bufs) {
+ Collections.addAll(result, buf0);
+ }
+ }
+ result.addAll(Arrays.asList(buf).subList(0, bufCount));
+ // Signature matching is not the same as type matching, since
+ // one signature might correspond to several types.
+ // So if matchType is a Class or MethodType, refilter the results.
+ if (matchType != null && matchType != matchSig) {
+ for (Iterator<MemberName> it = result.iterator(); it.hasNext();) {
+ MemberName m = it.next();
+ if (!matchType.equals(m.getType()))
+ it.remove();
+ }
+ }
+ return result;
+ }
+ boolean resolveInPlace(MemberName m, boolean searchSupers, Class<?> lookupClass) {
+ if (m.name == null || m.type == null) { // find unique non-overloaded name
+ Class<?> defc = m.getDeclaringClass();
+ List<MemberName> choices = null;
+ if (m.isMethod())
+ choices = getMethods(defc, searchSupers, m.name, (MethodType) m.type, lookupClass);
+ else if (m.isConstructor())
+ choices = getConstructors(defc, lookupClass);
+ else if (m.isField())
+ choices = getFields(defc, searchSupers, m.name, (Class<?>) m.type, lookupClass);
+ //System.out.println("resolving "+m+" to "+choices);
+ if (choices == null || choices.size() != 1)
+ return false;
+ if (m.name == null) m.name = choices.get(0).name;
+ if (m.type == null) m.type = choices.get(0).type;
+ }
+ MethodHandleNatives.resolve(m, lookupClass);
+ if (m.isResolved()) return true;
+ int matchFlags = m.flags | (searchSupers ? SEARCH_ALL_SUPERS : 0);
+ String matchSig = m.getSignature();
+ MemberName[] buf = { m };
+ int n = MethodHandleNatives.getMembers(m.getDeclaringClass(),
+ m.getName(), matchSig, matchFlags, lookupClass, 0, buf);
+ if (n != 1) return false;
+ return m.isResolved();
+ }
+ /** Produce a resolved version of the given member.
+ * Super types are searched (for inherited members) if {@code searchSupers} is true.
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * If lookup fails or access is not permitted, null is returned.
+ * Otherwise a fresh copy of the given member is returned, with modifier bits filled in.
+ */
+ public MemberName resolveOrNull(MemberName m, boolean searchSupers, Class<?> lookupClass) {
+ MemberName result = m.clone();
+ if (resolveInPlace(result, searchSupers, lookupClass))
+ return result;
+ return null;
+ }
+ /** Produce a resolved version of the given member.
+ * Super types are searched (for inherited members) if {@code searchSupers} is true.
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * If lookup fails or access is not permitted, a {@linkplain ReflectiveOperationException} is thrown.
+ * Otherwise a fresh copy of the given member is returned, with modifier bits filled in.
+ */
+ public
+ <NoSuchMemberException extends ReflectiveOperationException>
+ MemberName resolveOrFail(MemberName m, boolean searchSupers, Class<?> lookupClass,
+ Class<NoSuchMemberException> nsmClass)
+ throws IllegalAccessException, NoSuchMemberException {
+ MemberName result = resolveOrNull(m, searchSupers, lookupClass);
+ if (result != null)
+ return result;
+ ReflectiveOperationException ex = m.makeAccessException("no access");
+ if (ex instanceof IllegalAccessException) throw (IllegalAccessException) ex;
+ throw nsmClass.cast(ex);
+ }
+ /** Return a list of all methods defined by the given class.
+ * Super types are searched (for inherited members) if {@code searchSupers} is true.
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * Inaccessible members are not added to the last.
+ */
+ public List<MemberName> getMethods(Class<?> defc, boolean searchSupers,
+ Class<?> lookupClass) {
+ return getMethods(defc, searchSupers, null, null, lookupClass);
+ }
+ /** Return a list of matching methods defined by the given class.
+ * Super types are searched (for inherited members) if {@code searchSupers} is true.
+ * Returned methods will match the name (if not null) and the type (if not null).
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * Inaccessible members are not added to the last.
+ */
+ public List<MemberName> getMethods(Class<?> defc, boolean searchSupers,
+ String name, MethodType type, Class<?> lookupClass) {
+ int matchFlags = IS_METHOD | (searchSupers ? SEARCH_ALL_SUPERS : 0);
+ return getMembers(defc, name, type, matchFlags, lookupClass);
+ }
+ /** Return a list of all constructors defined by the given class.
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * Inaccessible members are not added to the last.
+ */
+ public List<MemberName> getConstructors(Class<?> defc, Class<?> lookupClass) {
+ return getMembers(defc, null, null, IS_CONSTRUCTOR, lookupClass);
+ }
+ /** Return a list of all fields defined by the given class.
+ * Super types are searched (for inherited members) if {@code searchSupers} is true.
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * Inaccessible members are not added to the last.
+ */
+ public List<MemberName> getFields(Class<?> defc, boolean searchSupers,
+ Class<?> lookupClass) {
+ return getFields(defc, searchSupers, null, null, lookupClass);
+ }
+ /** Return a list of all fields defined by the given class.
+ * Super types are searched (for inherited members) if {@code searchSupers} is true.
+ * Returned fields will match the name (if not null) and the type (if not null).
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * Inaccessible members are not added to the last.
+ */
+ public List<MemberName> getFields(Class<?> defc, boolean searchSupers,
+ String name, Class<?> type, Class<?> lookupClass) {
+ int matchFlags = IS_FIELD | (searchSupers ? SEARCH_ALL_SUPERS : 0);
+ return getMembers(defc, name, type, matchFlags, lookupClass);
+ }
+ /** Return a list of all nested types defined by the given class.
+ * Super types are searched (for inherited members) if {@code searchSupers} is true.
+ * Access checking is performed on behalf of the given {@code lookupClass}.
+ * Inaccessible members are not added to the last.
+ */
+ public List<MemberName> getNestedTypes(Class<?> defc, boolean searchSupers,
+ Class<?> lookupClass) {
+ int matchFlags = IS_TYPE | (searchSupers ? SEARCH_ALL_SUPERS : 0);
+ return getMembers(defc, null, null, matchFlags, lookupClass);
+ }
+ private static MemberName[] newMemberBuffer(int length) {
+ MemberName[] buf = new MemberName[length];
+ // fill the buffer with dummy structs for the JVM to fill in
+ for (int i = 0; i < length; i++)
+ buf[i] = new MemberName();
+ return buf;
+ }
+ }
+
+// static {
+// System.out.println("Hello world! My methods are:");
+// System.out.println(Factory.INSTANCE.getMethods(MemberName.class, true, null));
+// }
+}
--- a/jdk/src/share/classes/java/dyn/MethodHandle.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/MethodHandle.java Fri Mar 18 00:03:24 2011 -0700
@@ -25,13 +25,8 @@
package java.dyn;
-//import sun.dyn.*;
-import sun.dyn.Access;
-import sun.dyn.MethodHandleImpl;
-
-import static java.dyn.MethodHandles.invokers; // package-private API
-import static sun.dyn.MemberName.newIllegalArgumentException; // utility
+import static java.dyn.MethodHandleStatics.*;
/**
* A method handle is a typed, directly executable reference to an underlying method,
@@ -436,12 +431,35 @@
* @see MethodHandles
* @author John Rose, JSR 292 EG
*/
-public abstract class MethodHandle
- // Note: This is an implementation inheritance hack, and will be removed
- // with a JVM change which moves the required hidden state onto this class.
- extends MethodHandleImpl
-{
- private static Access IMPL_TOKEN = Access.getToken();
+public abstract class MethodHandle {
+ // { JVM internals:
+
+ private byte vmentry; // adapter stub or method entry point
+ //private int vmslots; // optionally, hoist type.form.vmslots
+ /*non-public*/ Object vmtarget; // VM-specific, class-specific target value
+
+ // TO DO: vmtarget should be invisible to Java, since the JVM puts internal
+ // managed pointers into it. Making it visible exposes it to debuggers,
+ // which can cause errors when they treat the pointer as an Object.
+
+ // These two dummy fields are present to force 'I' and 'J' signatures
+ // into this class's constant pool, so they can be transferred
+ // to vmentry when this class is loaded.
+ static final int INT_FIELD = 0;
+ static final long LONG_FIELD = 0;
+
+ // vmentry (a void* field) is used *only* by the JVM.
+ // The JVM adjusts its type to int or long depending on system wordsize.
+ // Since it is statically typed as neither int nor long, it is impossible
+ // to use this field from Java bytecode. (Please don't try to, either.)
+
+ // The vmentry is an assembly-language stub which is jumped to
+ // immediately after the method type is verified.
+ // For a direct MH, this stub loads the vmtarget's entry point
+ // and jumps to it.
+
+ // } End of JVM internals.
+
static { MethodHandleImpl.initStatics(); }
// interface MethodHandle<R throws X extends Exception,A...>
@@ -467,37 +485,16 @@
}
/**
- * <em>CONSTRUCTOR WILL BE REMOVED FOR PFD:</em>
- * Temporary constructor in early versions of the Reference Implementation.
- * Method handle inheritance (if any) will be contained completely within
+ * Package-private constructor for the method handle implementation hierarchy.
+ * Method handle inheritance will be contained completely within
* the {@code java.dyn} package.
*/
- // The constructor for MethodHandle may only be called by privileged code.
- // Subclasses may be in other packages, but must possess
- // a token which they obtained from MH with a security check.
- // @param token non-null object which proves access permission
// @param type type (permanently assigned) of the new method handle
- protected MethodHandle(Access token, MethodType type) {
- super(token);
- Access.check(token);
+ /*non-public*/ MethodHandle(MethodType type) {
+ type.getClass(); // elicit NPE
this.type = type;
}
- private void initType(MethodType type) {
- type.getClass(); // elicit NPE
- if (this.type != null) throw new InternalError();
- this.type = type;
- }
-
- static {
- // This hack allows the implementation package special access to
- // the internals of MethodHandle. In particular, the MTImpl has all sorts
- // of cached information useful to the implementation code.
- MethodHandleImpl.setMethodHandleFriend(IMPL_TOKEN, new MethodHandleImpl.MethodHandleFriend() {
- public void initType(MethodHandle mh, MethodType type) { mh.initType(type); }
- });
- }
-
/**
* Invoke the method handle, allowing any caller type descriptor, but requiring an exact type match.
* The type descriptor at the call site of {@code invokeExact} must
@@ -608,7 +605,7 @@
return asType(MethodType.genericMethodType(argc)).invokeWithArguments(arguments);
}
if (argc <= 10) {
- MethodHandle invoker = invokers(type).genericInvoker();
+ MethodHandle invoker = type.invokers().genericInvoker();
switch (argc) {
case 0: return invoker.invokeExact(this);
case 1: return invoker.invokeExact(this,
@@ -647,7 +644,7 @@
}
// more than ten arguments get boxed in a varargs list:
- MethodHandle invoker = invokers(type).spreadInvoker(0);
+ MethodHandle invoker = type.invokers().spreadInvoker(0);
return invoker.invokeExact(this, arguments);
}
/** Equivalent to {@code invokeWithArguments(arguments.toArray())}. */
@@ -1004,6 +1001,6 @@
*/
@Override
public String toString() {
- return MethodHandleImpl.getNameString(IMPL_TOKEN, this);
+ return getNameString(this);
}
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/MethodHandleImpl.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,1106 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.util.VerifyType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import sun.dyn.empty.Empty;
+import sun.dyn.util.ValueConversions;
+import sun.dyn.util.Wrapper;
+import sun.misc.Unsafe;
+import static java.dyn.MethodHandleStatics.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * Trusted implementation code for MethodHandle.
+ * @author jrose
+ */
+/*non-public*/ abstract class MethodHandleImpl {
+ /// Factory methods to create method handles:
+
+ private static final MemberName.Factory LOOKUP = MemberName.Factory.INSTANCE;
+
+ static void initStatics() {
+ // Trigger preceding sequence.
+ }
+
+ /** Look up a given method.
+ * Callable only from java.dyn and related packages.
+ * <p>
+ * The resulting method handle type will be of the given type,
+ * with a receiver type {@code rcvc} prepended if the member is not static.
+ * <p>
+ * Access checks are made as of the given lookup class.
+ * In particular, if the method is protected and {@code defc} is in a
+ * different package from the lookup class, then {@code rcvc} must be
+ * the lookup class or a subclass.
+ * @param token Proof that the lookup class has access to this package.
+ * @param member Resolved method or constructor to call.
+ * @param name Name of the desired method.
+ * @param rcvc Receiver type of desired non-static method (else null)
+ * @param doDispatch whether the method handle will test the receiver type
+ * @param lookupClass access-check relative to this class
+ * @return a direct handle to the matching method
+ * @throws IllegalAccessException if the given method cannot be accessed by the lookup class
+ */
+ static
+ MethodHandle findMethod(MemberName method,
+ boolean doDispatch, Class<?> lookupClass) throws IllegalAccessException {
+ MethodType mtype = method.getMethodType();
+ if (!method.isStatic()) {
+ // adjust the advertised receiver type to be exactly the one requested
+ // (in the case of invokespecial, this will be the calling class)
+ Class<?> recvType = method.getDeclaringClass();
+ mtype = mtype.insertParameterTypes(0, recvType);
+ }
+ DirectMethodHandle mh = new DirectMethodHandle(mtype, method, doDispatch, lookupClass);
+ if (!mh.isValid())
+ throw method.makeAccessException("no access", lookupClass);
+ assert(mh.type() == mtype);
+ if (!method.isVarargs())
+ return mh;
+ else
+ return mh.asVarargsCollector(mtype.parameterType(mtype.parameterCount()-1));
+ }
+
+ static
+ MethodHandle makeAllocator(MethodHandle rawConstructor) {
+ MethodType rawConType = rawConstructor.type();
+ // Wrap the raw (unsafe) constructor with the allocation of a suitable object.
+ MethodHandle allocator
+ = AllocateObject.make(rawConType.parameterType(0), rawConstructor);
+ assert(allocator.type()
+ .equals(rawConType.dropParameterTypes(0, 1).changeReturnType(rawConType.parameterType(0))));
+ return allocator;
+ }
+
+ static final class AllocateObject<C> extends BoundMethodHandle {
+ private static final Unsafe unsafe = Unsafe.getUnsafe();
+
+ private final Class<C> allocateClass;
+ private final MethodHandle rawConstructor;
+
+ private AllocateObject(MethodHandle invoker,
+ Class<C> allocateClass, MethodHandle rawConstructor) {
+ super(invoker);
+ this.allocateClass = allocateClass;
+ this.rawConstructor = rawConstructor;
+ }
+ static MethodHandle make(Class<?> allocateClass, MethodHandle rawConstructor) {
+ MethodType rawConType = rawConstructor.type();
+ assert(rawConType.parameterType(0) == allocateClass);
+ MethodType newType = rawConType.dropParameterTypes(0, 1).changeReturnType(allocateClass);
+ int nargs = rawConType.parameterCount() - 1;
+ if (nargs < INVOKES.length) {
+ MethodHandle invoke = INVOKES[nargs];
+ MethodType conType = CON_TYPES[nargs];
+ MethodHandle gcon = convertArguments(rawConstructor, conType, rawConType, null);
+ if (gcon == null) return null;
+ MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);
+ assert(galloc.type() == newType.generic());
+ return convertArguments(galloc, newType, galloc.type(), null);
+ } else {
+ MethodHandle invoke = VARARGS_INVOKE;
+ MethodType conType = CON_TYPES[nargs];
+ MethodHandle gcon = spreadArguments(rawConstructor, conType, 1);
+ if (gcon == null) return null;
+ MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);
+ return collectArguments(galloc, newType, 1, null);
+ }
+ }
+ @Override
+ public String toString() {
+ return addTypeString(allocateClass.getSimpleName(), this);
+ }
+ @SuppressWarnings("unchecked")
+ private C allocate() throws InstantiationException {
+ return (C) unsafe.allocateInstance(allocateClass);
+ }
+ private C invoke_V(Object... av) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, av);
+ return obj;
+ }
+ private C invoke_L0() throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj);
+ return obj;
+ }
+ private C invoke_L1(Object a0) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0);
+ return obj;
+ }
+ private C invoke_L2(Object a0, Object a1) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0, a1);
+ return obj;
+ }
+ private C invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0, a1, a2);
+ return obj;
+ }
+ private C invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3);
+ return obj;
+ }
+ private C invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4);
+ return obj;
+ }
+ private C invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5);
+ return obj;
+ }
+ private C invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6);
+ return obj;
+ }
+ private C invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ C obj = allocate();
+ rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6, a7);
+ return obj;
+ }
+ static MethodHandle[] makeInvokes() {
+ ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
+ MethodHandles.Lookup lookup = IMPL_LOOKUP;
+ for (;;) {
+ int nargs = invokes.size();
+ String name = "invoke_L"+nargs;
+ MethodHandle invoke = null;
+ try {
+ invoke = lookup.findVirtual(AllocateObject.class, name, MethodType.genericMethodType(nargs));
+ } catch (ReflectiveOperationException ex) {
+ }
+ if (invoke == null) break;
+ invokes.add(invoke);
+ }
+ assert(invokes.size() == 9); // current number of methods
+ return invokes.toArray(new MethodHandle[0]);
+ };
+ static final MethodHandle[] INVOKES = makeInvokes();
+ // For testing use this:
+ //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
+ static final MethodHandle VARARGS_INVOKE;
+ static {
+ try {
+ VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(AllocateObject.class, "invoke_V", MethodType.genericMethodType(0, true));
+ } catch (ReflectiveOperationException ex) {
+ throw uncaughtException(ex);
+ }
+ }
+ // Corresponding generic constructor types:
+ static final MethodType[] CON_TYPES = new MethodType[INVOKES.length];
+ static {
+ for (int i = 0; i < INVOKES.length; i++)
+ CON_TYPES[i] = makeConType(INVOKES[i]);
+ }
+ static final MethodType VARARGS_CON_TYPE = makeConType(VARARGS_INVOKE);
+ static MethodType makeConType(MethodHandle invoke) {
+ MethodType invType = invoke.type();
+ return invType.changeParameterType(0, Object.class).changeReturnType(void.class);
+ }
+ }
+
+ static
+ MethodHandle accessField(MemberName member, boolean isSetter,
+ Class<?> lookupClass) {
+ // Use sun. misc.Unsafe to dig up the dirt on the field.
+ MethodHandle mh = new FieldAccessor(member, isSetter);
+ return mh;
+ }
+
+ static
+ MethodHandle accessArrayElement(Class<?> arrayClass, boolean isSetter) {
+ if (!arrayClass.isArray())
+ throw newIllegalArgumentException("not an array: "+arrayClass);
+ Class<?> elemClass = arrayClass.getComponentType();
+ MethodHandle[] mhs = FieldAccessor.ARRAY_CACHE.get(elemClass);
+ if (mhs == null) {
+ if (!FieldAccessor.doCache(elemClass))
+ return FieldAccessor.ahandle(arrayClass, isSetter);
+ mhs = new MethodHandle[] {
+ FieldAccessor.ahandle(arrayClass, false),
+ FieldAccessor.ahandle(arrayClass, true)
+ };
+ if (mhs[0].type().parameterType(0) == Class.class) {
+ mhs[0] = MethodHandles.insertArguments(mhs[0], 0, elemClass);
+ mhs[1] = MethodHandles.insertArguments(mhs[1], 0, elemClass);
+ }
+ synchronized (FieldAccessor.ARRAY_CACHE) {} // memory barrier
+ FieldAccessor.ARRAY_CACHE.put(elemClass, mhs);
+ }
+ return mhs[isSetter ? 1 : 0];
+ }
+
+ static final class FieldAccessor<C,V> extends BoundMethodHandle {
+ private static final Unsafe unsafe = Unsafe.getUnsafe();
+ final Object base; // for static refs only
+ final long offset;
+ final String name;
+
+ FieldAccessor(MemberName field, boolean isSetter) {
+ super(fhandle(field.getDeclaringClass(), field.getFieldType(), isSetter, field.isStatic()));
+ this.offset = (long) field.getVMIndex();
+ this.name = field.getName();
+ this.base = staticBase(field);
+ }
+ @Override
+ public String toString() { return addTypeString(name, this); }
+
+ int getFieldI(C obj) { return unsafe.getInt(obj, offset); }
+ void setFieldI(C obj, int x) { unsafe.putInt(obj, offset, x); }
+ long getFieldJ(C obj) { return unsafe.getLong(obj, offset); }
+ void setFieldJ(C obj, long x) { unsafe.putLong(obj, offset, x); }
+ float getFieldF(C obj) { return unsafe.getFloat(obj, offset); }
+ void setFieldF(C obj, float x) { unsafe.putFloat(obj, offset, x); }
+ double getFieldD(C obj) { return unsafe.getDouble(obj, offset); }
+ void setFieldD(C obj, double x) { unsafe.putDouble(obj, offset, x); }
+ boolean getFieldZ(C obj) { return unsafe.getBoolean(obj, offset); }
+ void setFieldZ(C obj, boolean x) { unsafe.putBoolean(obj, offset, x); }
+ byte getFieldB(C obj) { return unsafe.getByte(obj, offset); }
+ void setFieldB(C obj, byte x) { unsafe.putByte(obj, offset, x); }
+ short getFieldS(C obj) { return unsafe.getShort(obj, offset); }
+ void setFieldS(C obj, short x) { unsafe.putShort(obj, offset, x); }
+ char getFieldC(C obj) { return unsafe.getChar(obj, offset); }
+ void setFieldC(C obj, char x) { unsafe.putChar(obj, offset, x); }
+ @SuppressWarnings("unchecked")
+ V getFieldL(C obj) { return (V) unsafe.getObject(obj, offset); }
+ @SuppressWarnings("unchecked")
+ void setFieldL(C obj, V x) { unsafe.putObject(obj, offset, x); }
+ // cast (V) is OK here, since we wrap convertArguments around the MH.
+
+ static Object staticBase(MemberName field) {
+ if (!field.isStatic()) return null;
+ Class c = field.getDeclaringClass();
+ java.lang.reflect.Field f;
+ try {
+ // FIXME: Should not have to create 'f' to get this value.
+ f = c.getDeclaredField(field.getName());
+ return unsafe.staticFieldBase(f);
+ } catch (Exception ee) {
+ throw uncaughtException(ee);
+ }
+ }
+
+ int getStaticI() { return unsafe.getInt(base, offset); }
+ void setStaticI(int x) { unsafe.putInt(base, offset, x); }
+ long getStaticJ() { return unsafe.getLong(base, offset); }
+ void setStaticJ(long x) { unsafe.putLong(base, offset, x); }
+ float getStaticF() { return unsafe.getFloat(base, offset); }
+ void setStaticF(float x) { unsafe.putFloat(base, offset, x); }
+ double getStaticD() { return unsafe.getDouble(base, offset); }
+ void setStaticD(double x) { unsafe.putDouble(base, offset, x); }
+ boolean getStaticZ() { return unsafe.getBoolean(base, offset); }
+ void setStaticZ(boolean x) { unsafe.putBoolean(base, offset, x); }
+ byte getStaticB() { return unsafe.getByte(base, offset); }
+ void setStaticB(byte x) { unsafe.putByte(base, offset, x); }
+ short getStaticS() { return unsafe.getShort(base, offset); }
+ void setStaticS(short x) { unsafe.putShort(base, offset, x); }
+ char getStaticC() { return unsafe.getChar(base, offset); }
+ void setStaticC(char x) { unsafe.putChar(base, offset, x); }
+ V getStaticL() { return (V) unsafe.getObject(base, offset); }
+ void setStaticL(V x) { unsafe.putObject(base, offset, x); }
+
+ static String fname(Class<?> vclass, boolean isSetter, boolean isStatic) {
+ String stem;
+ if (!isStatic)
+ stem = (!isSetter ? "getField" : "setField");
+ else
+ stem = (!isSetter ? "getStatic" : "setStatic");
+ return stem + Wrapper.basicTypeChar(vclass);
+ }
+ static MethodType ftype(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {
+ MethodType type;
+ if (!isStatic) {
+ if (!isSetter)
+ return MethodType.methodType(vclass, cclass);
+ else
+ return MethodType.methodType(void.class, cclass, vclass);
+ } else {
+ if (!isSetter)
+ return MethodType.methodType(vclass);
+ else
+ return MethodType.methodType(void.class, vclass);
+ }
+ }
+ static MethodHandle fhandle(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {
+ String name = FieldAccessor.fname(vclass, isSetter, isStatic);
+ if (cclass.isPrimitive()) throw newIllegalArgumentException("primitive "+cclass);
+ Class<?> ecclass = Object.class; //erase this type
+ Class<?> evclass = vclass;
+ if (!evclass.isPrimitive()) evclass = Object.class;
+ MethodType type = FieldAccessor.ftype(ecclass, evclass, isSetter, isStatic);
+ MethodHandle mh;
+ try {
+ mh = IMPL_LOOKUP.findVirtual(FieldAccessor.class, name, type);
+ } catch (ReflectiveOperationException ex) {
+ throw uncaughtException(ex);
+ }
+ if (evclass != vclass || (!isStatic && ecclass != cclass)) {
+ MethodType strongType = FieldAccessor.ftype(cclass, vclass, isSetter, isStatic);
+ strongType = strongType.insertParameterTypes(0, FieldAccessor.class);
+ mh = MethodHandles.convertArguments(mh, strongType);
+ }
+ return mh;
+ }
+
+ /// Support for array element access
+ static final HashMap<Class<?>, MethodHandle[]> ARRAY_CACHE =
+ new HashMap<Class<?>, MethodHandle[]>();
+ // FIXME: Cache on the classes themselves, not here.
+ static boolean doCache(Class<?> elemClass) {
+ if (elemClass.isPrimitive()) return true;
+ ClassLoader cl = elemClass.getClassLoader();
+ return cl == null || cl == ClassLoader.getSystemClassLoader();
+ }
+ static int getElementI(int[] a, int i) { return a[i]; }
+ static void setElementI(int[] a, int i, int x) { a[i] = x; }
+ static long getElementJ(long[] a, int i) { return a[i]; }
+ static void setElementJ(long[] a, int i, long x) { a[i] = x; }
+ static float getElementF(float[] a, int i) { return a[i]; }
+ static void setElementF(float[] a, int i, float x) { a[i] = x; }
+ static double getElementD(double[] a, int i) { return a[i]; }
+ static void setElementD(double[] a, int i, double x) { a[i] = x; }
+ static boolean getElementZ(boolean[] a, int i) { return a[i]; }
+ static void setElementZ(boolean[] a, int i, boolean x) { a[i] = x; }
+ static byte getElementB(byte[] a, int i) { return a[i]; }
+ static void setElementB(byte[] a, int i, byte x) { a[i] = x; }
+ static short getElementS(short[] a, int i) { return a[i]; }
+ static void setElementS(short[] a, int i, short x) { a[i] = x; }
+ static char getElementC(char[] a, int i) { return a[i]; }
+ static void setElementC(char[] a, int i, char x) { a[i] = x; }
+ static Object getElementL(Object[] a, int i) { return a[i]; }
+ static void setElementL(Object[] a, int i, Object x) { a[i] = x; }
+ static <V> V getElementL(Class<V[]> aclass, V[] a, int i) { return aclass.cast(a)[i]; }
+ static <V> void setElementL(Class<V[]> aclass, V[] a, int i, V x) { aclass.cast(a)[i] = x; }
+
+ static String aname(Class<?> aclass, boolean isSetter) {
+ Class<?> vclass = aclass.getComponentType();
+ if (vclass == null) throw new IllegalArgumentException();
+ return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(vclass);
+ }
+ static MethodType atype(Class<?> aclass, boolean isSetter) {
+ Class<?> vclass = aclass.getComponentType();
+ if (!isSetter)
+ return MethodType.methodType(vclass, aclass, int.class);
+ else
+ return MethodType.methodType(void.class, aclass, int.class, vclass);
+ }
+ static MethodHandle ahandle(Class<?> aclass, boolean isSetter) {
+ Class<?> vclass = aclass.getComponentType();
+ String name = FieldAccessor.aname(aclass, isSetter);
+ Class<?> caclass = null;
+ if (!vclass.isPrimitive() && vclass != Object.class) {
+ caclass = aclass;
+ aclass = Object[].class;
+ vclass = Object.class;
+ }
+ MethodType type = FieldAccessor.atype(aclass, isSetter);
+ if (caclass != null)
+ type = type.insertParameterTypes(0, Class.class);
+ MethodHandle mh;
+ try {
+ mh = IMPL_LOOKUP.findStatic(FieldAccessor.class, name, type);
+ } catch (ReflectiveOperationException ex) {
+ throw uncaughtException(ex);
+ }
+ if (caclass != null) {
+ MethodType strongType = FieldAccessor.atype(caclass, isSetter);
+ mh = MethodHandles.insertArguments(mh, 0, caclass);
+ mh = MethodHandles.convertArguments(mh, strongType);
+ }
+ return mh;
+ }
+ }
+
+ /** Bind a predetermined first argument to the given direct method handle.
+ * Callable only from MethodHandles.
+ * @param token Proof that the caller has access to this package.
+ * @param target Any direct method handle.
+ * @param receiver Receiver (or first static method argument) to pre-bind.
+ * @return a BoundMethodHandle for the given DirectMethodHandle, or null if it does not exist
+ */
+ static
+ MethodHandle bindReceiver(MethodHandle target, Object receiver) {
+ if (target instanceof AdapterMethodHandle &&
+ ((AdapterMethodHandle)target).conversionOp() == MethodHandleNatives.Constants.OP_RETYPE_ONLY
+ ) {
+ Object info = MethodHandleNatives.getTargetInfo(target);
+ if (info instanceof DirectMethodHandle) {
+ DirectMethodHandle dmh = (DirectMethodHandle) info;
+ if (receiver == null ||
+ dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) {
+ MethodHandle bmh = new BoundMethodHandle(dmh, receiver, 0);
+ MethodType newType = target.type().dropParameterTypes(0, 1);
+ return convertArguments(bmh, newType, bmh.type(), null);
+ }
+ }
+ }
+ if (target instanceof DirectMethodHandle)
+ return new BoundMethodHandle((DirectMethodHandle)target, receiver, 0);
+ return null; // let caller try something else
+ }
+
+ /** Bind a predetermined argument to the given arbitrary method handle.
+ * Callable only from MethodHandles.
+ * @param token Proof that the caller has access to this package.
+ * @param target Any method handle.
+ * @param receiver Argument (which can be a boxed primitive) to pre-bind.
+ * @return a suitable BoundMethodHandle
+ */
+ static
+ MethodHandle bindArgument(MethodHandle target, int argnum, Object receiver) {
+ return new BoundMethodHandle(target, receiver, argnum);
+ }
+
+ static MethodHandle convertArguments(MethodHandle target,
+ MethodType newType,
+ MethodType oldType,
+ int[] permutationOrNull) {
+ assert(oldType.parameterCount() == target.type().parameterCount());
+ if (permutationOrNull != null) {
+ int outargs = oldType.parameterCount(), inargs = newType.parameterCount();
+ if (permutationOrNull.length != outargs)
+ throw newIllegalArgumentException("wrong number of arguments in permutation");
+ // Make the individual outgoing argument types match up first.
+ Class<?>[] callTypeArgs = new Class<?>[outargs];
+ for (int i = 0; i < outargs; i++)
+ callTypeArgs[i] = newType.parameterType(permutationOrNull[i]);
+ MethodType callType = MethodType.methodType(oldType.returnType(), callTypeArgs);
+ target = convertArguments(target, callType, oldType, null);
+ assert(target != null);
+ oldType = target.type();
+ List<Integer> goal = new ArrayList<Integer>(); // i*TOKEN
+ List<Integer> state = new ArrayList<Integer>(); // i*TOKEN
+ List<Integer> drops = new ArrayList<Integer>(); // not tokens
+ List<Integer> dups = new ArrayList<Integer>(); // not tokens
+ final int TOKEN = 10; // to mark items which are symbolic only
+ // state represents the argument values coming into target
+ for (int i = 0; i < outargs; i++) {
+ state.add(permutationOrNull[i] * TOKEN);
+ }
+ // goal represents the desired state
+ for (int i = 0; i < inargs; i++) {
+ if (state.contains(i * TOKEN)) {
+ goal.add(i * TOKEN);
+ } else {
+ // adapter must initially drop all unused arguments
+ drops.add(i);
+ }
+ }
+ // detect duplications
+ while (state.size() > goal.size()) {
+ for (int i2 = 0; i2 < state.size(); i2++) {
+ int arg1 = state.get(i2);
+ int i1 = state.indexOf(arg1);
+ if (i1 != i2) {
+ // found duplicate occurrence at i2
+ int arg2 = (inargs++) * TOKEN;
+ state.set(i2, arg2);
+ dups.add(goal.indexOf(arg1));
+ goal.add(arg2);
+ }
+ }
+ }
+ assert(state.size() == goal.size());
+ int size = goal.size();
+ while (!state.equals(goal)) {
+ // Look for a maximal sequence of adjacent misplaced arguments,
+ // and try to rotate them into place.
+ int bestRotArg = -10 * TOKEN, bestRotLen = 0;
+ int thisRotArg = -10 * TOKEN, thisRotLen = 0;
+ for (int i = 0; i < size; i++) {
+ int arg = state.get(i);
+ // Does this argument match the current run?
+ if (arg == thisRotArg + TOKEN) {
+ thisRotArg = arg;
+ thisRotLen += 1;
+ if (bestRotLen < thisRotLen) {
+ bestRotLen = thisRotLen;
+ bestRotArg = thisRotArg;
+ }
+ } else {
+ // The old sequence (if any) stops here.
+ thisRotLen = 0;
+ thisRotArg = -10 * TOKEN;
+ // But maybe a new one starts here also.
+ int wantArg = goal.get(i);
+ final int MAX_ARG_ROTATION = AdapterMethodHandle.MAX_ARG_ROTATION;
+ if (arg != wantArg &&
+ arg >= wantArg - TOKEN * MAX_ARG_ROTATION &&
+ arg <= wantArg + TOKEN * MAX_ARG_ROTATION) {
+ thisRotArg = arg;
+ thisRotLen = 1;
+ }
+ }
+ }
+ if (bestRotLen >= 2) {
+ // Do a rotation if it can improve argument positioning
+ // by at least 2 arguments. This is not always optimal,
+ // but it seems to catch common cases.
+ int dstEnd = state.indexOf(bestRotArg);
+ int srcEnd = goal.indexOf(bestRotArg);
+ int rotBy = dstEnd - srcEnd;
+ int dstBeg = dstEnd - (bestRotLen - 1);
+ int srcBeg = srcEnd - (bestRotLen - 1);
+ assert((dstEnd | dstBeg | srcEnd | srcBeg) >= 0); // no negs
+ // Make a span which covers both source and destination.
+ int rotBeg = Math.min(dstBeg, srcBeg);
+ int rotEnd = Math.max(dstEnd, srcEnd);
+ int score = 0;
+ for (int i = rotBeg; i <= rotEnd; i++) {
+ if ((int)state.get(i) != (int)goal.get(i))
+ score += 1;
+ }
+ List<Integer> rotSpan = state.subList(rotBeg, rotEnd+1);
+ Collections.rotate(rotSpan, -rotBy); // reverse direction
+ for (int i = rotBeg; i <= rotEnd; i++) {
+ if ((int)state.get(i) != (int)goal.get(i))
+ score -= 1;
+ }
+ if (score >= 2) {
+ // Improved at least two argument positions. Do it.
+ List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
+ Collections.rotate(ptypes.subList(rotBeg, rotEnd+1), -rotBy);
+ MethodType rotType = MethodType.methodType(oldType.returnType(), ptypes);
+ MethodHandle nextTarget
+ = AdapterMethodHandle.makeRotateArguments(rotType, target,
+ rotBeg, rotSpan.size(), rotBy);
+ if (nextTarget != null) {
+ //System.out.println("Rot: "+rotSpan+" by "+rotBy);
+ target = nextTarget;
+ oldType = rotType;
+ continue;
+ }
+ }
+ // Else de-rotate, and drop through to the swap-fest.
+ Collections.rotate(rotSpan, rotBy);
+ }
+
+ // Now swap like the wind!
+ List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
+ for (int i = 0; i < size; i++) {
+ // What argument do I want here?
+ int arg = goal.get(i);
+ if (arg != state.get(i)) {
+ // Where is it now?
+ int j = state.indexOf(arg);
+ Collections.swap(ptypes, i, j);
+ MethodType swapType = MethodType.methodType(oldType.returnType(), ptypes);
+ target = AdapterMethodHandle.makeSwapArguments(swapType, target, i, j);
+ if (target == null) throw newIllegalArgumentException("cannot swap");
+ assert(target.type() == swapType);
+ oldType = swapType;
+ Collections.swap(state, i, j);
+ }
+ }
+ // One pass of swapping must finish the job.
+ assert(state.equals(goal));
+ }
+ while (!dups.isEmpty()) {
+ // Grab a contiguous trailing sequence of dups.
+ int grab = dups.size() - 1;
+ int dupArgPos = dups.get(grab), dupArgCount = 1;
+ while (grab - 1 >= 0) {
+ int dup0 = dups.get(grab - 1);
+ if (dup0 != dupArgPos - 1) break;
+ dupArgPos -= 1;
+ dupArgCount += 1;
+ grab -= 1;
+ }
+ //if (dupArgCount > 1) System.out.println("Dup: "+dups.subList(grab, dups.size()));
+ dups.subList(grab, dups.size()).clear();
+ // In the new target type drop that many args from the tail:
+ List<Class<?>> ptypes = oldType.parameterList();
+ ptypes = ptypes.subList(0, ptypes.size() - dupArgCount);
+ MethodType dupType = MethodType.methodType(oldType.returnType(), ptypes);
+ target = AdapterMethodHandle.makeDupArguments(dupType, target, dupArgPos, dupArgCount);
+ if (target == null)
+ throw newIllegalArgumentException("cannot dup");
+ oldType = target.type();
+ }
+ while (!drops.isEmpty()) {
+ // Grab a contiguous initial sequence of drops.
+ int dropArgPos = drops.get(0), dropArgCount = 1;
+ while (dropArgCount < drops.size()) {
+ int drop1 = drops.get(dropArgCount);
+ if (drop1 != dropArgPos + dropArgCount) break;
+ dropArgCount += 1;
+ }
+ //if (dropArgCount > 1) System.out.println("Drop: "+drops.subList(0, dropArgCount));
+ drops.subList(0, dropArgCount).clear();
+ List<Class<?>> dropTypes = newType.parameterList()
+ .subList(dropArgPos, dropArgPos + dropArgCount);
+ MethodType dropType = oldType.insertParameterTypes(dropArgPos, dropTypes);
+ target = AdapterMethodHandle.makeDropArguments(dropType, target, dropArgPos, dropArgCount);
+ if (target == null) throw newIllegalArgumentException("cannot drop");
+ oldType = target.type();
+ }
+ }
+ if (newType == oldType)
+ return target;
+ if (oldType.parameterCount() != newType.parameterCount())
+ throw newIllegalArgumentException("mismatched parameter count");
+ MethodHandle res = AdapterMethodHandle.makePairwiseConvert(newType, target);
+ if (res != null)
+ return res;
+ int argc = oldType.parameterCount();
+ // The JVM can't do it directly, so fill in the gap with a Java adapter.
+ // TO DO: figure out what to put here from case-by-case experience
+ // Use a heavier method: Convert all the arguments to Object,
+ // then back to the desired types. We might have to use Java-based
+ // method handles to do this.
+ MethodType objType = MethodType.genericMethodType(argc);
+ MethodHandle objTarget = AdapterMethodHandle.makePairwiseConvert(objType, target);
+ if (objTarget == null)
+ objTarget = FromGeneric.make(target);
+ res = AdapterMethodHandle.makePairwiseConvert(newType, objTarget);
+ if (res != null)
+ return res;
+ return ToGeneric.make(newType, objTarget);
+ }
+
+ static MethodHandle spreadArguments(MethodHandle target,
+ MethodType newType,
+ int spreadArg) {
+ // TO DO: maybe allow the restarg to be Object and implicitly cast to Object[]
+ MethodType oldType = target.type();
+ // spread the last argument of newType to oldType
+ int spreadCount = oldType.parameterCount() - spreadArg;
+ Class<Object[]> spreadArgType = Object[].class;
+ MethodHandle res = AdapterMethodHandle.makeSpreadArguments(newType, target, spreadArgType, spreadArg, spreadCount);
+ if (res != null)
+ return res;
+ // try an intermediate adapter
+ Class<?> spreadType = null;
+ if (spreadArg < 0 || spreadArg >= newType.parameterCount()
+ || !VerifyType.isSpreadArgType(spreadType = newType.parameterType(spreadArg)))
+ throw newIllegalArgumentException("no restarg in "+newType);
+ Class<?>[] ptypes = oldType.parameterArray();
+ for (int i = 0; i < spreadCount; i++)
+ ptypes[spreadArg + i] = VerifyType.spreadArgElementType(spreadType, i);
+ MethodType midType = MethodType.methodType(newType.returnType(), ptypes);
+ // after spreading, some arguments may need further conversion
+ MethodHandle target2 = convertArguments(target, midType, oldType, null);
+ if (target2 == null)
+ throw new UnsupportedOperationException("NYI: convert "+midType+" =calls=> "+oldType);
+ res = AdapterMethodHandle.makeSpreadArguments(newType, target2, spreadArgType, spreadArg, spreadCount);
+ if (res != null)
+ return res;
+ res = SpreadGeneric.make(target2, spreadCount);
+ if (res != null)
+ res = convertArguments(res, newType, res.type(), null);
+ return res;
+ }
+
+ static MethodHandle collectArguments(MethodHandle target,
+ MethodType newType,
+ int collectArg,
+ MethodHandle collector) {
+ MethodType oldType = target.type(); // (a...,c)=>r
+ if (collector == null) {
+ int numCollect = newType.parameterCount() - oldType.parameterCount() + 1;
+ collector = ValueConversions.varargsArray(numCollect);
+ }
+ // newType // (a..., b...)=>r
+ MethodType colType = collector.type(); // (b...)=>c
+ // oldType // (a..., b...)=>r
+ assert(newType.parameterCount() == collectArg + colType.parameterCount());
+ assert(oldType.parameterCount() == collectArg + 1);
+ MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, null);
+ MethodHandle gcollector = convertArguments(collector, colType.generic(), colType, null);
+ if (gtarget == null || gcollector == null) return null;
+ MethodHandle gresult = FilterGeneric.makeArgumentCollector(gcollector, gtarget);
+ MethodHandle result = convertArguments(gresult, newType, gresult.type(), null);
+ return result;
+ }
+
+ static MethodHandle filterArgument(MethodHandle target,
+ int pos,
+ MethodHandle filter) {
+ MethodType ttype = target.type(), gttype = ttype.generic();
+ if (ttype != gttype) {
+ target = convertArguments(target, gttype, ttype, null);
+ ttype = gttype;
+ }
+ MethodType ftype = filter.type(), gftype = ftype.generic();
+ if (ftype.parameterCount() != 1)
+ throw new InternalError();
+ if (ftype != gftype) {
+ filter = convertArguments(filter, gftype, ftype, null);
+ ftype = gftype;
+ }
+ if (ftype == ttype) {
+ // simple unary case
+ return FilterOneArgument.make(filter, target);
+ }
+ return FilterGeneric.makeArgumentFilter(pos, filter, target);
+ }
+
+ static MethodHandle foldArguments(MethodHandle target,
+ MethodType newType,
+ MethodHandle combiner) {
+ MethodType oldType = target.type();
+ MethodType ctype = combiner.type();
+ MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, null);
+ MethodHandle gcombiner = convertArguments(combiner, ctype.generic(), ctype, null);
+ if (gtarget == null || gcombiner == null) return null;
+ MethodHandle gresult = FilterGeneric.makeArgumentFolder(gcombiner, gtarget);
+ MethodHandle result = convertArguments(gresult, newType, gresult.type(), null);
+ return result;
+ }
+
+ static
+ MethodHandle dropArguments(MethodHandle target,
+ MethodType newType, int argnum) {
+ int drops = newType.parameterCount() - target.type().parameterCount();
+ MethodHandle res = AdapterMethodHandle.makeDropArguments(newType, target, argnum, drops);
+ if (res != null)
+ return res;
+ throw new UnsupportedOperationException("NYI");
+ }
+
+ private static class GuardWithTest extends BoundMethodHandle {
+ private final MethodHandle test, target, fallback;
+ private GuardWithTest(MethodHandle invoker,
+ MethodHandle test, MethodHandle target, MethodHandle fallback) {
+ super(invoker);
+ this.test = test;
+ this.target = target;
+ this.fallback = fallback;
+ }
+ static MethodHandle make(MethodHandle test, MethodHandle target, MethodHandle fallback) {
+ MethodType type = target.type();
+ int nargs = type.parameterCount();
+ if (nargs < INVOKES.length) {
+ MethodHandle invoke = INVOKES[nargs];
+ MethodType gtype = type.generic();
+ assert(invoke.type().dropParameterTypes(0,1) == gtype);
+ MethodHandle gtest = convertArguments(test, gtype.changeReturnType(boolean.class), test.type(), null);
+ MethodHandle gtarget = convertArguments(target, gtype, type, null);
+ MethodHandle gfallback = convertArguments(fallback, gtype, type, null);
+ if (gtest == null || gtarget == null || gfallback == null) return null;
+ MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback);
+ return convertArguments(gguard, type, gtype, null);
+ } else {
+ MethodHandle invoke = VARARGS_INVOKE;
+ MethodType gtype = MethodType.genericMethodType(1);
+ assert(invoke.type().dropParameterTypes(0,1) == gtype);
+ MethodHandle gtest = spreadArguments(test, gtype.changeReturnType(boolean.class), 0);
+ MethodHandle gtarget = spreadArguments(target, gtype, 0);
+ MethodHandle gfallback = spreadArguments(fallback, gtype, 0);
+ MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback);
+ if (gtest == null || gtarget == null || gfallback == null) return null;
+ return collectArguments(gguard, type, 0, null);
+ }
+ }
+ @Override
+ public String toString() {
+ return addTypeString(target, this);
+ }
+ private Object invoke_V(Object... av) throws Throwable {
+ if ((boolean) test.invokeExact(av))
+ return target.invokeExact(av);
+ return fallback.invokeExact(av);
+ }
+ private Object invoke_L0() throws Throwable {
+ if ((boolean) test.invokeExact())
+ return target.invokeExact();
+ return fallback.invokeExact();
+ }
+ private Object invoke_L1(Object a0) throws Throwable {
+ if ((boolean) test.invokeExact(a0))
+ return target.invokeExact(a0);
+ return fallback.invokeExact(a0);
+ }
+ private Object invoke_L2(Object a0, Object a1) throws Throwable {
+ if ((boolean) test.invokeExact(a0, a1))
+ return target.invokeExact(a0, a1);
+ return fallback.invokeExact(a0, a1);
+ }
+ private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
+ if ((boolean) test.invokeExact(a0, a1, a2))
+ return target.invokeExact(a0, a1, a2);
+ return fallback.invokeExact(a0, a1, a2);
+ }
+ private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ if ((boolean) test.invokeExact(a0, a1, a2, a3))
+ return target.invokeExact(a0, a1, a2, a3);
+ return fallback.invokeExact(a0, a1, a2, a3);
+ }
+ private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
+ if ((boolean) test.invokeExact(a0, a1, a2, a3, a4))
+ return target.invokeExact(a0, a1, a2, a3, a4);
+ return fallback.invokeExact(a0, a1, a2, a3, a4);
+ }
+ private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
+ if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5))
+ return target.invokeExact(a0, a1, a2, a3, a4, a5);
+ return fallback.invokeExact(a0, a1, a2, a3, a4, a5);
+ }
+ private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
+ if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6))
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
+ return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6);
+ }
+ private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7))
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
+ return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+ static MethodHandle[] makeInvokes() {
+ ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
+ MethodHandles.Lookup lookup = IMPL_LOOKUP;
+ for (;;) {
+ int nargs = invokes.size();
+ String name = "invoke_L"+nargs;
+ MethodHandle invoke = null;
+ try {
+ invoke = lookup.findVirtual(GuardWithTest.class, name, MethodType.genericMethodType(nargs));
+ } catch (ReflectiveOperationException ex) {
+ }
+ if (invoke == null) break;
+ invokes.add(invoke);
+ }
+ assert(invokes.size() == 9); // current number of methods
+ return invokes.toArray(new MethodHandle[0]);
+ };
+ static final MethodHandle[] INVOKES = makeInvokes();
+ // For testing use this:
+ //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
+ static final MethodHandle VARARGS_INVOKE;
+ static {
+ try {
+ VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(GuardWithTest.class, "invoke_V", MethodType.genericMethodType(0, true));
+ } catch (ReflectiveOperationException ex) {
+ throw uncaughtException(ex);
+ }
+ }
+ }
+
+ static
+ MethodHandle makeGuardWithTest(MethodHandle test,
+ MethodHandle target,
+ MethodHandle fallback) {
+ return GuardWithTest.make(test, target, fallback);
+ }
+
+ private static class GuardWithCatch extends BoundMethodHandle {
+ private final MethodHandle target;
+ private final Class<? extends Throwable> exType;
+ private final MethodHandle catcher;
+ GuardWithCatch(MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
+ this(INVOKES[target.type().parameterCount()], target, exType, catcher);
+ }
+ GuardWithCatch(MethodHandle invoker,
+ MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
+ super(invoker);
+ this.target = target;
+ this.exType = exType;
+ this.catcher = catcher;
+ }
+ @Override
+ public String toString() {
+ return addTypeString(target, this);
+ }
+ private Object invoke_V(Object... av) throws Throwable {
+ try {
+ return target.invokeExact(av);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, av);
+ }
+ }
+ private Object invoke_L0() throws Throwable {
+ try {
+ return target.invokeExact();
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t);
+ }
+ }
+ private Object invoke_L1(Object a0) throws Throwable {
+ try {
+ return target.invokeExact(a0);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0);
+ }
+ }
+ private Object invoke_L2(Object a0, Object a1) throws Throwable {
+ try {
+ return target.invokeExact(a0, a1);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0, a1);
+ }
+ }
+ private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
+ try {
+ return target.invokeExact(a0, a1, a2);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0, a1, a2);
+ }
+ }
+ private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
+ try {
+ return target.invokeExact(a0, a1, a2, a3);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0, a1, a2, a3);
+ }
+ }
+ private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
+ try {
+ return target.invokeExact(a0, a1, a2, a3, a4);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0, a1, a2, a3, a4);
+ }
+ }
+ private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
+ try {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5);
+ }
+ }
+ private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
+ try {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6);
+ }
+ }
+ private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
+ try {
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
+ } catch (Throwable t) {
+ if (!exType.isInstance(t)) throw t;
+ return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+ }
+ static MethodHandle[] makeInvokes() {
+ ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
+ MethodHandles.Lookup lookup = IMPL_LOOKUP;
+ for (;;) {
+ int nargs = invokes.size();
+ String name = "invoke_L"+nargs;
+ MethodHandle invoke = null;
+ try {
+ invoke = lookup.findVirtual(GuardWithCatch.class, name, MethodType.genericMethodType(nargs));
+ } catch (ReflectiveOperationException ex) {
+ }
+ if (invoke == null) break;
+ invokes.add(invoke);
+ }
+ assert(invokes.size() == 9); // current number of methods
+ return invokes.toArray(new MethodHandle[0]);
+ };
+ static final MethodHandle[] INVOKES = makeInvokes();
+ // For testing use this:
+ //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
+ static final MethodHandle VARARGS_INVOKE;
+ static {
+ try {
+ VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(GuardWithCatch.class, "invoke_V", MethodType.genericMethodType(0, true));
+ } catch (ReflectiveOperationException ex) {
+ throw uncaughtException(ex);
+ }
+ }
+ }
+
+
+ static
+ MethodHandle makeGuardWithCatch(MethodHandle target,
+ Class<? extends Throwable> exType,
+ MethodHandle catcher) {
+ MethodType type = target.type();
+ MethodType ctype = catcher.type();
+ int nargs = type.parameterCount();
+ if (nargs < GuardWithCatch.INVOKES.length) {
+ MethodType gtype = type.generic();
+ MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
+ MethodHandle gtarget = convertArguments(target, gtype, type, null);
+ MethodHandle gcatcher = convertArguments(catcher, gcatchType, ctype, null);
+ MethodHandle gguard = new GuardWithCatch(gtarget, exType, gcatcher);
+ if (gtarget == null || gcatcher == null || gguard == null) return null;
+ return convertArguments(gguard, type, gtype, null);
+ } else {
+ MethodType gtype = MethodType.genericMethodType(0, true);
+ MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
+ MethodHandle gtarget = spreadArguments(target, gtype, 0);
+ MethodHandle gcatcher = spreadArguments(catcher, gcatchType, 1);
+ MethodHandle gguard = new GuardWithCatch(GuardWithCatch.VARARGS_INVOKE, gtarget, exType, gcatcher);
+ if (gtarget == null || gcatcher == null || gguard == null) return null;
+ return collectArguments(gguard, type, 0, null);
+ }
+ }
+
+ static
+ MethodHandle throwException(MethodType type) {
+ return AdapterMethodHandle.makeRetypeRaw(type, throwException());
+ }
+
+ static MethodHandle THROW_EXCEPTION;
+ static MethodHandle throwException() {
+ if (THROW_EXCEPTION != null) return THROW_EXCEPTION;
+ try {
+ THROW_EXCEPTION
+ = IMPL_LOOKUP.findStatic(MethodHandleImpl.class, "throwException",
+ MethodType.methodType(Empty.class, Throwable.class));
+ } catch (ReflectiveOperationException ex) {
+ throw new RuntimeException(ex);
+ }
+ return THROW_EXCEPTION;
+ }
+ static <T extends Throwable> Empty throwException(T t) throws T { throw t; }
+
+ // Linkage support:
+ static void registerBootstrap(Class<?> callerClass, MethodHandle bootstrapMethod) {
+ MethodHandleNatives.registerBootstrap(callerClass, bootstrapMethod);
+ }
+ static MethodHandle getBootstrap(Class<?> callerClass) {
+ return MethodHandleNatives.getBootstrap(callerClass);
+ }
+
+ static MethodHandle asVarargsCollector(MethodHandle target, Class<?> arrayType) {
+ return AdapterMethodHandle.makeVarargsCollector(target, arrayType);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/MethodHandleNatives.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import java.dyn.MethodHandles.Lookup;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Field;
+import static java.dyn.MethodHandleNatives.Constants.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * The JVM interface for the method handles package is all here.
+ * This is an interface internal and private to an implemetantion of JSR 292.
+ * <em>This class is not part of the JSR 292 standard.</em>
+ * @author jrose
+ */
+class MethodHandleNatives {
+
+ private MethodHandleNatives() { } // static only
+
+ /// MethodName support
+
+ static native void init(MemberName self, Object ref);
+ static native void expand(MemberName self);
+ static native void resolve(MemberName self, Class<?> caller);
+ static native int getMembers(Class<?> defc, String matchName, String matchSig,
+ int matchFlags, Class<?> caller, int skip, MemberName[] results);
+
+ /// MethodHandle support
+
+ /** Initialize the method handle to adapt the call. */
+ static native void init(AdapterMethodHandle self, MethodHandle target, int argnum);
+ /** Initialize the method handle to call the correct method, directly. */
+ static native void init(BoundMethodHandle self, Object target, int argnum);
+ /** Initialize the method handle to call as if by an invoke* instruction. */
+ static native void init(DirectMethodHandle self, Object ref, boolean doDispatch, Class<?> caller);
+
+ /** Initialize a method type, once per form. */
+ static native void init(MethodType self);
+
+ /** Tell the JVM about a class's bootstrap method. */
+ static native void registerBootstrap(Class<?> caller, MethodHandle bootstrapMethod);
+
+ /** Ask the JVM about a class's bootstrap method. */
+ static native MethodHandle getBootstrap(Class<?> caller);
+
+ /** Tell the JVM that we need to change the target of an invokedynamic. */
+ static native void setCallSiteTarget(CallSite site, MethodHandle target);
+
+ /** Fetch the vmtarget field.
+ * It will be sanitized as necessary to avoid exposing non-Java references.
+ * This routine is for debugging and reflection.
+ */
+ static native Object getTarget(MethodHandle self, int format);
+
+ /** Fetch the name of the handled method, if available.
+ * This routine is for debugging and reflection.
+ */
+ static MemberName getMethodName(MethodHandle self) {
+ return (MemberName) getTarget(self, ETF_METHOD_NAME);
+ }
+
+ /** Fetch the reflective version of the handled method, if available.
+ */
+ static AccessibleObject getTargetMethod(MethodHandle self) {
+ return (AccessibleObject) getTarget(self, ETF_REFLECT_METHOD);
+ }
+
+ /** Fetch the target of this method handle.
+ * If it directly targets a method, return a MemberName for the method.
+ * If it is chained to another method handle, return that handle.
+ */
+ static Object getTargetInfo(MethodHandle self) {
+ return getTarget(self, ETF_HANDLE_OR_METHOD_NAME);
+ }
+
+ static Object[] makeTarget(Class<?> defc, String name, String sig, int mods, Class<?> refc) {
+ return new Object[] { defc, name, sig, mods, refc };
+ }
+
+ /** Fetch MH-related JVM parameter.
+ * which=0 retrieves MethodHandlePushLimit
+ * which=1 retrieves stack slot push size (in address units)
+ */
+ static native int getConstant(int which);
+
+ /** Java copy of MethodHandlePushLimit in range 2..255. */
+ static final int JVM_PUSH_LIMIT;
+ /** JVM stack motion (in words) after one slot is pushed, usually -1.
+ */
+ static final int JVM_STACK_MOVE_UNIT;
+
+ /** Which conv-ops are implemented by the JVM? */
+ static final int CONV_OP_IMPLEMENTED_MASK;
+
+ private static native void registerNatives();
+ static {
+ int JVM_PUSH_LIMIT_;
+ int JVM_STACK_MOVE_UNIT_;
+ int CONV_OP_IMPLEMENTED_MASK_;
+ try {
+ registerNatives();
+ JVM_PUSH_LIMIT_ = getConstant(Constants.GC_JVM_PUSH_LIMIT);
+ JVM_STACK_MOVE_UNIT_ = getConstant(Constants.GC_JVM_STACK_MOVE_UNIT);
+ CONV_OP_IMPLEMENTED_MASK_ = getConstant(Constants.GC_CONV_OP_IMPLEMENTED_MASK);
+ //sun.reflect.Reflection.registerMethodsToFilter(MethodHandleImpl.class, "init");
+ } catch (UnsatisfiedLinkError ee) {
+ // ignore; if we use init() methods later we'll see linkage errors
+ JVM_PUSH_LIMIT_ = 3; // arbitrary
+ JVM_STACK_MOVE_UNIT_ = -1; // arbitrary
+ CONV_OP_IMPLEMENTED_MASK_ = 0;
+ JVM_PUSH_LIMIT = JVM_PUSH_LIMIT_;
+ JVM_STACK_MOVE_UNIT = JVM_STACK_MOVE_UNIT_;
+ throw ee; // just die; hopeless to try to run with an older JVM
+ }
+ JVM_PUSH_LIMIT = JVM_PUSH_LIMIT_;
+ JVM_STACK_MOVE_UNIT = JVM_STACK_MOVE_UNIT_;
+ if (CONV_OP_IMPLEMENTED_MASK_ == 0)
+ CONV_OP_IMPLEMENTED_MASK_ = DEFAULT_CONV_OP_IMPLEMENTED_MASK;
+ CONV_OP_IMPLEMENTED_MASK = CONV_OP_IMPLEMENTED_MASK_;
+ }
+
+ // All compile-time constants go here.
+ // There is an opportunity to check them against the JVM's idea of them.
+ static class Constants {
+ Constants() { } // static only
+ // MethodHandleImpl
+ static final int // for getConstant
+ GC_JVM_PUSH_LIMIT = 0,
+ GC_JVM_STACK_MOVE_UNIT = 1,
+ GC_CONV_OP_IMPLEMENTED_MASK = 2;
+ static final int
+ ETF_HANDLE_OR_METHOD_NAME = 0, // all available data (immediate MH or method)
+ ETF_DIRECT_HANDLE = 1, // ultimate method handle (will be a DMH, may be self)
+ ETF_METHOD_NAME = 2, // ultimate method as MemberName
+ ETF_REFLECT_METHOD = 3; // ultimate method as java.lang.reflect object (sans refClass)
+
+ // MemberName
+ // The JVM uses values of -2 and above for vtable indexes.
+ // Field values are simple positive offsets.
+ // Ref: src/share/vm/oops/methodOop.hpp
+ // This value is negative enough to avoid such numbers,
+ // but not too negative.
+ static final int
+ MN_IS_METHOD = 0x00010000, // method (not constructor)
+ MN_IS_CONSTRUCTOR = 0x00020000, // constructor
+ MN_IS_FIELD = 0x00040000, // field
+ MN_IS_TYPE = 0x00080000, // nested type
+ MN_SEARCH_SUPERCLASSES = 0x00100000, // for MHN.getMembers
+ MN_SEARCH_INTERFACES = 0x00200000, // for MHN.getMembers
+ VM_INDEX_UNINITIALIZED = -99;
+
+ // AdapterMethodHandle
+ /** Conversions recognized by the JVM.
+ * They must align with the constants in java.dyn_AdapterMethodHandle,
+ * in the JVM file hotspot/src/share/vm/classfile/javaClasses.hpp.
+ */
+ static final int
+ OP_RETYPE_ONLY = 0x0, // no argument changes; straight retype
+ OP_RETYPE_RAW = 0x1, // no argument changes; straight retype
+ OP_CHECK_CAST = 0x2, // ref-to-ref conversion; requires a Class argument
+ OP_PRIM_TO_PRIM = 0x3, // converts from one primitive to another
+ OP_REF_TO_PRIM = 0x4, // unboxes a wrapper to produce a primitive
+ OP_PRIM_TO_REF = 0x5, // boxes a primitive into a wrapper (NYI)
+ OP_SWAP_ARGS = 0x6, // swap arguments (vminfo is 2nd arg)
+ OP_ROT_ARGS = 0x7, // rotate arguments (vminfo is displaced arg)
+ OP_DUP_ARGS = 0x8, // duplicates one or more arguments (at TOS)
+ OP_DROP_ARGS = 0x9, // remove one or more argument slots
+ OP_COLLECT_ARGS = 0xA, // combine one or more arguments into a varargs (NYI)
+ OP_SPREAD_ARGS = 0xB, // expand in place a varargs array (of known size)
+ OP_FLYBY = 0xC, // operate first on reified argument list (NYI)
+ OP_RICOCHET = 0xD, // run an adapter chain on the return value (NYI)
+ CONV_OP_LIMIT = 0xE; // limit of CONV_OP enumeration
+ /** Shift and mask values for decoding the AMH.conversion field.
+ * These numbers are shared with the JVM for creating AMHs.
+ */
+ static final int
+ CONV_OP_MASK = 0xF00, // this nybble contains the conversion op field
+ CONV_VMINFO_MASK = 0x0FF, // LSB is reserved for JVM use
+ CONV_VMINFO_SHIFT = 0, // position of bits in CONV_VMINFO_MASK
+ CONV_OP_SHIFT = 8, // position of bits in CONV_OP_MASK
+ CONV_DEST_TYPE_SHIFT = 12, // byte 2 has the adapter BasicType (if needed)
+ CONV_SRC_TYPE_SHIFT = 16, // byte 2 has the source BasicType (if needed)
+ CONV_STACK_MOVE_SHIFT = 20, // high 12 bits give signed SP change
+ CONV_STACK_MOVE_MASK = (1 << (32 - CONV_STACK_MOVE_SHIFT)) - 1;
+
+ /** Which conv-ops are implemented by the JVM? */
+ static final int DEFAULT_CONV_OP_IMPLEMENTED_MASK =
+ // Value to use if the corresponding JVM query fails.
+ ((1<<OP_RETYPE_ONLY)
+ |(1<<OP_RETYPE_RAW)
+ |(1<<OP_CHECK_CAST)
+ |(1<<OP_PRIM_TO_PRIM)
+ |(1<<OP_REF_TO_PRIM)
+ |(1<<OP_SWAP_ARGS)
+ |(1<<OP_ROT_ARGS)
+ |(1<<OP_DUP_ARGS)
+ |(1<<OP_DROP_ARGS)
+ //|(1<<OP_SPREAD_ARGS)
+ );
+
+ /**
+ * Basic types as encoded in the JVM. These code values are not
+ * intended for use outside this class. They are used as part of
+ * a private interface between the JVM and this class.
+ */
+ static final int
+ T_BOOLEAN = 4,
+ T_CHAR = 5,
+ T_FLOAT = 6,
+ T_DOUBLE = 7,
+ T_BYTE = 8,
+ T_SHORT = 9,
+ T_INT = 10,
+ T_LONG = 11,
+ T_OBJECT = 12,
+ //T_ARRAY = 13
+ T_VOID = 14;
+ //T_ADDRESS = 15
+
+ /**
+ * Constant pool reference-kind codes, as used by CONSTANT_MethodHandle CP entries.
+ */
+ static final int
+ REF_getField = 1,
+ REF_getStatic = 2,
+ REF_putField = 3,
+ REF_putStatic = 4,
+ REF_invokeVirtual = 5,
+ REF_invokeStatic = 6,
+ REF_invokeSpecial = 7,
+ REF_newInvokeSpecial = 8,
+ REF_invokeInterface = 9;
+ }
+
+ private static native int getNamedCon(int which, Object[] name);
+ static boolean verifyConstants() {
+ Object[] box = { null };
+ for (int i = 0; ; i++) {
+ box[0] = null;
+ int vmval = getNamedCon(i, box);
+ if (box[0] == null) break;
+ String name = (String) box[0];
+ try {
+ Field con = Constants.class.getDeclaredField(name);
+ int jval = con.getInt(null);
+ if (jval != vmval)
+ throw new InternalError(name+": JVM has "+vmval+" while Java has "+jval);
+ } catch (Exception ex) {
+ throw new InternalError(name+": access failed, got "+ex);
+ }
+ }
+ return true;
+ }
+ static {
+ verifyConstants();
+ }
+
+ // Up-calls from the JVM.
+ // These must NOT be public.
+
+ /**
+ * The JVM is linking an invokedynamic instruction. Create a reified call site for it.
+ */
+ static CallSite makeDynamicCallSite(MethodHandle bootstrapMethod,
+ String name, MethodType type,
+ Object info,
+ MemberName callerMethod, int callerBCI) {
+ return CallSite.makeSite(bootstrapMethod, name, type, info, callerMethod, callerBCI);
+ }
+
+ /**
+ * Called by the JVM to check the length of a spread array.
+ */
+ static void checkSpreadArgument(Object av, int n) {
+ MethodHandleStatics.checkSpreadArgument(av, n);
+ }
+
+ /**
+ * The JVM wants a pointer to a MethodType. Oblige it by finding or creating one.
+ */
+ static MethodType findMethodHandleType(Class<?> rtype, Class<?>[] ptypes) {
+ return MethodType.makeImpl(rtype, ptypes, true);
+ }
+
+ /**
+ * The JVM wants to use a MethodType with invokeGeneric. Give the runtime fair warning.
+ */
+ static void notifyGenericMethodType(MethodType type) {
+ type.form().notifyGenericMethodType();
+ }
+
+ /**
+ * The JVM wants to raise an exception. Here's the path.
+ */
+ static void raiseException(int code, Object actual, Object required) {
+ String message;
+ // disregard the identity of the actual object, if it is not a class:
+ if (!(actual instanceof Class) && !(actual instanceof MethodType))
+ actual = actual.getClass();
+ if (actual != null)
+ message = "required "+required+" but encountered "+actual;
+ else
+ message = "required "+required;
+ switch (code) {
+ case 192: // checkcast
+ throw new ClassCastException(message);
+ default:
+ throw new InternalError("unexpected code "+code+": "+message);
+ }
+ }
+
+ /**
+ * The JVM is resolving a CONSTANT_MethodHandle CP entry. And it wants our help.
+ * It will make an up-call to this method. (Do not change the name or signature.)
+ */
+ static MethodHandle linkMethodHandleConstant(Class<?> callerClass, int refKind,
+ Class<?> defc, String name, Object type) {
+ try {
+ Lookup lookup = IMPL_LOOKUP.in(callerClass);
+ switch (refKind) {
+ case REF_getField: return lookup.findGetter( defc, name, (Class<?>) type );
+ case REF_getStatic: return lookup.findStaticGetter( defc, name, (Class<?>) type );
+ case REF_putField: return lookup.findSetter( defc, name, (Class<?>) type );
+ case REF_putStatic: return lookup.findStaticSetter( defc, name, (Class<?>) type );
+ case REF_invokeVirtual: return lookup.findVirtual( defc, name, (MethodType) type );
+ case REF_invokeStatic: return lookup.findStatic( defc, name, (MethodType) type );
+ case REF_invokeSpecial: return lookup.findSpecial( defc, name, (MethodType) type, callerClass );
+ case REF_newInvokeSpecial: return lookup.findConstructor( defc, (MethodType) type );
+ case REF_invokeInterface: return lookup.findVirtual( defc, name, (MethodType) type );
+ }
+ throw new IllegalArgumentException("bad MethodHandle constant "+name+" : "+type);
+ } catch (ReflectiveOperationException ex) {
+ Error err = new IncompatibleClassChangeError();
+ err.initCause(ex);
+ throw err;
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/MethodHandleStatics.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+/**
+ * This class consists exclusively of static names internal to the
+ * method handle implementation.
+ * Usage: {@code import static java.dyn.MethodHandleStatics.*}
+ * @author John Rose, JSR 292 EG
+ */
+/*non-public*/ class MethodHandleStatics {
+
+ private MethodHandleStatics() { } // do not instantiate
+
+ /*non-public*/ static String getNameString(MethodHandle target, MethodType type) {
+ if (type == null)
+ type = target.type();
+ MemberName name = null;
+ if (target != null)
+ name = MethodHandleNatives.getMethodName(target);
+ if (name == null)
+ return "invoke" + type;
+ return name.getName() + type;
+ }
+
+ /*non-public*/ static String getNameString(MethodHandle target, MethodHandle typeHolder) {
+ return getNameString(target, typeHolder == null ? (MethodType) null : typeHolder.type());
+ }
+
+ /*non-public*/ static String getNameString(MethodHandle target) {
+ return getNameString(target, (MethodType) null);
+ }
+
+ /*non-public*/ static String addTypeString(Object obj, MethodHandle target) {
+ String str = String.valueOf(obj);
+ if (target == null) return str;
+ int paren = str.indexOf('(');
+ if (paren >= 0) str = str.substring(0, paren);
+ return str + target.type();
+ }
+
+ static void checkSpreadArgument(Object av, int n) {
+ if (av == null ? n != 0 : ((Object[])av).length != n)
+ throw newIllegalArgumentException("Array is not of length "+n);
+ }
+
+ // handy shared exception makers (they simplify the common case code)
+ /*non-public*/ static RuntimeException newIllegalStateException(String message) {
+ return new IllegalStateException(message);
+ }
+ /*non-public*/ static RuntimeException newIllegalStateException(String message, Object obj) {
+ return new IllegalStateException(message(message, obj));
+ }
+ /*non-public*/ static RuntimeException newIllegalArgumentException(String message) {
+ return new IllegalArgumentException(message);
+ }
+ /*non-public*/ static RuntimeException newIllegalArgumentException(String message, Object obj) {
+ return new IllegalArgumentException(message(message, obj));
+ }
+ /*non-public*/ static Error uncaughtException(Exception ex) {
+ Error err = new InternalError("uncaught exception");
+ err.initCause(ex);
+ return err;
+ }
+ private static String message(String message, Object obj) {
+ if (obj != null) message = message + ": " + obj;
+ return message;
+ }
+}
--- a/jdk/src/share/classes/java/dyn/MethodHandles.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/MethodHandles.java Fri Mar 18 00:03:24 2011 -0700
@@ -26,9 +26,6 @@
package java.dyn;
import java.lang.reflect.*;
-import sun.dyn.Access;
-import sun.dyn.MemberName;
-import sun.dyn.MethodHandleImpl;
import sun.dyn.WrapperInstance;
import sun.dyn.util.ValueConversions;
import sun.dyn.util.VerifyAccess;
@@ -36,11 +33,8 @@
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
-import sun.dyn.Invokers;
-import sun.dyn.MethodTypeImpl;
import sun.reflect.Reflection;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-import static sun.dyn.MemberName.newNoAccessException;
+import static java.dyn.MethodHandleStatics.*;
/**
* This class consists exclusively of static methods that operate on or return
@@ -58,8 +52,7 @@
private MethodHandles() { } // do not instantiate
- private static final Access IMPL_TOKEN = Access.getToken();
- private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory(IMPL_TOKEN);
+ private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory();
static { MethodHandleImpl.initStatics(); }
// See IMPL_LOOKUP below.
@@ -410,9 +403,8 @@
checkUnprivilegedlookupClass(lookupClass);
}
- Lookup(Access token, Class<?> lookupClass) {
+ Lookup(Class<?> lookupClass) {
this(lookupClass, ALL_MODES);
- Access.check(token);
}
private Lookup(Class<?> lookupClass, int allowedModes) {
@@ -471,7 +463,7 @@
}
// Make sure outer class is initialized first.
- static { IMPL_TOKEN.getClass(); }
+ static { IMPL_NAMES.getClass(); }
/** Version of lookup which is trusted minimally.
* It can only be used to create method handles to
@@ -481,11 +473,10 @@
/** Package-private version of lookup which is trusted. */
static final Lookup IMPL_LOOKUP = new Lookup(Object.class, TRUSTED);
- static { MethodHandleImpl.initLookup(IMPL_TOKEN, IMPL_LOOKUP); }
private static void checkUnprivilegedlookupClass(Class<?> lookupClass) {
String name = lookupClass.getName();
- if (name.startsWith("java.dyn.") || name.startsWith("sun.dyn."))
+ if (name.startsWith("java.dyn."))
throw newIllegalArgumentException("illegal lookupClass: "+lookupClass);
}
@@ -577,7 +568,7 @@
MethodHandle findStatic(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
MemberName method = resolveOrFail(refc, name, type, true);
checkMethod(refc, method, true);
- return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClassOrNull());
+ return MethodHandleImpl.findMethod(method, false, lookupClassOrNull());
}
/**
@@ -618,7 +609,7 @@
public MethodHandle findVirtual(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
MemberName method = resolveOrFail(refc, name, type, false);
checkMethod(refc, method, false);
- MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());
+ MethodHandle mh = MethodHandleImpl.findMethod(method, true, lookupClassOrNull());
return restrictProtectedReceiver(method, mh);
}
@@ -651,8 +642,8 @@
MemberName ctor = resolveOrFail(refc, name, type, false, false, lookupClassOrNull());
assert(ctor.isConstructor());
checkAccess(refc, ctor);
- MethodHandle rawMH = MethodHandleImpl.findMethod(IMPL_TOKEN, ctor, false, lookupClassOrNull());
- MethodHandle allocMH = MethodHandleImpl.makeAllocator(IMPL_TOKEN, rawMH);
+ MethodHandle rawMH = MethodHandleImpl.findMethod(ctor, false, lookupClassOrNull());
+ MethodHandle allocMH = MethodHandleImpl.makeAllocator(rawMH);
return fixVarargs(allocMH, rawMH);
}
@@ -708,7 +699,7 @@
checkSpecialCaller(specialCaller);
MemberName method = resolveOrFail(refc, name, type, false, false, specialCaller);
checkMethod(refc, method, false);
- MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, specialCaller);
+ MethodHandle mh = MethodHandleImpl.findMethod(method, false, specialCaller);
return restrictReceiver(method, mh, specialCaller);
}
@@ -839,10 +830,10 @@
Class<? extends Object> refc = receiver.getClass(); // may get NPE
MemberName method = resolveOrFail(refc, name, type, false);
checkMethod(refc, method, false);
- MethodHandle dmh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());
- MethodHandle bmh = MethodHandleImpl.bindReceiver(IMPL_TOKEN, dmh, receiver);
+ MethodHandle dmh = MethodHandleImpl.findMethod(method, true, lookupClassOrNull());
+ MethodHandle bmh = MethodHandleImpl.bindReceiver(dmh, receiver);
if (bmh == null)
- throw newNoAccessException(method, this);
+ throw method.makeAccessException("no access", this);
if (dmh.type().parameterCount() == 0)
return dmh; // bound the trailing parameter; no varargs possible
return fixVarargs(bmh, dmh);
@@ -871,7 +862,7 @@
MemberName method = new MemberName(m);
assert(method.isMethod());
if (!m.isAccessible()) checkMethod(method.getDeclaringClass(), method, method.isStatic());
- MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClassOrNull());
+ MethodHandle mh = MethodHandleImpl.findMethod(method, true, lookupClassOrNull());
if (!m.isAccessible()) mh = restrictProtectedReceiver(method, mh);
return mh;
}
@@ -901,7 +892,7 @@
assert(method.isMethod());
// ignore m.isAccessible: this is a new kind of access
checkMethod(m.getDeclaringClass(), method, false);
- MethodHandle mh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClassOrNull());
+ MethodHandle mh = MethodHandleImpl.findMethod(method, false, lookupClassOrNull());
return restrictReceiver(method, mh, specialCaller);
}
@@ -928,8 +919,8 @@
MemberName ctor = new MemberName(c);
assert(ctor.isConstructor());
if (!c.isAccessible()) checkAccess(c.getDeclaringClass(), ctor);
- MethodHandle rawCtor = MethodHandleImpl.findMethod(IMPL_TOKEN, ctor, false, lookupClassOrNull());
- MethodHandle allocator = MethodHandleImpl.makeAllocator(IMPL_TOKEN, rawCtor);
+ MethodHandle rawCtor = MethodHandleImpl.findMethod(ctor, false, lookupClassOrNull());
+ MethodHandle allocator = MethodHandleImpl.makeAllocator(rawCtor);
return fixVarargs(allocator, rawCtor);
}
@@ -999,7 +990,7 @@
void checkSymbolicClass(Class<?> refc) throws IllegalAccessException {
Class<?> caller = lookupClassOrNull();
if (caller != null && !VerifyAccess.isClassAccessible(refc, caller))
- throw newNoAccessException("symbolic reference class is not public", new MemberName(refc), this);
+ throw new MemberName(refc).makeAccessException("symbolic reference class is not public", this);
}
void checkMethod(Class<?> refc, MemberName m, boolean wantStatic) throws IllegalAccessException {
@@ -1012,7 +1003,7 @@
message = wantStatic ? "expected a static method" : "expected a non-static method";
else
{ checkAccess(refc, m); return; }
- throw newNoAccessException(message, m, this);
+ throw m.makeAccessException(message, this);
}
void checkAccess(Class<?> refc, MemberName m) throws IllegalAccessException {
@@ -1030,7 +1021,7 @@
&& VerifyAccess.isSamePackage(m.getDeclaringClass(), lookupClass()))
// Protected members can also be checked as if they were package-private.
return;
- throw newNoAccessException(accessFailedMessage(refc, m), m, this);
+ throw m.makeAccessException(accessFailedMessage(refc, m), this);
}
String accessFailedMessage(Class<?> refc, MemberName m) {
@@ -1064,8 +1055,8 @@
|| (specialCaller != lookupClass()
&& !(ALLOW_NESTMATE_ACCESS &&
VerifyAccess.isSamePackageMember(specialCaller, lookupClass()))))
- throw newNoAccessException("no private access for invokespecial",
- new MemberName(specialCaller), this);
+ throw new MemberName(specialCaller).
+ makeAccessException("no private access for invokespecial", this);
}
MethodHandle restrictProtectedReceiver(MemberName method, MethodHandle mh) throws IllegalAccessException {
@@ -1084,12 +1075,12 @@
assert(!method.isStatic());
Class<?> defc = method.getDeclaringClass(); // receiver type of mh is too wide
if (defc.isInterface() || !defc.isAssignableFrom(caller)) {
- throw newNoAccessException("caller class must be a subclass below the method", method, caller);
+ throw method.makeAccessException("caller class must be a subclass below the method", caller);
}
MethodType rawType = mh.type();
if (rawType.parameterType(0) == caller) return mh;
MethodType narrowType = rawType.changeParameterType(0, caller);
- MethodHandle narrowMH = MethodHandleImpl.convertArguments(IMPL_TOKEN, mh, narrowType, rawType, null);
+ MethodHandle narrowMH = MethodHandleImpl.convertArguments(mh, narrowType, rawType, null);
return fixVarargs(narrowMH, mh);
}
@@ -1097,10 +1088,9 @@
boolean isStatic, boolean isSetter) throws NoSuchFieldException, IllegalAccessException {
MemberName field = resolveOrFail(refc, name, type, isStatic);
if (isStatic != field.isStatic())
- throw newNoAccessException(isStatic
- ? "expected a static field"
- : "expected a non-static field",
- field, this);
+ throw field.makeAccessException(isStatic
+ ? "expected a static field"
+ : "expected a non-static field", this);
return makeAccessor(refc, field, false, isSetter);
}
@@ -1108,9 +1098,9 @@
boolean trusted, boolean isSetter) throws IllegalAccessException {
assert(field.isField());
if (trusted)
- return MethodHandleImpl.accessField(IMPL_TOKEN, field, isSetter, lookupClassOrNull());
+ return MethodHandleImpl.accessField(field, isSetter, lookupClassOrNull());
checkAccess(refc, field);
- MethodHandle mh = MethodHandleImpl.accessField(IMPL_TOKEN, field, isSetter, lookupClassOrNull());
+ MethodHandle mh = MethodHandleImpl.accessField(field, isSetter, lookupClassOrNull());
return restrictProtectedReceiver(field, mh);
}
}
@@ -1127,7 +1117,7 @@
*/
public static
MethodHandle arrayElementGetter(Class<?> arrayClass) throws IllegalArgumentException {
- return MethodHandleImpl.accessArrayElement(IMPL_TOKEN, arrayClass, false);
+ return MethodHandleImpl.accessArrayElement(arrayClass, false);
}
/**
@@ -1141,7 +1131,7 @@
*/
public static
MethodHandle arrayElementSetter(Class<?> arrayClass) throws IllegalArgumentException {
- return MethodHandleImpl.accessArrayElement(IMPL_TOKEN, arrayClass, true);
+ return MethodHandleImpl.accessArrayElement(arrayClass, true);
}
/// method handle invocation (reflective style)
@@ -1191,7 +1181,7 @@
MethodHandle spreadInvoker(MethodType type, int objectArgCount) {
if (objectArgCount < 0 || objectArgCount > type.parameterCount())
throw new IllegalArgumentException("bad argument count "+objectArgCount);
- return invokers(type).spreadInvoker(objectArgCount);
+ return type.invokers().spreadInvoker(objectArgCount);
}
/**
@@ -1231,7 +1221,7 @@
*/
static public
MethodHandle exactInvoker(MethodType type) {
- return invokers(type).exactInvoker();
+ return type.invokers().exactInvoker();
}
/**
@@ -1258,11 +1248,7 @@
*/
static public
MethodHandle genericInvoker(MethodType type) {
- return invokers(type).genericInvoker();
- }
-
- static Invokers invokers(MethodType type) {
- return MethodTypeImpl.invokers(IMPL_TOKEN, type);
+ return type.invokers().genericInvoker();
}
/**
@@ -1387,7 +1373,7 @@
return target;
MethodHandle res = null;
try {
- res = MethodHandleImpl.convertArguments(IMPL_TOKEN, target,
+ res = MethodHandleImpl.convertArguments(target,
newType, oldType, null);
} catch (IllegalArgumentException ex) {
}
@@ -1531,7 +1517,7 @@
MethodHandle permuteArguments(MethodHandle target, MethodType newType, int... reorder) {
MethodType oldType = target.type();
checkReorder(reorder, newType, oldType);
- return MethodHandleImpl.convertArguments(IMPL_TOKEN, target,
+ return MethodHandleImpl.convertArguments(target,
newType, oldType,
reorder);
}
@@ -1574,7 +1560,7 @@
int numSpread = (outargs - spreadPos);
MethodHandle res = null;
if (spreadPos >= 0 && numSpread >= 0) {
- res = MethodHandleImpl.spreadArguments(IMPL_TOKEN, target, newType, spreadPos);
+ res = MethodHandleImpl.spreadArguments(target, newType, spreadPos);
}
if (res == null) {
throw newIllegalArgumentException("cannot spread "+newType+" to " +oldType);
@@ -1607,7 +1593,7 @@
int numCollect = (inargs - collectPos);
if (collectPos < 0 || numCollect < 0)
throw newIllegalArgumentException("wrong number of arguments");
- MethodHandle res = MethodHandleImpl.collectArguments(IMPL_TOKEN, target, newType, collectPos, null);
+ MethodHandle res = MethodHandleImpl.collectArguments(target, newType, collectPos, null);
if (res == null) {
throw newIllegalArgumentException("cannot collect from "+newType+" to " +oldType);
}
@@ -1654,7 +1640,13 @@
MethodHandle identity(Class<?> type) {
if (type == void.class)
throw newIllegalArgumentException("void type");
- return ValueConversions.identity(type);
+ else if (type == Object.class)
+ return ValueConversions.identity();
+ else if (type.isPrimitive())
+ return ValueConversions.identity(Wrapper.forPrimitiveType(type));
+ else
+ return AdapterMethodHandle.makeRetypeRaw(
+ MethodType.methodType(type, type), ValueConversions.identity());
}
/**
@@ -1701,14 +1693,14 @@
value = checkValue(valueType, value);
if (pos == 0 && !valueType.isPrimitive()) {
// At least for now, make bound method handles a special case.
- MethodHandle bmh = MethodHandleImpl.bindReceiver(IMPL_TOKEN, result, value);
+ MethodHandle bmh = MethodHandleImpl.bindReceiver(result, value);
if (bmh != null) {
result = bmh;
continue;
}
// else fall through to general adapter machinery
}
- result = MethodHandleImpl.bindArgument(IMPL_TOKEN, result, pos, value);
+ result = MethodHandleImpl.bindArgument(result, pos, value);
}
return result;
}
@@ -1762,7 +1754,7 @@
new ArrayList<Class<?>>(oldType.parameterList());
ptypes.addAll(pos, valueTypes);
MethodType newType = MethodType.methodType(oldType.returnType(), ptypes);
- return MethodHandleImpl.dropArguments(IMPL_TOKEN, target, newType, pos);
+ return MethodHandleImpl.dropArguments(target, newType, pos);
}
/**
@@ -1855,11 +1847,11 @@
|| filterType.returnType() != targetType.parameterType(curPos))
throw newIllegalArgumentException("target and filter types do not match");
adapterType = adapterType.changeParameterType(curPos, filterType.parameterType(0));
- adapter = MethodHandleImpl.filterArgument(IMPL_TOKEN, adapter, curPos, filter);
+ adapter = MethodHandleImpl.filterArgument(adapter, curPos, filter);
}
MethodType midType = adapter.type();
if (midType != adapterType)
- adapter = MethodHandleImpl.convertArguments(IMPL_TOKEN, adapter, adapterType, midType, null);
+ adapter = MethodHandleImpl.convertArguments(adapter, adapterType, midType, null);
return adapter;
}
@@ -1966,7 +1958,7 @@
if (!ok)
throw misMatchedTypes("target and combiner types", targetType, combinerType);
MethodType newType = targetType.dropParameterTypes(0, 1);
- return MethodHandleImpl.foldArguments(IMPL_TOKEN, target, newType, combiner);
+ return MethodHandleImpl.foldArguments(target, newType, combiner);
}
/**
@@ -2021,7 +2013,7 @@
test = dropArguments(test, gpc, targs.subList(gpc, tpc));
gtype = test.type();
}
- return MethodHandleImpl.makeGuardWithTest(IMPL_TOKEN, test, target, fallback);
+ return MethodHandleImpl.makeGuardWithTest(test, target, fallback);
}
static RuntimeException misMatchedTypes(String what, MethodType t1, MethodType t2) {
@@ -2092,7 +2084,7 @@
handler = dropArguments(handler, hpc, hargs.subList(hpc, tpc));
htype = handler.type();
}
- return MethodHandleImpl.makeGuardWithCatch(IMPL_TOKEN, target, exType, handler);
+ return MethodHandleImpl.makeGuardWithCatch(target, exType, handler);
}
/**
@@ -2107,7 +2099,7 @@
*/
public static
MethodHandle throwException(Class<?> returnType, Class<? extends Throwable> exType) {
- return MethodHandleImpl.throwException(IMPL_TOKEN, MethodType.methodType(returnType, exType));
+ return MethodHandleImpl.throwException(MethodType.methodType(returnType, exType));
}
/**
@@ -2334,6 +2326,6 @@
/*non-public*/
static MethodHandle asVarargsCollector(MethodHandle target, Class<?> arrayType) {
- return MethodHandleImpl.asVarargsCollector(IMPL_TOKEN, target, arrayType);
+ return MethodHandleImpl.asVarargsCollector(target, arrayType);
}
}
--- a/jdk/src/share/classes/java/dyn/MethodType.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/MethodType.java Fri Mar 18 00:03:24 2011 -0700
@@ -29,12 +29,8 @@
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
-import sun.dyn.Access;
-import sun.dyn.Invokers;
-import sun.dyn.MethodHandleImpl;
-import sun.dyn.MethodTypeImpl;
import sun.dyn.util.BytecodeDescriptor;
-import static sun.dyn.MemberName.newIllegalArgumentException;
+import static java.dyn.MethodHandleStatics.*;
/**
* A method type represents the arguments and return type accepted and
@@ -96,34 +92,6 @@
private MethodType wrapAlt; // alternative wrapped/unwrapped version
private Invokers invokers; // cache of handy higher-order adapters
- private static final Access IMPL_TOKEN = Access.getToken();
-
- // share a cache with a friend in this package
- Invokers getInvokers() { return invokers; }
- void setInvokers(Invokers inv) { invokers = inv; }
-
- static {
- // This hack allows the implementation package special access to
- // the internals of MethodType. In particular, the MTImpl has all sorts
- // of cached information useful to the implementation code.
- MethodTypeImpl.setMethodTypeFriend(IMPL_TOKEN, new MethodTypeImpl.MethodTypeFriend() {
- public Class<?>[] ptypes(MethodType mt) { return mt.ptypes; }
- public MethodTypeImpl form(MethodType mt) { return mt.form; }
- public void setForm(MethodType mt, MethodTypeImpl form) {
- assert(mt.form == null);
- mt.form = (MethodTypeForm) form;
- }
- public MethodType makeImpl(Class<?> rtype, Class<?>[] ptypes, boolean trusted) {
- return MethodType.makeImpl(rtype, ptypes, trusted);
- }
- public MethodTypeImpl newMethodTypeForm(MethodType mt) {
- return new MethodTypeForm(mt);
- }
- public Invokers getInvokers(MethodType mt) { return mt.invokers; }
- public void setInvokers(MethodType mt, Invokers inv) { mt.invokers = inv; }
- });
- }
-
/**
* Check the given parameters for validity and store them into the final fields.
*/
@@ -134,6 +102,10 @@
this.ptypes = ptypes;
}
+ /*trusted*/ MethodTypeForm form() { return form; }
+ /*trusted*/ Class<?> rtype() { return rtype; }
+ /*trusted*/ Class<?>[] ptypes() { return ptypes; }
+
private static void checkRtype(Class<?> rtype) {
rtype.equals(rtype); // null check
}
@@ -253,7 +225,7 @@
* @param trusted whether the ptypes can be used without cloning
* @return the unique method type of the desired structure
*/
- private static
+ /*trusted*/ static
MethodType makeImpl(Class<?> rtype, Class<?>[] ptypes, boolean trusted) {
if (ptypes == null || ptypes.length == 0) {
ptypes = NO_PTYPES; trusted = true;
@@ -269,7 +241,12 @@
// defensively copy the array passed in by the user
mt1 = new MethodType(rtype, ptypes.clone());
// promote the object to the Real Thing, and reprobe
- MethodTypeImpl.initForm(IMPL_TOKEN, mt1);
+ MethodTypeForm form = MethodTypeForm.findForm(mt1);
+ mt1.form = form;
+ if (form.erasedType == mt1) {
+ // This is a principal (erased) type; show it to the JVM.
+ MethodHandleNatives.init(mt1);
+ }
synchronized (internTable) {
mt0 = internTable.get(mt1);
if (mt0 != null)
@@ -279,12 +256,6 @@
return mt1;
}
- // Entry point from JVM. TODO: Change the name & signature.
- private static MethodType makeImpl(Class<?> rtype, Class<?>[] ptypes,
- boolean ignore1, boolean ignore2) {
- return makeImpl(rtype, ptypes, true);
- }
-
private static final MethodType[] objectOnlyTypes = new MethodType[20];
/**
@@ -535,7 +506,7 @@
MethodType wt = pt.wrapAlt;
if (wt == null) {
// fill in lazily
- wt = MethodTypeImpl.canonicalize(pt, MethodTypeImpl.WRAP, MethodTypeImpl.WRAP);
+ wt = MethodTypeForm.canonicalize(pt, MethodTypeForm.WRAP, MethodTypeForm.WRAP);
assert(wt != null);
pt.wrapAlt = wt;
}
@@ -547,7 +518,7 @@
MethodType uwt = wt.wrapAlt;
if (uwt == null) {
// fill in lazily
- uwt = MethodTypeImpl.canonicalize(wt, MethodTypeImpl.UNWRAP, MethodTypeImpl.UNWRAP);
+ uwt = MethodTypeForm.canonicalize(wt, MethodTypeForm.UNWRAP, MethodTypeForm.UNWRAP);
if (uwt == null)
uwt = wt; // type has no wrappers or prims at all
wt.wrapAlt = uwt;
@@ -666,12 +637,18 @@
* This method is included for the benfit of applications that must
* generate bytecodes that process method handles and invokedynamic.
* @return the number of JVM stack slots for this type's parameters
- * @deprecated Will be removed for PFD.
*/
- public int parameterSlotCount() {
+ /*non-public*/ int parameterSlotCount() {
return form.parameterSlotCount();
}
+ /*non-public*/ Invokers invokers() {
+ Invokers inv = invokers;
+ if (inv != null) return inv;
+ invokers = inv = new Invokers(this);
+ return inv;
+ }
+
/** Reports the number of JVM stack slots which carry all parameters including and after
* the given position, which must be in the range of 0 to
* {@code parameterCount} inclusive. Successive parameters are
@@ -694,9 +671,8 @@
* @return the index of the (shallowest) JVM stack slot transmitting the
* given parameter
* @throws IllegalArgumentException if {@code num} is negative or greater than {@code parameterCount()}
- * @deprecated Will be removed for PFD.
*/
- public int parameterSlotDepth(int num) {
+ /*non-public*/ int parameterSlotDepth(int num) {
if (num < 0 || num > ptypes.length)
parameterType(num); // force a range check
return form.parameterToArgSlot(num-1);
@@ -710,9 +686,9 @@
* This method is included for the benfit of applications that must
* generate bytecodes that process method handles and invokedynamic.
* @return the number of JVM stack slots (0, 1, or 2) for this type's return value
- * @deprecated Will be removed for PFD.
+ * Will be removed for PFD.
*/
- public int returnSlotCount() {
+ /*non-public*/ int returnSlotCount() {
return form.returnSlotCount();
}
--- a/jdk/src/share/classes/java/dyn/MethodTypeForm.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/MethodTypeForm.java Fri Mar 18 00:03:24 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -25,15 +25,452 @@
package java.dyn;
+import sun.dyn.util.Wrapper;
+import static java.dyn.MethodHandleStatics.*;
+
/**
- * TO DO: Temporary shim; remove after refactoring effects are complete in JVM.
+ * Shared information for a group of method types, which differ
+ * only by reference types, and therefore share a common erasure
+ * and wrapping.
+ * <p>
+ * For an empirical discussion of the structure of method types,
+ * see <a href="http://groups.google.com/group/jvm-languages/browse_thread/thread/ac9308ae74da9b7e/">
+ * the thread "Avoiding Boxing" on jvm-languages</a>.
+ * There are approximately 2000 distinct erased method types in the JDK.
+ * There are a little over 10 times that number of unerased types.
+ * No more than half of these are likely to be loaded at once.
* @author John Rose
*/
-import sun.dyn.MethodTypeImpl;
+class MethodTypeForm {
+ final int[] argToSlotTable, slotToArgTable;
+ final long argCounts; // packed slot & value counts
+ final long primCounts; // packed prim & double counts
+ final int vmslots; // total number of parameter slots
+ final MethodType erasedType; // the canonical erasure
+
+ /*lazy*/ MethodType primsAsBoxes; // replace prims by wrappers
+ /*lazy*/ MethodType primArgsAsBoxes; // wrap args only; make raw return
+ /*lazy*/ MethodType primsAsInts; // replace prims by int/long
+ /*lazy*/ MethodType primsAsLongs; // replace prims by long
+ /*lazy*/ MethodType primsAtEnd; // reorder primitives to the end
+
+ // Cached adapter information:
+ /*lazy*/ ToGeneric toGeneric; // convert cs. with prims to w/o
+ /*lazy*/ FromGeneric fromGeneric; // convert cs. w/o prims to with
+ /*lazy*/ SpreadGeneric[] spreadGeneric; // expand one argument to many
+ /*lazy*/ FilterGeneric filterGeneric; // convert argument(s) on the fly
+ /*lazy*/ MethodHandle genericInvoker; // hook for invokeGeneric
+
+ public MethodType erasedType() {
+ return erasedType;
+ }
+
+ protected MethodTypeForm(MethodType erasedType) {
+ this.erasedType = erasedType;
+
+ Class<?>[] ptypes = erasedType.ptypes();
+ int ptypeCount = ptypes.length;
+ int pslotCount = ptypeCount; // temp. estimate
+ int rtypeCount = 1; // temp. estimate
+ int rslotCount = 1; // temp. estimate
+
+ int[] argToSlotTab = null, slotToArgTab = null;
+
+ // Walk the argument types, looking for primitives.
+ int pac = 0, lac = 0, prc = 0, lrc = 0;
+ Class<?> epts[] = ptypes;
+ for (int i = 0; i < epts.length; i++) {
+ Class<?> pt = epts[i];
+ if (pt != Object.class) {
+ assert(pt.isPrimitive());
+ ++pac;
+ if (hasTwoArgSlots(pt)) ++lac;
+ }
+ }
+ pslotCount += lac; // #slots = #args + #longs
+ Class<?> rt = erasedType.returnType();
+ if (rt != Object.class) {
+ ++prc; // even void.class counts as a prim here
+ if (hasTwoArgSlots(rt)) ++lrc;
+ // adjust #slots, #args
+ if (rt == void.class)
+ rtypeCount = rslotCount = 0;
+ else
+ rslotCount += lrc;
+ }
+ if (lac != 0) {
+ int slot = ptypeCount + lac;
+ slotToArgTab = new int[slot+1];
+ argToSlotTab = new int[1+ptypeCount];
+ argToSlotTab[0] = slot; // argument "-1" is past end of slots
+ for (int i = 0; i < epts.length; i++) {
+ Class<?> pt = epts[i];
+ if (hasTwoArgSlots(pt)) --slot;
+ --slot;
+ slotToArgTab[slot] = i+1; // "+1" see argSlotToParameter note
+ argToSlotTab[1+i] = slot;
+ }
+ assert(slot == 0); // filled the table
+ }
+ this.primCounts = pack(lrc, prc, lac, pac);
+ this.argCounts = pack(rslotCount, rtypeCount, pslotCount, ptypeCount);
+ if (slotToArgTab == null) {
+ int slot = ptypeCount; // first arg is deepest in stack
+ slotToArgTab = new int[slot+1];
+ argToSlotTab = new int[1+ptypeCount];
+ argToSlotTab[0] = slot; // argument "-1" is past end of slots
+ for (int i = 0; i < ptypeCount; i++) {
+ --slot;
+ slotToArgTab[slot] = i+1; // "+1" see argSlotToParameter note
+ argToSlotTab[1+i] = slot;
+ }
+ }
+ this.argToSlotTable = argToSlotTab;
+ this.slotToArgTable = slotToArgTab;
+
+ if (pslotCount >= 256) throw newIllegalArgumentException("too many arguments");
+
+ // send a few bits down to the JVM:
+ this.vmslots = parameterSlotCount();
-class MethodTypeForm extends MethodTypeImpl {
+ // short circuit some no-op canonicalizations:
+ if (!hasPrimitives()) {
+ primsAsBoxes = erasedType;
+ primArgsAsBoxes = erasedType;
+ primsAsInts = erasedType;
+ primsAsLongs = erasedType;
+ primsAtEnd = erasedType;
+ }
+ }
+
+ /** Turn all primitive types to corresponding wrapper types.
+ */
+ public MethodType primsAsBoxes() {
+ MethodType ct = primsAsBoxes;
+ if (ct != null) return ct;
+ MethodType t = erasedType;
+ ct = canonicalize(erasedType, WRAP, WRAP);
+ if (ct == null) ct = t; // no prims to box
+ return primsAsBoxes = ct;
+ }
+
+ /** Turn all primitive argument types to corresponding wrapper types.
+ * Subword and void return types are promoted to int.
+ */
+ public MethodType primArgsAsBoxes() {
+ MethodType ct = primArgsAsBoxes;
+ if (ct != null) return ct;
+ MethodType t = erasedType;
+ ct = canonicalize(erasedType, RAW_RETURN, WRAP);
+ if (ct == null) ct = t; // no prims to box
+ return primArgsAsBoxes = ct;
+ }
+
+ /** Turn all primitive types to either int or long.
+ * Floating point return types are not changed, because
+ * they may require special calling sequences.
+ * A void return value is turned to int.
+ */
+ public MethodType primsAsInts() {
+ MethodType ct = primsAsInts;
+ if (ct != null) return ct;
+ MethodType t = erasedType;
+ ct = canonicalize(t, RAW_RETURN, INTS);
+ if (ct == null) ct = t; // no prims to int-ify
+ return primsAsInts = ct;
+ }
+
+ /** Turn all primitive types to either int or long.
+ * Floating point return types are not changed, because
+ * they may require special calling sequences.
+ * A void return value is turned to int.
+ */
+ public MethodType primsAsLongs() {
+ MethodType ct = primsAsLongs;
+ if (ct != null) return ct;
+ MethodType t = erasedType;
+ ct = canonicalize(t, RAW_RETURN, LONGS);
+ if (ct == null) ct = t; // no prims to int-ify
+ return primsAsLongs = ct;
+ }
+
+ /** Stably sort parameters into 3 buckets: ref, int, long. */
+ public MethodType primsAtEnd() {
+ MethodType ct = primsAtEnd;
+ if (ct != null) return ct;
+ MethodType t = erasedType;
+
+ int pac = primitiveParameterCount();
+ if (pac == 0)
+ return primsAtEnd = t;
+
+ int argc = parameterCount();
+ int lac = longPrimitiveParameterCount();
+ if (pac == argc && (lac == 0 || lac == argc))
+ return primsAtEnd = t;
+
+ // known to have a mix of 2 or 3 of ref, int, long
+ int[] reorder = primsAtEndOrder(t);
+ ct = reorderParameters(t, reorder, null);
+ //System.out.println("t="+t+" / reorder="+java.util.Arrays.toString(reorder)+" => "+ct);
+ return primsAtEnd = ct;
+ }
+
+ /** Compute a new ordering of parameters so that all references
+ * are before all ints or longs, and all ints are before all longs.
+ * For this ordering, doubles count as longs, and all other primitive
+ * values count as ints.
+ * As a special case, if the parameters are already in the specified
+ * order, this method returns a null reference, rather than an array
+ * specifying a null permutation.
+ * <p>
+ * For example, the type {@code (int,boolean,int,Object,String)void}
+ * produces the order {@code {3,4,0,1,2}}, the type
+ * {@code (long,int,String)void} produces {@code {2,1,2}}, and
+ * the type {@code (Object,int)Object} produces {@code null}.
+ */
+ public static int[] primsAtEndOrder(MethodType mt) {
+ MethodTypeForm form = mt.form();
+ if (form.primsAtEnd == form.erasedType)
+ // quick check shows no reordering is necessary
+ return null;
+
+ int argc = form.parameterCount();
+ int[] paramOrder = new int[argc];
+
+ // 3-way bucket sort:
+ int pac = form.primitiveParameterCount();
+ int lac = form.longPrimitiveParameterCount();
+ int rfill = 0, ifill = argc - pac, lfill = argc - lac;
- MethodTypeForm(MethodType erasedType) {
- super(erasedType);
+ Class<?>[] ptypes = mt.ptypes();
+ boolean changed = false;
+ for (int i = 0; i < ptypes.length; i++) {
+ Class<?> pt = ptypes[i];
+ int ord;
+ if (!pt.isPrimitive()) ord = rfill++;
+ else if (!hasTwoArgSlots(pt)) ord = ifill++;
+ else ord = lfill++;
+ if (ord != i) changed = true;
+ assert(paramOrder[ord] == 0);
+ paramOrder[ord] = i;
+ }
+ assert(rfill == argc - pac && ifill == argc - lac && lfill == argc);
+ if (!changed) {
+ form.primsAtEnd = form.erasedType;
+ return null;
+ }
+ return paramOrder;
+ }
+
+ /** Put the existing parameters of mt into a new order, given by newParamOrder.
+ * The third argument is logically appended to mt.parameterArray,
+ * so that elements of newParamOrder can index either pre-existing or
+ * new parameter types.
+ */
+ public static MethodType reorderParameters(MethodType mt, int[] newParamOrder, Class<?>[] moreParams) {
+ if (newParamOrder == null) return mt; // no-op reordering
+ Class<?>[] ptypes = mt.ptypes();
+ Class<?>[] ntypes = new Class<?>[newParamOrder.length];
+ int maxParam = ptypes.length + (moreParams == null ? 0 : moreParams.length);
+ boolean changed = (ntypes.length != ptypes.length);
+ for (int i = 0; i < newParamOrder.length; i++) {
+ int param = newParamOrder[i];
+ if (param != i) changed = true;
+ Class<?> nt;
+ if (param < ptypes.length) nt = ptypes[param];
+ else if (param == maxParam) nt = mt.returnType();
+ else nt = moreParams[param - ptypes.length];
+ ntypes[i] = nt;
+ }
+ if (!changed) return mt;
+ return MethodType.makeImpl(mt.returnType(), ntypes, true);
+ }
+
+ private static boolean hasTwoArgSlots(Class<?> type) {
+ return type == long.class || type == double.class;
+ }
+
+ private static long pack(int a, int b, int c, int d) {
+ assert(((a|b|c|d) & ~0xFFFF) == 0);
+ long hw = ((a << 16) | b), lw = ((c << 16) | d);
+ return (hw << 32) | lw;
+ }
+ private static char unpack(long packed, int word) { // word==0 => return a, ==3 => return d
+ assert(word <= 3);
+ return (char)(packed >> ((3-word) * 16));
+ }
+
+ public int parameterCount() { // # outgoing values
+ return unpack(argCounts, 3);
+ }
+ public int parameterSlotCount() { // # outgoing interpreter slots
+ return unpack(argCounts, 2);
+ }
+ public int returnCount() { // = 0 (V), or 1
+ return unpack(argCounts, 1);
+ }
+ public int returnSlotCount() { // = 0 (V), 2 (J/D), or 1
+ return unpack(argCounts, 0);
+ }
+ public int primitiveParameterCount() {
+ return unpack(primCounts, 3);
+ }
+ public int longPrimitiveParameterCount() {
+ return unpack(primCounts, 2);
+ }
+ public int primitiveReturnCount() { // = 0 (obj), or 1
+ return unpack(primCounts, 1);
+ }
+ public int longPrimitiveReturnCount() { // = 1 (J/D), or 0
+ return unpack(primCounts, 0);
+ }
+ public boolean hasPrimitives() {
+ return primCounts != 0;
+ }
+// public boolean hasNonVoidPrimitives() {
+// if (primCounts == 0) return false;
+// if (primitiveParameterCount() != 0) return true;
+// return (primitiveReturnCount() != 0 && returnCount() != 0);
+// }
+ public boolean hasLongPrimitives() {
+ return (longPrimitiveParameterCount() | longPrimitiveReturnCount()) != 0;
+ }
+ public int parameterToArgSlot(int i) {
+ return argToSlotTable[1+i];
+ }
+ public int argSlotToParameter(int argSlot) {
+ // Note: Empty slots are represented by zero in this table.
+ // Valid arguments slots contain incremented entries, so as to be non-zero.
+ // We return -1 the caller to mean an empty slot.
+ return slotToArgTable[argSlot] - 1;
+ }
+
+ static MethodTypeForm findForm(MethodType mt) {
+ MethodType erased = canonicalize(mt, ERASE, ERASE);
+ if (erased == null) {
+ // It is already erased. Make a new MethodTypeForm.
+ return new MethodTypeForm(mt);
+ } else {
+ // Share the MethodTypeForm with the erased version.
+ return erased.form();
+ }
}
+
+ /** Codes for {@link #canonicalize(java.lang.Class, int)}.
+ * ERASE means change every reference to {@code Object}.
+ * WRAP means convert primitives (including {@code void} to their
+ * corresponding wrapper types. UNWRAP means the reverse of WRAP.
+ * INTS means convert all non-void primitive types to int or long,
+ * according to size. LONGS means convert all non-void primitives
+ * to long, regardless of size. RAW_RETURN means convert a type
+ * (assumed to be a return type) to int if it is smaller than an int,
+ * or if it is void.
+ */
+ public static final int NO_CHANGE = 0, ERASE = 1, WRAP = 2, UNWRAP = 3, INTS = 4, LONGS = 5, RAW_RETURN = 6;
+
+ /** Canonicalize the types in the given method type.
+ * If any types change, intern the new type, and return it.
+ * Otherwise return null.
+ */
+ public static MethodType canonicalize(MethodType mt, int howRet, int howArgs) {
+ Class<?>[] ptypes = mt.ptypes();
+ Class<?>[] ptc = MethodTypeForm.canonicalizes(ptypes, howArgs);
+ Class<?> rtype = mt.returnType();
+ Class<?> rtc = MethodTypeForm.canonicalize(rtype, howRet);
+ if (ptc == null && rtc == null) {
+ // It is already canonical.
+ return null;
+ }
+ // Find the erased version of the method type:
+ if (rtc == null) rtc = rtype;
+ if (ptc == null) ptc = ptypes;
+ return MethodType.makeImpl(rtc, ptc, true);
+ }
+
+ /** Canonicalize the given return or param type.
+ * Return null if the type is already canonicalized.
+ */
+ static Class<?> canonicalize(Class<?> t, int how) {
+ Class<?> ct;
+ if (t == Object.class) {
+ // no change, ever
+ } else if (!t.isPrimitive()) {
+ switch (how) {
+ case UNWRAP:
+ ct = Wrapper.asPrimitiveType(t);
+ if (ct != t) return ct;
+ break;
+ case RAW_RETURN:
+ case ERASE:
+ return Object.class;
+ }
+ } else if (t == void.class) {
+ // no change, usually
+ switch (how) {
+ case RAW_RETURN:
+ return int.class;
+ case WRAP:
+ return Void.class;
+ }
+ } else {
+ // non-void primitive
+ switch (how) {
+ case WRAP:
+ return Wrapper.asWrapperType(t);
+ case INTS:
+ if (t == int.class || t == long.class)
+ return null; // no change
+ if (t == double.class)
+ return long.class;
+ return int.class;
+ case LONGS:
+ if (t == long.class)
+ return null; // no change
+ return long.class;
+ case RAW_RETURN:
+ if (t == int.class || t == long.class ||
+ t == float.class || t == double.class)
+ return null; // no change
+ // everything else returns as an int
+ return int.class;
+ }
+ }
+ // no change; return null to signify
+ return null;
+ }
+
+ /** Canonicalize each param type in the given array.
+ * Return null if all types are already canonicalized.
+ */
+ static Class<?>[] canonicalizes(Class<?>[] ts, int how) {
+ Class<?>[] cs = null;
+ for (int imax = ts.length, i = 0; i < imax; i++) {
+ Class<?> c = canonicalize(ts[i], how);
+ if (c != null) {
+ if (cs == null)
+ cs = ts.clone();
+ cs[i] = c;
+ }
+ }
+ return cs;
+ }
+
+ /*non-public*/ void notifyGenericMethodType() {
+ if (genericInvoker != null) return;
+ try {
+ // Trigger adapter creation.
+ genericInvoker = InvokeGeneric.genericInvokerOf(erasedType);
+ } catch (Exception ex) {
+ Error err = new InternalError("Exception while resolving invokeGeneric");
+ err.initCause(ex);
+ throw err;
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "Form"+erasedType;
+ }
+
}
--- a/jdk/src/share/classes/java/dyn/MutableCallSite.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/MutableCallSite.java Fri Mar 18 00:03:24 2011 -0700
@@ -25,8 +25,6 @@
package java.dyn;
-import sun.dyn.*;
-import sun.dyn.empty.Empty;
import java.util.concurrent.atomic.AtomicInteger;
/**
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/SpreadGeneric.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,678 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import sun.dyn.util.ValueConversions;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import static java.dyn.MethodHandleStatics.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * Generic spread adapter.
+ * Expands a final argument into multiple (zero or more) arguments, keeping the others the same.
+ * @author jrose
+ */
+class SpreadGeneric {
+ // type for the outgoing call
+ private final MethodType targetType;
+ // number of arguments to spread
+ private final int spreadCount;
+ // prototype adapter (clone and customize for each new target!)
+ private final Adapter adapter;
+ // entry point for adapter (Adapter mh, a...) => ...
+ private final MethodHandle entryPoint;
+
+ /** Compute and cache information common to all spreading adapters
+ * that accept calls of the given (generic) type.
+ */
+ private SpreadGeneric(MethodType targetType, int spreadCount) {
+ assert(targetType == targetType.generic());
+ this.targetType = targetType;
+ this.spreadCount = spreadCount;
+ // the target invoker will generally need casts on reference arguments
+ MethodHandle[] ep = { null };
+ Adapter ad = findAdapter(this, ep);
+ if (ad != null) {
+ this.adapter = ad;
+ this.entryPoint = ep[0];
+ return;
+ }
+ this.adapter = buildAdapterFromBytecodes(targetType, spreadCount, ep);
+ this.entryPoint = ep[0];
+ }
+
+ /** From targetType remove the last spreadCount arguments, and instead
+ * append a simple Object argument.
+ */
+ static MethodType preSpreadType(MethodType targetType, int spreadCount) {
+ @SuppressWarnings("unchecked")
+ ArrayList<Class<?>> params = new ArrayList(targetType.parameterList());
+ int outargs = params.size();
+ params.subList(outargs - spreadCount, outargs).clear();
+ params.add(Object.class);
+ return MethodType.methodType(targetType.returnType(), params);
+ }
+
+ MethodHandle makeInstance(MethodHandle target) {
+ MethodType type = target.type();
+ if (type != targetType) {
+ throw new UnsupportedOperationException("NYI type="+type);
+ }
+ return adapter.makeInstance(this, target);
+ }
+
+ /** Build an adapter of the given generic type, which invokes typedTarget
+ * on the incoming arguments, after unboxing as necessary.
+ * The return value is boxed if necessary.
+ * @param genericType the required type of the result
+ * @param typedTarget the target
+ * @return an adapter method handle
+ */
+ public static MethodHandle make(MethodHandle target, int spreadCount) {
+ MethodType type = target.type();
+ MethodType gtype = type.generic();
+ if (type == gtype) {
+ return SpreadGeneric.of(type, spreadCount).makeInstance(target);
+ } else {
+ MethodHandle gtarget = FromGeneric.make(target);
+ assert(gtarget.type() == gtype);
+ MethodHandle gspread = SpreadGeneric.of(gtype, spreadCount).makeInstance(gtarget);
+ return ToGeneric.make(preSpreadType(type, spreadCount), gspread);
+ }
+ }
+
+ /** Return the adapter information for this type's erasure. */
+ static SpreadGeneric of(MethodType targetType, int spreadCount) {
+ if (targetType != targetType.generic())
+ throw new UnsupportedOperationException("NYI type="+targetType);
+ MethodTypeForm form = targetType.form();
+ int outcount = form.parameterCount();
+ assert(spreadCount <= outcount);
+ SpreadGeneric[] spreadGens = form.spreadGeneric;
+ if (spreadGens == null)
+ form.spreadGeneric = spreadGens = new SpreadGeneric[outcount+1];
+ SpreadGeneric spreadGen = spreadGens[spreadCount];
+ if (spreadGen == null)
+ spreadGens[spreadCount] = spreadGen = new SpreadGeneric(form.erasedType(), spreadCount);
+ return spreadGen;
+ }
+
+ public String toString() {
+ return getClass().getSimpleName()+targetType+"["+spreadCount+"]";
+ }
+
+ // This mini-api is called from an Adapter to manage the spread.
+ /** A check/coercion that happens once before any selections. */
+ protected Object check(Object av, int n) {
+ checkSpreadArgument(av, n);
+ return av;
+ }
+
+ /** The selection operator for spreading; note that it takes Object not Object[]. */
+ protected Object select(Object av, int n) {
+ return ((Object[])av)[n];
+ }
+ /*
+ protected int select_I(Object av, int n) {
+ // maybe return ((int[])select)[n]
+ throw new UnsupportedOperationException("subclass resp.");
+ }
+ protected int select_J(Object av, int n) {
+ // maybe return ((long[])select)[n]
+ throw new UnsupportedOperationException("subclass resp.");
+ }
+ // */
+
+ /* Create an adapter that handles spreading calls for the given type. */
+ static Adapter findAdapter(SpreadGeneric outer, MethodHandle[] ep) {
+ MethodType targetType = outer.targetType;
+ int spreadCount = outer.spreadCount;
+ int outargs = targetType.parameterCount();
+ int inargs = outargs - spreadCount;
+ if (inargs < 0) return null;
+ MethodType entryType = MethodType.genericMethodType(inargs + 1); // 1 for av
+ String cname1 = "S" + outargs;
+ String[] cnames = { cname1 };
+ String iname = "invoke_S"+spreadCount;
+ // e.g., D5I2, D5, L5I2, L5; invoke_D5
+ for (String cname : cnames) {
+ Class<? extends Adapter> acls = Adapter.findSubClass(cname);
+ if (acls == null) continue;
+ // see if it has the required invoke method
+ MethodHandle entryPoint = null;
+ try {
+ entryPoint = IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
+ } catch (ReflectiveOperationException ex) {
+ }
+ if (entryPoint == null) continue;
+ Constructor<? extends Adapter> ctor = null;
+ try {
+ ctor = acls.getDeclaredConstructor(SpreadGeneric.class);
+ } catch (NoSuchMethodException ex) {
+ } catch (SecurityException ex) {
+ }
+ if (ctor == null) continue;
+ try {
+ // Produce an instance configured as a prototype.
+ Adapter ad = ctor.newInstance(outer);
+ ep[0] = entryPoint;
+ return ad;
+ } catch (IllegalArgumentException ex) {
+ } catch (InvocationTargetException wex) {
+ Throwable ex = wex.getTargetException();
+ if (ex instanceof Error) throw (Error)ex;
+ if (ex instanceof RuntimeException) throw (RuntimeException)ex;
+ } catch (InstantiationException ex) {
+ } catch (IllegalAccessException ex) {
+ }
+ }
+ return null;
+ }
+
+ static Adapter buildAdapterFromBytecodes(MethodType targetType,
+ int spreadCount, MethodHandle[] ep) {
+ throw new UnsupportedOperationException("NYI");
+ }
+
+ /**
+ * This adapter takes some untyped arguments, and returns an untyped result.
+ * Internally, it applies the invoker to the target, which causes the
+ * objects to be unboxed; the result is a raw type in L/I/J/F/D.
+ * This result is passed to convert, which is responsible for
+ * converting the raw result into a boxed object.
+ * The invoker is kept separate from the target because it can be
+ * generated once per type erasure family, and reused across adapters.
+ */
+ static abstract class Adapter extends BoundMethodHandle {
+ /*
+ * class X<<R,int M,int N>> extends Adapter {
+ * (Object**N)=>R target;
+ * static int S = N-M;
+ * Object invoke(Object**M a, Object v) = target(a..., v[0]...v[S-1]);
+ * }
+ */
+ protected final SpreadGeneric outer;
+ protected final MethodHandle target; // (any**N) => R
+
+ @Override
+ public String toString() {
+ return addTypeString(target, this);
+ }
+
+ static final MethodHandle NO_ENTRY = ValueConversions.identity();
+
+ protected boolean isPrototype() { return target == null; }
+ protected Adapter(SpreadGeneric outer) {
+ super(NO_ENTRY);
+ this.outer = outer;
+ this.target = null;
+ assert(isPrototype());
+ }
+
+ protected Adapter(SpreadGeneric outer, MethodHandle target) {
+ super(outer.entryPoint);
+ this.outer = outer;
+ this.target = target;
+ }
+
+ /** Make a copy of self, with new fields. */
+ protected abstract Adapter makeInstance(SpreadGeneric outer, MethodHandle target);
+ // { return new ThisType(outer, target); }
+
+ protected Object check(Object av, int n) {
+ return outer.check(av, n);
+ }
+ protected Object select(Object av, int n) {
+ return outer.select(av, n);
+ }
+
+ static private final String CLASS_PREFIX; // "java.dyn.SpreadGeneric$"
+ static {
+ String aname = Adapter.class.getName();
+ String sname = Adapter.class.getSimpleName();
+ if (!aname.endsWith(sname)) throw new InternalError();
+ CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
+ }
+ /** Find a sibing class of Adapter. */
+ static Class<? extends Adapter> findSubClass(String name) {
+ String cname = Adapter.CLASS_PREFIX + name;
+ try {
+ return Class.forName(cname).asSubclass(Adapter.class);
+ } catch (ClassNotFoundException ex) {
+ return null;
+ } catch (ClassCastException ex) {
+ return null;
+ }
+ }
+ }
+
+ /* generated classes follow this pattern:
+ static class xS2 extends Adapter {
+ protected xS2(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected xS2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected xS2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new xS2(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av,0);
+ return target.invokeExact(a0, a1)); }
+ protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av,1);
+ return target.invokeExact(a0,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av,1);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1)); }
+ }
+ // */
+
+/*
+: SHELL; n=SpreadGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
+//{{{
+import java.util.*;
+class genclasses {
+ static String[][] TEMPLATES = { {
+ "@for@ N=0..10",
+ " //@each-cat@",
+ " static class @cat@ extends Adapter {",
+ " protected @cat@(SpreadGeneric outer) { super(outer); } // to build prototype",
+ " protected @cat@(SpreadGeneric outer, MethodHandle t) { super(outer, t); }",
+ " protected @cat@ makeInstance(SpreadGeneric outer, MethodHandle t) { return new @cat@(outer, t); }",
+ " protected Object invoke_S0(@Tvav,@Object av) throws Throwable { av = super.check(av, 0);",
+ " return target.invokeExact(@av@); }",
+ " //@each-S@",
+ " protected Object invoke_S@S@(@Tvav,@Object av) throws Throwable { av = super.check(av, @S@);",
+ " return target.invokeExact(@av,@@sv@); }",
+ " //@end-S@",
+ " }",
+ } };
+ static final String NEWLINE_INDENT = "\n ";
+ enum VAR {
+ cat, N, S, av, av_, Tvav_, sv;
+ public final String pattern = "@"+toString().replace('_','.')+"@";
+ public String binding = toString();
+ static void makeBindings(boolean topLevel, int outargs, int spread) {
+ int inargs = outargs - spread;
+ VAR.cat.binding = "S"+outargs;
+ VAR.N.binding = String.valueOf(outargs); // outgoing arg count
+ VAR.S.binding = String.valueOf(spread); // spread count
+ String[] av = new String[inargs];
+ String[] Tvav = new String[inargs];
+ for (int i = 0; i < inargs; i++) {
+ av[i] = arg(i);
+ Tvav[i] = param("Object", av[i]);
+ }
+ VAR.av.binding = comma(av);
+ VAR.av_.binding = comma(av, ", ");
+ VAR.Tvav_.binding = comma(Tvav, ", ");
+ String[] sv = new String[spread];
+ for (int i = 0; i < spread; i++) {
+ String spc = "";
+ if (i % 4 == 0) spc = NEWLINE_INDENT;
+ sv[i] = spc+"super.select(av,"+i+")";
+ }
+ VAR.sv.binding = comma(sv);
+ }
+ static String arg(int i) { return "a"+i; }
+ static String param(String t, String a) { return t+" "+a; }
+ static String comma(String[] v) { return comma(v, ""); }
+ static String comma(String[] v, String sep) {
+ if (v.length == 0) return "";
+ String res = v[0];
+ for (int i = 1; i < v.length; i++) res += ", "+v[i];
+ return res + sep;
+ }
+ static String transform(String string) {
+ for (VAR var : values())
+ string = string.replaceAll(var.pattern, var.binding);
+ return string;
+ }
+ }
+ static String[] stringsIn(String[] strings, int beg, int end) {
+ return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
+ }
+ static String[] stringsBefore(String[] strings, int pos) {
+ return stringsIn(strings, 0, pos);
+ }
+ static String[] stringsAfter(String[] strings, int pos) {
+ return stringsIn(strings, pos, strings.length);
+ }
+ static int indexAfter(String[] strings, int pos, String tag) {
+ return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
+ }
+ static int indexBefore(String[] strings, int pos, String tag) {
+ for (int i = pos, end = strings.length; ; i++) {
+ if (i == end || strings[i].endsWith(tag)) return i;
+ }
+ }
+ static int MIN_ARITY, MAX_ARITY;
+ public static void main(String... av) {
+ for (String[] template : TEMPLATES) {
+ int forLinesLimit = indexBefore(template, 0, "@each-cat@");
+ String[] forLines = stringsBefore(template, forLinesLimit);
+ template = stringsAfter(template, forLinesLimit);
+ for (String forLine : forLines)
+ expandTemplate(forLine, template);
+ }
+ }
+ static void expandTemplate(String forLine, String[] template) {
+ String[] params = forLine.split("[^0-9]+");
+ if (params[0].length() == 0) params = stringsAfter(params, 1);
+ System.out.println("//params="+Arrays.asList(params));
+ int pcur = 0;
+ MIN_ARITY = Integer.valueOf(params[pcur++]);
+ MAX_ARITY = Integer.valueOf(params[pcur++]);
+ if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
+ for (int outargs = MIN_ARITY; outargs <= MAX_ARITY; outargs++) {
+ expandTemplate(template, true, outargs, 0);
+ }
+ }
+ static void expandTemplate(String[] template, boolean topLevel, int outargs, int spread) {
+ VAR.makeBindings(topLevel, outargs, spread);
+ for (int i = 0; i < template.length; i++) {
+ String line = template[i];
+ if (line.endsWith("@each-cat@")) {
+ // ignore
+ } else if (line.endsWith("@each-S@")) {
+ int blockEnd = indexAfter(template, i, "@end-S@");
+ String[] block = stringsIn(template, i+1, blockEnd-1);
+ for (int spread1 = spread+1; spread1 <= outargs; spread1++)
+ expandTemplate(block, false, outargs, spread1);
+ VAR.makeBindings(topLevel, outargs, spread);
+ i = blockEnd-1; continue;
+ } else {
+ System.out.println(VAR.transform(line));
+ }
+ }
+ }
+}
+//}}} */
+//params=[0, 10]
+ static class S0 extends Adapter {
+ protected S0(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S0(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S0 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S0(outer, t); }
+ protected Object invoke_S0(Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(); }
+ }
+ static class S1 extends Adapter {
+ protected S1(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S1(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S1 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S1(outer, t); }
+ protected Object invoke_S0(Object a0, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0); }
+ protected Object invoke_S1(Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(
+ super.select(av,0)); }
+ }
+ static class S2 extends Adapter {
+ protected S2(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S2(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1); }
+ protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1)); }
+ }
+ static class S3 extends Adapter {
+ protected S3(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S3(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S3 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S3(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2); }
+ protected Object invoke_S1(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ }
+ static class S4 extends Adapter {
+ protected S4(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S4(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S4 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S4(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2, a3); }
+ protected Object invoke_S1(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1, a2,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0, a1,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object a0, Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ protected Object invoke_S4(Object av) throws Throwable { av = super.check(av, 4);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
+ }
+ static class S5 extends Adapter {
+ protected S5(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S5(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S5 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S5(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2, a3, a4); }
+ protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1, a2, a3,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0, a1, a2,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(a0, a1,
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ protected Object invoke_S4(Object a0, Object av) throws Throwable { av = super.check(av, 4);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
+ protected Object invoke_S5(Object av) throws Throwable { av = super.check(av, 5);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4)); }
+ }
+ static class S6 extends Adapter {
+ protected S6(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S6(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S6 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S6(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1, a2, a3, a4,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0, a1, a2, a3,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(a0, a1, a2,
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ protected Object invoke_S4(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 4);
+ return target.invokeExact(a0, a1,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
+ protected Object invoke_S5(Object a0, Object av) throws Throwable { av = super.check(av, 5);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4)); }
+ protected Object invoke_S6(Object av) throws Throwable { av = super.check(av, 6);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5)); }
+ }
+ static class S7 extends Adapter {
+ protected S7(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S7(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S7 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S7(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0, a1, a2, a3, a4,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(a0, a1, a2, a3,
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ protected Object invoke_S4(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 4);
+ return target.invokeExact(a0, a1, a2,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
+ protected Object invoke_S5(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 5);
+ return target.invokeExact(a0, a1,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4)); }
+ protected Object invoke_S6(Object a0, Object av) throws Throwable { av = super.check(av, 6);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5)); }
+ protected Object invoke_S7(Object av) throws Throwable { av = super.check(av, 7);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6)); }
+ }
+ static class S8 extends Adapter {
+ protected S8(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S8(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S8 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S8(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(a0, a1, a2, a3, a4,
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 4);
+ return target.invokeExact(a0, a1, a2, a3,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
+ protected Object invoke_S5(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 5);
+ return target.invokeExact(a0, a1, a2,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4)); }
+ protected Object invoke_S6(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 6);
+ return target.invokeExact(a0, a1,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5)); }
+ protected Object invoke_S7(Object a0, Object av) throws Throwable { av = super.check(av, 7);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6)); }
+ protected Object invoke_S8(Object av) throws Throwable { av = super.check(av, 8);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
+ }
+ static class S9 extends Adapter {
+ protected S9(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S9(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S9 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S9(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5,
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 4);
+ return target.invokeExact(a0, a1, a2, a3, a4,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
+ protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 5);
+ return target.invokeExact(a0, a1, a2, a3,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4)); }
+ protected Object invoke_S6(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 6);
+ return target.invokeExact(a0, a1, a2,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5)); }
+ protected Object invoke_S7(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 7);
+ return target.invokeExact(a0, a1,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6)); }
+ protected Object invoke_S8(Object a0, Object av) throws Throwable { av = super.check(av, 8);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
+ protected Object invoke_S9(Object av) throws Throwable { av = super.check(av, 9);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
+ super.select(av,8)); }
+ }
+ static class S10 extends Adapter {
+ protected S10(SpreadGeneric outer) { super(outer); } // to build prototype
+ protected S10(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
+ protected S10 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S10(outer, t); }
+ protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9, Object av) throws Throwable { av = super.check(av, 0);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object av) throws Throwable { av = super.check(av, 1);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8,
+ super.select(av,0)); }
+ protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 2);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
+ super.select(av,0), super.select(av,1)); }
+ protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 3);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
+ super.select(av,0), super.select(av,1), super.select(av,2)); }
+ protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 4);
+ return target.invokeExact(a0, a1, a2, a3, a4, a5,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
+ protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 5);
+ return target.invokeExact(a0, a1, a2, a3, a4,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4)); }
+ protected Object invoke_S6(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 6);
+ return target.invokeExact(a0, a1, a2, a3,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5)); }
+ protected Object invoke_S7(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 7);
+ return target.invokeExact(a0, a1, a2,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6)); }
+ protected Object invoke_S8(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 8);
+ return target.invokeExact(a0, a1,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
+ protected Object invoke_S9(Object a0, Object av) throws Throwable { av = super.check(av, 9);
+ return target.invokeExact(a0,
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
+ super.select(av,8)); }
+ protected Object invoke_S10(Object av) throws Throwable { av = super.check(av, 10);
+ return target.invokeExact(
+ super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
+ super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
+ super.select(av,8), super.select(av,9)); }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/dyn/ToGeneric.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,1041 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.dyn;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import sun.dyn.util.ValueConversions;
+import sun.dyn.util.Wrapper;
+import static java.dyn.MethodHandleStatics.*;
+import static java.dyn.MethodHandles.Lookup.IMPL_LOOKUP;
+
+/**
+ * Adapters which mediate between incoming calls which are not generic
+ * and outgoing calls which are. Any call can be represented generically
+ * boxing up its arguments, and (on return) unboxing the return value.
+ * <p>
+ * A call is "generic" (in MethodHandle terms) if its MethodType features
+ * only Object arguments. A non-generic call therefore features
+ * primitives and/or reference types other than Object.
+ * An adapter has types for its incoming and outgoing calls.
+ * The incoming call type is simply determined by the adapter's type
+ * (the MethodType it presents to callers). The outgoing call type
+ * is determined by the adapter's target (a MethodHandle that the adapter
+ * either binds internally or else takes as a leading argument).
+ * (To stretch the term, adapter-like method handles may have multiple
+ * targets or be polymorphic across multiple call types.)
+ * @author jrose
+ */
+class ToGeneric {
+ // type for the incoming call (may be erased)
+ private final MethodType entryType;
+ // incoming type with primitives moved to the end and turned to int/long
+ private final MethodType rawEntryType;
+ // adapter for the erased type
+ private final Adapter adapter;
+ // entry point for adapter (Adapter mh, a...) => ...
+ private final MethodHandle entryPoint;
+ // permutation of arguments for primsAtEndType
+ private final int[] primsAtEndOrder;
+ // optional final argument list conversions (at least, invokes the target)
+ private final MethodHandle invoker;
+ // conversion which unboxes a primitive return value
+ private final MethodHandle returnConversion;
+
+ /** Compute and cache information common to all generifying (boxing) adapters
+ * that implement members of the erasure-family of the given erased type.
+ */
+ private ToGeneric(MethodType entryType) {
+ assert(entryType.erase() == entryType); // for now
+ // incoming call will first "forget" all reference types except Object
+ this.entryType = entryType;
+ MethodHandle invoker0 = entryType.generic().invokers().exactInvoker();
+ MethodType rawEntryTypeInit;
+ Adapter ad = findAdapter(rawEntryTypeInit = entryType);
+ if (ad != null) {
+ // Immediate hit to exactly the adapter we want,
+ // with no monkeying around with primitive types.
+ this.returnConversion = computeReturnConversion(entryType, rawEntryTypeInit, false);
+ this.rawEntryType = rawEntryTypeInit;
+ this.adapter = ad;
+ this.entryPoint = ad.prototypeEntryPoint();
+ this.primsAtEndOrder = null;
+ this.invoker = invoker0;
+ return;
+ }
+
+ // next, it will reorder primitives after references
+ MethodType primsAtEnd = entryType.form().primsAtEnd();
+ // at the same time, it will "forget" all primitive types except int/long
+ this.primsAtEndOrder = MethodTypeForm.primsAtEndOrder(entryType);
+ if (primsAtEndOrder != null) {
+ // reordering is required; build on top of a simpler ToGeneric
+ ToGeneric va2 = ToGeneric.of(primsAtEnd);
+ this.adapter = va2.adapter;
+ if (true) throw new UnsupportedOperationException("NYI: primitive parameters must follow references; entryType = "+entryType);
+ this.entryPoint = MethodHandleImpl.convertArguments(
+ va2.entryPoint, primsAtEnd, entryType, primsAtEndOrder);
+ // example: for entryType of (int,Object,Object), the reordered
+ // type is (Object,Object,int) and the order is {1,2,0},
+ // and putPAE is (mh,int0,obj1,obj2) => mh.invokeExact(obj1,obj2,int0)
+ return;
+ }
+
+ // after any needed argument reordering, it will reinterpret
+ // primitive arguments according to their "raw" types int/long
+ MethodType intsAtEnd = primsAtEnd.form().primsAsInts();
+ ad = findAdapter(rawEntryTypeInit = intsAtEnd);
+ MethodHandle rawEntryPoint;
+ if (ad != null) {
+ rawEntryPoint = ad.prototypeEntryPoint();
+ } else {
+ // Perhaps the adapter is available only for longs.
+ // If so, we can use it, but there will have to be a little
+ // more stack motion on each call.
+ MethodType longsAtEnd = primsAtEnd.form().primsAsLongs();
+ ad = findAdapter(rawEntryTypeInit = longsAtEnd);
+ if (ad != null) {
+ MethodType eptWithLongs = longsAtEnd.insertParameterTypes(0, ad.getClass());
+ MethodType eptWithInts = intsAtEnd.insertParameterTypes(0, ad.getClass());
+ rawEntryPoint = ad.prototypeEntryPoint();
+ MethodType midType = eptWithLongs; // will change longs to ints
+ for (int i = 0, nargs = midType.parameterCount(); i < nargs; i++) {
+ if (midType.parameterType(i) != eptWithInts.parameterType(i)) {
+ assert(midType.parameterType(i) == long.class);
+ assert(eptWithInts.parameterType(i) == int.class);
+ MethodType nextType = midType.changeParameterType(i, int.class);
+ rawEntryPoint = MethodHandleImpl.convertArguments(
+ rawEntryPoint, nextType, midType, null);
+ midType = nextType;
+ }
+ }
+ assert(midType == eptWithInts);
+ } else {
+ // If there is no statically compiled adapter,
+ // build one by means of dynamic bytecode generation.
+ ad = buildAdapterFromBytecodes(rawEntryTypeInit = intsAtEnd);
+ rawEntryPoint = ad.prototypeEntryPoint();
+ }
+ }
+ MethodType tepType = entryType.insertParameterTypes(0, ad.getClass());
+ this.entryPoint =
+ AdapterMethodHandle.makeRetypeRaw(tepType, rawEntryPoint);
+ if (this.entryPoint == null)
+ throw new UnsupportedOperationException("cannot retype to "+entryType
+ +" from "+rawEntryPoint.type().dropParameterTypes(0, 1));
+ this.returnConversion = computeReturnConversion(entryType, rawEntryTypeInit, false);
+ this.rawEntryType = rawEntryTypeInit;
+ this.adapter = ad;
+ this.invoker = makeRawArgumentFilter(invoker0, rawEntryTypeInit, entryType);
+ }
+
+ /** A generic argument list will be created by a call of type 'raw'.
+ * The values need to be reboxed for to match 'cooked'.
+ * Do this on the fly.
+ */
+ // TO DO: Use a generic argument converter in a different file
+ static MethodHandle makeRawArgumentFilter(MethodHandle invoker,
+ MethodType raw, MethodType cooked) {
+ MethodHandle filteredInvoker = null;
+ for (int i = 0, nargs = raw.parameterCount(); i < nargs; i++) {
+ Class<?> src = raw.parameterType(i);
+ Class<?> dst = cooked.parameterType(i);
+ if (src == dst) continue;
+ assert(src.isPrimitive() && dst.isPrimitive());
+ if (filteredInvoker == null) {
+ filteredInvoker =
+ AdapterMethodHandle.makeCheckCast(
+ invoker.type().generic(), invoker, 0, MethodHandle.class);
+ if (filteredInvoker == null) throw new UnsupportedOperationException("NYI");
+ }
+ MethodHandle reboxer = ValueConversions.rebox(dst, false);
+ filteredInvoker = FilterGeneric.makeArgumentFilter(1+i, reboxer, filteredInvoker);
+ if (filteredInvoker == null) throw new InternalError();
+ }
+ if (filteredInvoker == null) return invoker;
+ return AdapterMethodHandle.makeRetypeOnly(invoker.type(), filteredInvoker);
+ }
+
+ /**
+ * Caller will be expecting a result from a call to {@code type},
+ * while the internal adapter entry point is rawEntryType.
+ * Also, the internal target method will be returning a boxed value,
+ * as an untyped object.
+ * <p>
+ * Produce a value converter which will be typed to convert from
+ * {@code Object} to the return value of {@code rawEntryType}, and will
+ * in fact ensure that the value is compatible with the return type of
+ * {@code type}.
+ */
+ private static MethodHandle computeReturnConversion(
+ MethodType type, MethodType rawEntryType, boolean mustCast) {
+ Class<?> tret = type.returnType();
+ Class<?> rret = rawEntryType.returnType();
+ if (mustCast || !tret.isPrimitive()) {
+ assert(!tret.isPrimitive());
+ assert(!rret.isPrimitive());
+ if (rret == Object.class && !mustCast)
+ return null;
+ return ValueConversions.cast(tret, false);
+ } else if (tret == rret) {
+ return ValueConversions.unbox(tret, false);
+ } else {
+ assert(rret.isPrimitive());
+ assert(tret == double.class ? rret == long.class : rret == int.class);
+ return ValueConversions.unboxRaw(tret, false);
+ }
+ }
+
+ Adapter makeInstance(MethodType type, MethodHandle genericTarget) {
+ genericTarget.getClass(); // check for NPE
+ MethodHandle convert = returnConversion;
+ if (primsAtEndOrder != null)
+ // reorder arguments passed to genericTarget, if primsAtEndOrder
+ throw new UnsupportedOperationException("NYI");
+ if (type == entryType) {
+ if (convert == null) convert = ValueConversions.identity();
+ return adapter.makeInstance(entryPoint, invoker, convert, genericTarget);
+ }
+ // my erased-type is not exactly the same as the desired type
+ assert(type.erase() == entryType); // else we are busted
+ if (convert == null)
+ convert = computeReturnConversion(type, rawEntryType, true);
+ // retype erased reference arguments (the cast makes it safe to do this)
+ MethodType tepType = type.insertParameterTypes(0, adapter.getClass());
+ MethodHandle typedEntryPoint =
+ AdapterMethodHandle.makeRetypeRaw(tepType, entryPoint);
+ return adapter.makeInstance(typedEntryPoint, invoker, convert, genericTarget);
+ }
+
+ /** Build an adapter of the given type, which invokes genericTarget
+ * on the incoming arguments, after boxing as necessary.
+ * The return value is unboxed if necessary.
+ * @param type the required type of the
+ * @param genericTarget the target, which must accept and return only Object values
+ * @return an adapter method handle
+ */
+ public static MethodHandle make(MethodType type, MethodHandle genericTarget) {
+ MethodType gtype = genericTarget.type();
+ if (type.generic() != gtype)
+ throw newIllegalArgumentException("type must be generic");
+ if (type == gtype) return genericTarget;
+ return ToGeneric.of(type).makeInstance(type, genericTarget);
+ }
+
+ /** Return the adapter information for this type's erasure. */
+ static ToGeneric of(MethodType type) {
+ MethodTypeForm form = type.form();
+ ToGeneric toGen = form.toGeneric;
+ if (toGen == null)
+ form.toGeneric = toGen = new ToGeneric(form.erasedType());
+ return toGen;
+ }
+
+ public String toString() {
+ return "ToGeneric"+entryType
+ +(primsAtEndOrder!=null?"[reorder]":"");
+ }
+
+ /* Create an adapter for the given incoming call type. */
+ static Adapter findAdapter(MethodType entryPointType) {
+ MethodTypeForm form = entryPointType.form();
+ Class<?> rtype = entryPointType.returnType();
+ int argc = form.parameterCount();
+ int lac = form.longPrimitiveParameterCount();
+ int iac = form.primitiveParameterCount() - lac;
+ String intsAndLongs = (iac > 0 ? "I"+iac : "")+(lac > 0 ? "J"+lac : "");
+ String rawReturn = String.valueOf(Wrapper.forPrimitiveType(rtype).basicTypeChar());
+ String iname0 = "invoke_"+rawReturn;
+ String iname1 = "invoke";
+ String[] inames = { iname0, iname1 };
+ String cname0 = rawReturn + argc;
+ String cname1 = "A" + argc;
+ String[] cnames = { cname1, cname1+intsAndLongs, cname0, cname0+intsAndLongs };
+ // e.g., D5I2, D5, L5I2, L5
+ for (String cname : cnames) {
+ Class<? extends Adapter> acls = Adapter.findSubClass(cname);
+ if (acls == null) continue;
+ // see if it has the required invoke method
+ for (String iname : inames) {
+ MethodHandle entryPoint = null;
+ try {
+ entryPoint = IMPL_LOOKUP.
+ findSpecial(acls, iname, entryPointType, acls);
+ } catch (ReflectiveOperationException ex) {
+ }
+ if (entryPoint == null) continue;
+ Constructor<? extends Adapter> ctor = null;
+ try {
+ // Prototype builder:
+ ctor = acls.getDeclaredConstructor(MethodHandle.class);
+ } catch (NoSuchMethodException ex) {
+ } catch (SecurityException ex) {
+ }
+ if (ctor == null) continue;
+ try {
+ return ctor.newInstance(entryPoint);
+ } catch (IllegalArgumentException ex) {
+ } catch (InvocationTargetException wex) {
+ Throwable ex = wex.getTargetException();
+ if (ex instanceof Error) throw (Error)ex;
+ if (ex instanceof RuntimeException) throw (RuntimeException)ex;
+ } catch (InstantiationException ex) {
+ } catch (IllegalAccessException ex) {
+ }
+ }
+ }
+ return null;
+ }
+
+ static Adapter buildAdapterFromBytecodes(MethodType entryPointType) {
+ throw new UnsupportedOperationException("NYI");
+ }
+
+ /**
+ * The invoke method takes some particular but unconstrained spread
+ * of raw argument types, and returns a raw return type (in L/I/J/F/D).
+ * Internally, it converts the incoming arguments uniformly into objects.
+ * This series of objects is then passed to the {@code target} method,
+ * which returns a result object. This result is finally converted,
+ * via another method handle {@code convert}, which is responsible for
+ * converting the object result into the raw return value.
+ */
+ static abstract class Adapter extends BoundMethodHandle {
+ /*
+ * class X<<R,A...>> extends Adapter {
+ * Object...=>Object target;
+ * Object=>R convert;
+ * R invoke(A... a...) = convert(invoker(target, a...)))
+ * }
+ */
+ protected final MethodHandle invoker; // (MH, Object...) -> Object
+ protected final MethodHandle target; // Object... -> Object
+ protected final MethodHandle convert; // Object -> R
+
+ @Override
+ public String toString() {
+ return target == null ? "prototype:"+convert : addTypeString(target, this);
+ }
+
+ protected boolean isPrototype() { return target == null; }
+ /* Prototype constructor. */
+ protected Adapter(MethodHandle entryPoint) {
+ super(entryPoint);
+ this.invoker = null;
+ this.convert = entryPoint;
+ this.target = null;
+ assert(isPrototype());
+ }
+ protected MethodHandle prototypeEntryPoint() {
+ if (!isPrototype()) throw new InternalError();
+ return convert;
+ }
+
+ protected Adapter(MethodHandle entryPoint, MethodHandle invoker, MethodHandle convert, MethodHandle target) {
+ super(entryPoint);
+ this.invoker = invoker;
+ this.convert = convert;
+ this.target = target;
+ }
+
+ /** Make a copy of self, with new fields. */
+ protected abstract Adapter makeInstance(MethodHandle entryPoint,
+ MethodHandle invoker, MethodHandle convert, MethodHandle target);
+ // { return new ThisType(entryPoint, convert, target); }
+
+ // Code to run when the arguments (<= 4) have all been boxed.
+ protected Object target() throws Throwable { return invoker.invokeExact(target); }
+ protected Object target(Object a0) throws Throwable { return invoker.invokeExact(target, a0); }
+ protected Object target(Object a0, Object a1)
+ throws Throwable { return invoker.invokeExact(target, a0, a1); }
+ protected Object target(Object a0, Object a1, Object a2)
+ throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3)
+ throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
+ /*
+ protected Object target_0(Object... av) throws Throwable { return invoker.invokeExact(target, av); }
+ protected Object target_1(Object a0, Object... av)
+ throws Throwable { return invoker.invokeExact(target, a0, (Object)av); }
+ protected Object target_2(Object a0, Object a1, Object... av)
+ throws Throwable { return invoker.invokeExact(target, a0, a1, (Object)av); }
+ protected Object target_3(Object a0, Object a1, Object a2, Object... av)
+ throws Throwable { return invoker.invokeExact(target, a0, a1, a2, (Object)av); }
+ protected Object target_4(Object a0, Object a1, Object a2, Object a3, Object... av)
+ throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, (Object)av); }
+ // */
+ // (For more than 4 arguments, generate the code in the adapter itself.)
+
+ // Code to run when the generic target has finished and produced a value.
+ protected Object return_L(Object res) throws Throwable { return (Object)convert.invokeExact(res); }
+ protected int return_I(Object res) throws Throwable { return (int) convert.invokeExact(res); }
+ protected long return_J(Object res) throws Throwable { return (long) convert.invokeExact(res); }
+ protected float return_F(Object res) throws Throwable { return (float) convert.invokeExact(res); }
+ protected double return_D(Object res) throws Throwable { return (double)convert.invokeExact(res); }
+
+ static private final String CLASS_PREFIX; // "java.dyn.ToGeneric$"
+ static {
+ String aname = Adapter.class.getName();
+ String sname = Adapter.class.getSimpleName();
+ if (!aname.endsWith(sname)) throw new InternalError();
+ CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
+ }
+ /** Find a sibing class of Adapter. */
+ static Class<? extends Adapter> findSubClass(String name) {
+ String cname = Adapter.CLASS_PREFIX + name;
+ try {
+ return Class.forName(cname).asSubclass(Adapter.class);
+ } catch (ClassNotFoundException ex) {
+ return null;
+ } catch (ClassCastException ex) {
+ return null;
+ }
+ }
+ }
+
+ /* generated classes follow this pattern:
+ static class A1 extends Adapter {
+ protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
+ protected Object target(Object a0) throws Throwable { return invoker.invokeExact(target, a0); }
+ protected Object targetA1(Object a0) throws Throwable { return target(a0); }
+ protected Object targetA1(int a0) throws Throwable { return target(a0); }
+ protected Object targetA1(long a0) throws Throwable { return target(a0); }
+ protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
+ protected int invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
+ protected long invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
+ protected float invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
+ protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
+ protected Object invoke_L(int a0) throws Throwable { return return_L(targetA1(a0)); }
+ protected int invoke_I(int a0) throws Throwable { return return_I(targetA1(a0)); }
+ protected long invoke_J(int a0) throws Throwable { return return_J(targetA1(a0)); }
+ protected float invoke_F(int a0) throws Throwable { return return_F(targetA1(a0)); }
+ protected double invoke_D(int a0) throws Throwable { return return_D(targetA1(a0)); }
+ protected Object invoke_L(long a0) throws Throwable { return return_L(targetA1(a0)); }
+ protected int invoke_I(long a0) throws Throwable { return return_I(targetA1(a0)); }
+ protected long invoke_J(long a0) throws Throwable { return return_J(targetA1(a0)); }
+ protected float invoke_F(long a0) throws Throwable { return return_F(targetA1(a0)); }
+ protected double invoke_D(long a0) throws Throwable { return return_D(targetA1(a0)); }
+ }
+ // */
+
+/*
+: SHELL; n=ToGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
+//{{{
+import java.util.*;
+class genclasses {
+ static String[] TYPES = { "Object", "int ", "long ", "float ", "double" };
+ static String[] TCHARS = { "L", "I", "J", "F", "D", "A" };
+ static String[][] TEMPLATES = { {
+ "@for@ arity=0..3 rcat<=4 nrefs<=99 nints<=99 nlongs<=99",
+ "@for@ arity=4..5 rcat<=2 nrefs<=99 nints<=99 nlongs<=99",
+ "@for@ arity=6..10 rcat<=2 nrefs<=99 nints=0 nlongs<=99",
+ " //@each-cat@",
+ " static class @cat@ extends Adapter {",
+ " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
+ " protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }",
+ " protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new @cat@(e, i, c, t); }",
+ " protected Object target(@Ovav@) throws Throwable { return invoker.invokeExact(target, @av@); }",
+ " //@each-Tv@",
+ " protected Object target@cat@(@Tvav@) throws Throwable { return target(@av@); }",
+ " //@end-Tv@",
+ " //@each-Tv@",
+ " //@each-R@",
+ " protected @R@ invoke_@Rc@(@Tvav@) throws Throwable { return return_@Rc@(target@cat@(@av@)); }",
+ " //@end-R@",
+ " //@end-Tv@",
+ " }",
+ } };
+ enum VAR {
+ cat, R, Rc, Tv, av, Tvav, Ovav;
+ public final String pattern = "@"+toString().replace('_','.')+"@";
+ public String binding;
+ static void makeBindings(boolean topLevel, int rcat, int nrefs, int nints, int nlongs) {
+ int nargs = nrefs + nints + nlongs;
+ if (topLevel)
+ VAR.cat.binding = catstr(ALL_RETURN_TYPES ? TYPES.length : rcat, nrefs, nints, nlongs);
+ VAR.R.binding = TYPES[rcat];
+ VAR.Rc.binding = TCHARS[rcat];
+ String[] Tv = new String[nargs];
+ String[] av = new String[nargs];
+ String[] Tvav = new String[nargs];
+ String[] Ovav = new String[nargs];
+ for (int i = 0; i < nargs; i++) {
+ int tcat = (i < nrefs) ? 0 : (i < nrefs + nints) ? 1 : 2;
+ Tv[i] = TYPES[tcat];
+ av[i] = arg(i);
+ Tvav[i] = param(Tv[i], av[i]);
+ Ovav[i] = param("Object", av[i]);
+ }
+ VAR.Tv.binding = comma(Tv);
+ VAR.av.binding = comma(av);
+ VAR.Tvav.binding = comma(Tvav);
+ VAR.Ovav.binding = comma(Ovav);
+ }
+ static String arg(int i) { return "a"+i; }
+ static String param(String t, String a) { return t+" "+a; }
+ static String comma(String[] v) { return comma(v, ""); }
+ static String comma(String sep, String[] v) {
+ if (v.length == 0) return "";
+ String res = sep+v[0];
+ for (int i = 1; i < v.length; i++) res += ", "+v[i];
+ return res;
+ }
+ static String transform(String string) {
+ for (VAR var : values())
+ string = string.replaceAll(var.pattern, var.binding);
+ return string;
+ }
+ }
+ static String[] stringsIn(String[] strings, int beg, int end) {
+ return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
+ }
+ static String[] stringsBefore(String[] strings, int pos) {
+ return stringsIn(strings, 0, pos);
+ }
+ static String[] stringsAfter(String[] strings, int pos) {
+ return stringsIn(strings, pos, strings.length);
+ }
+ static int indexAfter(String[] strings, int pos, String tag) {
+ return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
+ }
+ static int indexBefore(String[] strings, int pos, String tag) {
+ for (int i = pos, end = strings.length; ; i++) {
+ if (i == end || strings[i].endsWith(tag)) return i;
+ }
+ }
+ static int MIN_ARITY, MAX_ARITY, MAX_RCAT, MAX_REFS, MAX_INTS, MAX_LONGS;
+ static boolean ALL_ARG_TYPES, ALL_RETURN_TYPES;
+ static HashSet<String> done = new HashSet<String>();
+ public static void main(String... av) {
+ for (String[] template : TEMPLATES) {
+ int forLinesLimit = indexBefore(template, 0, "@each-cat@");
+ String[] forLines = stringsBefore(template, forLinesLimit);
+ template = stringsAfter(template, forLinesLimit);
+ for (String forLine : forLines)
+ expandTemplate(forLine, template);
+ }
+ }
+ static void expandTemplate(String forLine, String[] template) {
+ String[] params = forLine.split("[^0-9]+");
+ if (params[0].length() == 0) params = stringsAfter(params, 1);
+ System.out.println("//params="+Arrays.asList(params));
+ int pcur = 0;
+ MIN_ARITY = Integer.valueOf(params[pcur++]);
+ MAX_ARITY = Integer.valueOf(params[pcur++]);
+ MAX_RCAT = Integer.valueOf(params[pcur++]);
+ MAX_REFS = Integer.valueOf(params[pcur++]);
+ MAX_INTS = Integer.valueOf(params[pcur++]);
+ MAX_LONGS = Integer.valueOf(params[pcur++]);
+ if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
+ if (MAX_RCAT >= TYPES.length) MAX_RCAT = TYPES.length - 1;
+ ALL_ARG_TYPES = (indexBefore(template, 0, "@each-Tv@") < template.length);
+ ALL_RETURN_TYPES = (indexBefore(template, 0, "@each-R@") < template.length);
+ for (int nargs = MIN_ARITY; nargs <= MAX_ARITY; nargs++) {
+ for (int rcat = 0; rcat <= MAX_RCAT; rcat++) {
+ expandTemplate(template, true, rcat, nargs, 0, 0);
+ if (ALL_ARG_TYPES) break;
+ expandTemplateForPrims(template, true, rcat, nargs, 1, 1);
+ if (ALL_RETURN_TYPES) break;
+ }
+ }
+ }
+ static String catstr(int rcat, int nrefs, int nints, int nlongs) {
+ int nargs = nrefs + nints + nlongs;
+ String cat = TCHARS[rcat] + nargs;
+ if (!ALL_ARG_TYPES) cat += (nints==0?"":"I"+nints)+(nlongs==0?"":"J"+nlongs);
+ return cat;
+ }
+ static void expandTemplateForPrims(String[] template, boolean topLevel, int rcat, int nargs, int minints, int minlongs) {
+ for (int isLong = 0; isLong <= 1; isLong++) {
+ for (int nprims = 1; nprims <= nargs; nprims++) {
+ int nrefs = nargs - nprims;
+ int nints = ((1-isLong) * nprims);
+ int nlongs = (isLong * nprims);
+ expandTemplate(template, topLevel, rcat, nrefs, nints, nlongs);
+ }
+ }
+ }
+ static void expandTemplate(String[] template, boolean topLevel,
+ int rcat, int nrefs, int nints, int nlongs) {
+ int nargs = nrefs + nints + nlongs;
+ if (nrefs > MAX_REFS || nints > MAX_INTS || nlongs > MAX_LONGS) return;
+ VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
+ if (topLevel && !done.add(VAR.cat.binding)) {
+ System.out.println(" //repeat "+VAR.cat.binding);
+ return;
+ }
+ for (int i = 0; i < template.length; i++) {
+ String line = template[i];
+ if (line.endsWith("@each-cat@")) {
+ // ignore
+ } else if (line.endsWith("@each-R@")) {
+ int blockEnd = indexAfter(template, i, "@end-R@");
+ String[] block = stringsIn(template, i+1, blockEnd-1);
+ for (int rcat1 = rcat; rcat1 <= MAX_RCAT; rcat1++)
+ expandTemplate(block, false, rcat1, nrefs, nints, nlongs);
+ VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
+ i = blockEnd-1; continue;
+ } else if (line.endsWith("@each-Tv@")) {
+ int blockEnd = indexAfter(template, i, "@end-Tv@");
+ String[] block = stringsIn(template, i+1, blockEnd-1);
+ expandTemplate(block, false, rcat, nrefs, nints, nlongs);
+ expandTemplateForPrims(block, false, rcat, nargs, nints+1, nlongs+1);
+ VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
+ i = blockEnd-1; continue;
+ } else {
+ System.out.println(VAR.transform(line));
+ }
+ }
+ }
+}
+//}}} */
+//params=[0, 3, 4, 99, 99, 99]
+ static class A0 extends Adapter {
+ protected A0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A0(e, i, c, t); }
+ protected Object target() throws Throwable { return invoker.invokeExact(target); }
+ protected Object targetA0() throws Throwable { return target(); }
+ protected Object invoke_L() throws Throwable { return return_L(targetA0()); }
+ protected int invoke_I() throws Throwable { return return_I(targetA0()); }
+ protected long invoke_J() throws Throwable { return return_J(targetA0()); }
+ protected float invoke_F() throws Throwable { return return_F(targetA0()); }
+ protected double invoke_D() throws Throwable { return return_D(targetA0()); }
+ }
+ static class A1 extends Adapter {
+ protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
+ protected Object target(Object a0) throws Throwable { return invoker.invokeExact(target, a0); }
+ protected Object targetA1(Object a0) throws Throwable { return target(a0); }
+ protected Object targetA1(int a0) throws Throwable { return target(a0); }
+ protected Object targetA1(long a0) throws Throwable { return target(a0); }
+ protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
+ protected int invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
+ protected long invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
+ protected float invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
+ protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
+ protected Object invoke_L(int a0) throws Throwable { return return_L(targetA1(a0)); }
+ protected int invoke_I(int a0) throws Throwable { return return_I(targetA1(a0)); }
+ protected long invoke_J(int a0) throws Throwable { return return_J(targetA1(a0)); }
+ protected float invoke_F(int a0) throws Throwable { return return_F(targetA1(a0)); }
+ protected double invoke_D(int a0) throws Throwable { return return_D(targetA1(a0)); }
+ protected Object invoke_L(long a0) throws Throwable { return return_L(targetA1(a0)); }
+ protected int invoke_I(long a0) throws Throwable { return return_I(targetA1(a0)); }
+ protected long invoke_J(long a0) throws Throwable { return return_J(targetA1(a0)); }
+ protected float invoke_F(long a0) throws Throwable { return return_F(targetA1(a0)); }
+ protected double invoke_D(long a0) throws Throwable { return return_D(targetA1(a0)); }
+ }
+ static class A2 extends Adapter {
+ protected A2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A2(e, i, c, t); }
+ protected Object target(Object a0, Object a1) throws Throwable { return invoker.invokeExact(target, a0, a1); }
+ protected Object targetA2(Object a0, Object a1) throws Throwable { return target(a0, a1); }
+ protected Object targetA2(Object a0, int a1) throws Throwable { return target(a0, a1); }
+ protected Object targetA2(int a0, int a1) throws Throwable { return target(a0, a1); }
+ protected Object targetA2(Object a0, long a1) throws Throwable { return target(a0, a1); }
+ protected Object targetA2(long a0, long a1) throws Throwable { return target(a0, a1); }
+ protected Object invoke_L(Object a0, Object a1) throws Throwable { return return_L(targetA2(a0, a1)); }
+ protected int invoke_I(Object a0, Object a1) throws Throwable { return return_I(targetA2(a0, a1)); }
+ protected long invoke_J(Object a0, Object a1) throws Throwable { return return_J(targetA2(a0, a1)); }
+ protected float invoke_F(Object a0, Object a1) throws Throwable { return return_F(targetA2(a0, a1)); }
+ protected double invoke_D(Object a0, Object a1) throws Throwable { return return_D(targetA2(a0, a1)); }
+ protected Object invoke_L(Object a0, int a1) throws Throwable { return return_L(targetA2(a0, a1)); }
+ protected int invoke_I(Object a0, int a1) throws Throwable { return return_I(targetA2(a0, a1)); }
+ protected long invoke_J(Object a0, int a1) throws Throwable { return return_J(targetA2(a0, a1)); }
+ protected float invoke_F(Object a0, int a1) throws Throwable { return return_F(targetA2(a0, a1)); }
+ protected double invoke_D(Object a0, int a1) throws Throwable { return return_D(targetA2(a0, a1)); }
+ protected Object invoke_L(int a0, int a1) throws Throwable { return return_L(targetA2(a0, a1)); }
+ protected int invoke_I(int a0, int a1) throws Throwable { return return_I(targetA2(a0, a1)); }
+ protected long invoke_J(int a0, int a1) throws Throwable { return return_J(targetA2(a0, a1)); }
+ protected float invoke_F(int a0, int a1) throws Throwable { return return_F(targetA2(a0, a1)); }
+ protected double invoke_D(int a0, int a1) throws Throwable { return return_D(targetA2(a0, a1)); }
+ protected Object invoke_L(Object a0, long a1) throws Throwable { return return_L(targetA2(a0, a1)); }
+ protected int invoke_I(Object a0, long a1) throws Throwable { return return_I(targetA2(a0, a1)); }
+ protected long invoke_J(Object a0, long a1) throws Throwable { return return_J(targetA2(a0, a1)); }
+ protected float invoke_F(Object a0, long a1) throws Throwable { return return_F(targetA2(a0, a1)); }
+ protected double invoke_D(Object a0, long a1) throws Throwable { return return_D(targetA2(a0, a1)); }
+ protected Object invoke_L(long a0, long a1) throws Throwable { return return_L(targetA2(a0, a1)); }
+ protected int invoke_I(long a0, long a1) throws Throwable { return return_I(targetA2(a0, a1)); }
+ protected long invoke_J(long a0, long a1) throws Throwable { return return_J(targetA2(a0, a1)); }
+ protected float invoke_F(long a0, long a1) throws Throwable { return return_F(targetA2(a0, a1)); }
+ protected double invoke_D(long a0, long a1) throws Throwable { return return_D(targetA2(a0, a1)); }
+ }
+ static class A3 extends Adapter {
+ protected A3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A3(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2) throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
+ protected Object targetA3(Object a0, Object a1, Object a2) throws Throwable { return target(a0, a1, a2); }
+ protected Object targetA3(Object a0, Object a1, int a2) throws Throwable { return target(a0, a1, a2); }
+ protected Object targetA3(Object a0, int a1, int a2) throws Throwable { return target(a0, a1, a2); }
+ protected Object targetA3(int a0, int a1, int a2) throws Throwable { return target(a0, a1, a2); }
+ protected Object targetA3(Object a0, Object a1, long a2) throws Throwable { return target(a0, a1, a2); }
+ protected Object targetA3(Object a0, long a1, long a2) throws Throwable { return target(a0, a1, a2); }
+ protected Object targetA3(long a0, long a1, long a2) throws Throwable { return target(a0, a1, a2); }
+ protected Object invoke_L(Object a0, Object a1, Object a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
+ protected int invoke_I(Object a0, Object a1, Object a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
+ protected long invoke_J(Object a0, Object a1, Object a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
+ protected float invoke_F(Object a0, Object a1, Object a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
+ protected double invoke_D(Object a0, Object a1, Object a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
+ protected Object invoke_L(Object a0, Object a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
+ protected int invoke_I(Object a0, Object a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
+ protected long invoke_J(Object a0, Object a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
+ protected float invoke_F(Object a0, Object a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
+ protected double invoke_D(Object a0, Object a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
+ protected Object invoke_L(Object a0, int a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
+ protected int invoke_I(Object a0, int a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
+ protected long invoke_J(Object a0, int a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
+ protected float invoke_F(Object a0, int a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
+ protected double invoke_D(Object a0, int a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
+ protected Object invoke_L(int a0, int a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
+ protected int invoke_I(int a0, int a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
+ protected long invoke_J(int a0, int a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
+ protected float invoke_F(int a0, int a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
+ protected double invoke_D(int a0, int a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
+ protected Object invoke_L(Object a0, Object a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
+ protected int invoke_I(Object a0, Object a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
+ protected long invoke_J(Object a0, Object a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
+ protected float invoke_F(Object a0, Object a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
+ protected double invoke_D(Object a0, Object a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
+ protected Object invoke_L(Object a0, long a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
+ protected int invoke_I(Object a0, long a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
+ protected long invoke_J(Object a0, long a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
+ protected float invoke_F(Object a0, long a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
+ protected double invoke_D(Object a0, long a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
+ protected Object invoke_L(long a0, long a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
+ protected int invoke_I(long a0, long a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
+ protected long invoke_J(long a0, long a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
+ protected float invoke_F(long a0, long a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
+ protected double invoke_D(long a0, long a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
+ }
+//params=[4, 5, 2, 99, 99, 99]
+ static class A4 extends Adapter {
+ protected A4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A4(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
+ protected Object targetA4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(Object a0, Object a1, Object a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(Object a0, Object a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(Object a0, int a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(int a0, int a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(Object a0, Object a1, Object a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(Object a0, Object a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(Object a0, long a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object targetA4(long a0, long a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(Object a0, Object a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(Object a0, Object a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(Object a0, Object a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(Object a0, int a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(Object a0, int a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(Object a0, int a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(int a0, int a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(int a0, int a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(int a0, int a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(Object a0, Object a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(Object a0, Object a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(Object a0, Object a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(Object a0, long a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(Object a0, long a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(Object a0, long a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ protected Object invoke_L(long a0, long a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
+ protected int invoke_I(long a0, long a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
+ protected long invoke_J(long a0, long a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
+ }
+ static class A5 extends Adapter {
+ protected A5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A5(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(int a0, int a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object targetA5(long a0, long a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(int a0, int a1, int a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(int a0, int a1, int a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(int a0, int a1, int a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ protected Object invoke_L(long a0, long a1, long a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
+ protected int invoke_I(long a0, long a1, long a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
+ protected long invoke_J(long a0, long a1, long a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
+ }
+//params=[6, 10, 2, 99, 0, 99]
+ static class A6 extends Adapter {
+ protected A6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A6(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5); }
+ protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
+ protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
+ protected Object targetA6(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
+ protected Object targetA6(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
+ protected Object targetA6(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
+ protected Object targetA6(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
+ protected Object targetA6(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
+ protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
+ }
+ static class A7 extends Adapter {
+ protected A7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A7(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object targetA7(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
+ }
+ static class A8 extends Adapter {
+ protected A8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A8(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object targetA8(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
+ }
+ static class A9 extends Adapter {
+ protected A9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A9(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object targetA9(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
+ }
+ static class A10 extends Adapter {
+ protected A10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
+ protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
+ protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A10(e, i, c, t); }
+ protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object targetA10(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
+ }
+}
--- a/jdk/src/share/classes/java/dyn/VolatileCallSite.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/VolatileCallSite.java Fri Mar 18 00:03:24 2011 -0700
@@ -25,8 +25,6 @@
package java.dyn;
-import java.util.List;
-
/**
* A {@code VolatileCallSite} is a {@link CallSite} whose target acts like a volatile variable.
* An {@code invokedynamic} instruction linked to a {@code VolatileCallSite} sees updates
--- a/jdk/src/share/classes/java/dyn/WrongMethodTypeException.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/java/dyn/WrongMethodTypeException.java Fri Mar 18 00:03:24 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
--- a/jdk/src/share/classes/sun/dyn/Access.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,109 +0,0 @@
-/*
- * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import sun.reflect.Reflection;
-
-/**
- * Access control to this package.
- * Classes in other packages can attempt to acquire the access token,
- * but will fail if they are not recognized as friends.
- * Certain methods in this package, although public, require a non-null
- * access token in order to proceed; they act like package-private methods.
- * @author jrose
- */
-
-public class Access {
-
- private Access() { }
-
- /**
- * The heart of this pattern: The list of classes which are
- * permitted to acquire the access token, and become honorary
- * members of this package.
- */
- private static final String[] FRIENDS = {
- "java.dyn.", "sun.dyn."
- };
-
- /**
- * The following object is NOT public. That's the point of the pattern.
- * It is package-private, so that any member of this package
- * can acquire the access token, and give it away to trusted friends.
- */
- static final Access TOKEN = new Access();
-
- /**
- * @return Access.TOKEN, if the caller is a friend of this package
- */
- public static Access getToken() {
- Class<?> callc = Reflection.getCallerClass(2);
- if (isFriend(callc))
- return TOKEN;
- else
- throw new IllegalAccessError("bad caller: " + callc);
- }
-
- /** Is the given name the name of a class which could be our friend? */
- public static boolean isFriendName(String name) {
- for (String friend : FRIENDS) {
- if (name.startsWith(friend))
- return true;
- }
- return false;
- }
-
- /** Is the given class a friend? True if {@link #isFriendName},
- * and the given class also shares a class loader with us.
- */
- public static boolean isFriend(Class<?> c) {
- return isFriendName(c.getName()) && c.getClassLoader() == CLASS_LOADER;
- }
-
- private static final ClassLoader CLASS_LOADER = Access.class.getClassLoader();
-
- /**
- * Throw an IllegalAccessError if the caller does not possess
- * the Access.TOKEN.
- * @param must be Access.TOKEN
- */
- public static void check(Access token) {
- if (token == null)
- fail();
- // else it must be the unique Access.TOKEN
- assert(token == Access.TOKEN);
- }
- private static void fail() {
- final int CALLER_DEPTH = 3;
- // 0: Reflection.getCC, 1: this.fail, 2: Access.*, 3: caller
- Class<?> callc = Reflection.getCallerClass(CALLER_DEPTH);
- throw new IllegalAccessError("bad caller: " + callc);
- }
-
- static {
- //sun.reflect.Reflection.registerMethodsToFilter(MH.class, "getToken");
- }
-}
--- a/jdk/src/share/classes/sun/dyn/AdapterMethodHandle.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,974 +0,0 @@
-/*
- * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import sun.dyn.util.VerifyType;
-import sun.dyn.util.Wrapper;
-import java.dyn.*;
-import java.util.Arrays;
-import static sun.dyn.MethodHandleNatives.Constants.*;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-
-/**
- * This method handle performs simple conversion or checking of a single argument.
- * @author jrose
- */
-public class AdapterMethodHandle extends BoundMethodHandle {
-
- //MethodHandle vmtarget; // next AMH or BMH in chain or final DMH
- //Object argument; // parameter to the conversion if needed
- //int vmargslot; // which argument slot is affected
- private final int conversion; // the type of conversion: RETYPE_ONLY, etc.
-
- // Constructors in this class *must* be package scoped or private.
- private AdapterMethodHandle(MethodHandle target, MethodType newType,
- long conv, Object convArg) {
- super(newType, convArg, newType.parameterSlotDepth(1+convArgPos(conv)));
- this.conversion = convCode(conv);
- if (MethodHandleNatives.JVM_SUPPORT) {
- // JVM might update VM-specific bits of conversion (ignore)
- MethodHandleNatives.init(this, target, convArgPos(conv));
- }
- }
- private AdapterMethodHandle(MethodHandle target, MethodType newType,
- long conv) {
- this(target, newType, conv, null);
- }
-
- private static final Access IMPL_TOKEN = Access.getToken();
-
- // TO DO: When adapting another MH with a null conversion, clone
- // the target and change its type, instead of adding another layer.
-
- /** Can a JVM-level adapter directly implement the proposed
- * argument conversions, as if by MethodHandles.convertArguments?
- */
- public static boolean canPairwiseConvert(MethodType newType, MethodType oldType) {
- // same number of args, of course
- int len = newType.parameterCount();
- if (len != oldType.parameterCount())
- return false;
-
- // Check return type. (Not much can be done with it.)
- Class<?> exp = newType.returnType();
- Class<?> ret = oldType.returnType();
- if (!VerifyType.isNullConversion(ret, exp))
- return false;
-
- // Check args pairwise.
- for (int i = 0; i < len; i++) {
- Class<?> src = newType.parameterType(i); // source type
- Class<?> dst = oldType.parameterType(i); // destination type
- if (!canConvertArgument(src, dst))
- return false;
- }
-
- return true;
- }
-
- /** Can a JVM-level adapter directly implement the proposed
- * argument conversion, as if by MethodHandles.convertArguments?
- */
- public static boolean canConvertArgument(Class<?> src, Class<?> dst) {
- // ? Retool this logic to use RETYPE_ONLY, CHECK_CAST, etc., as opcodes,
- // so we don't need to repeat so much decision making.
- if (VerifyType.isNullConversion(src, dst)) {
- return true;
- } else if (src.isPrimitive()) {
- if (dst.isPrimitive())
- return canPrimCast(src, dst);
- else
- return canBoxArgument(src, dst);
- } else {
- if (dst.isPrimitive())
- return canUnboxArgument(src, dst);
- else
- return true; // any two refs can be interconverted
- }
- }
-
- /**
- * Create a JVM-level adapter method handle to conform the given method
- * handle to the similar newType, using only pairwise argument conversions.
- * For each argument, convert incoming argument to the exact type needed.
- * Only null conversions are allowed on the return value (until
- * the JVM supports ricochet adapters).
- * The argument conversions allowed are casting, unboxing,
- * integral widening or narrowing, and floating point widening or narrowing.
- * @param token access check
- * @param newType required call type
- * @param target original method handle
- * @return an adapter to the original handle with the desired new type,
- * or the original target if the types are already identical
- * or null if the adaptation cannot be made
- */
- public static MethodHandle makePairwiseConvert(Access token,
- MethodType newType, MethodHandle target) {
- Access.check(token);
- MethodType oldType = target.type();
- if (newType == oldType) return target;
-
- if (!canPairwiseConvert(newType, oldType))
- return null;
- // (after this point, it is an assertion error to fail to convert)
-
- // Find last non-trivial conversion (if any).
- int lastConv = newType.parameterCount()-1;
- while (lastConv >= 0) {
- Class<?> src = newType.parameterType(lastConv); // source type
- Class<?> dst = oldType.parameterType(lastConv); // destination type
- if (VerifyType.isNullConversion(src, dst)) {
- --lastConv;
- } else {
- break;
- }
- }
- // Now build a chain of one or more adapters.
- MethodHandle adapter = target;
- MethodType midType = oldType.changeReturnType(newType.returnType());
- for (int i = 0; i <= lastConv; i++) {
- Class<?> src = newType.parameterType(i); // source type
- Class<?> dst = midType.parameterType(i); // destination type
- if (VerifyType.isNullConversion(src, dst)) {
- // do nothing: difference is trivial
- continue;
- }
- // Work the current type backward toward the desired caller type:
- if (i != lastConv) {
- midType = midType.changeParameterType(i, src);
- } else {
- // When doing the last (or only) real conversion,
- // force all remaining null conversions to happen also.
- assert(VerifyType.isNullConversion(newType, midType.changeParameterType(i, src)));
- midType = newType;
- }
-
- // Tricky case analysis follows.
- // It parallels canConvertArgument() above.
- if (src.isPrimitive()) {
- if (dst.isPrimitive()) {
- adapter = makePrimCast(token, midType, adapter, i, dst);
- } else {
- adapter = makeBoxArgument(token, midType, adapter, i, dst);
- }
- } else {
- if (dst.isPrimitive()) {
- // Caller has boxed a primitive. Unbox it for the target.
- // The box type must correspond exactly to the primitive type.
- // This is simpler than the powerful set of widening
- // conversions supported by reflect.Method.invoke.
- // Those conversions require a big nest of if/then/else logic,
- // which we prefer to make a user responsibility.
- adapter = makeUnboxArgument(token, midType, adapter, i, dst);
- } else {
- // Simple reference conversion.
- // Note: Do not check for a class hierarchy relation
- // between src and dst. In all cases a 'null' argument
- // will pass the cast conversion.
- adapter = makeCheckCast(token, midType, adapter, i, dst);
- }
- }
- assert(adapter != null);
- assert(adapter.type() == midType);
- }
- if (adapter.type() != newType) {
- // Only trivial conversions remain.
- adapter = makeRetypeOnly(IMPL_TOKEN, newType, adapter);
- assert(adapter != null);
- // Actually, that's because there were no non-trivial ones:
- assert(lastConv == -1);
- }
- assert(adapter.type() == newType);
- return adapter;
- }
-
- /**
- * Create a JVM-level adapter method handle to permute the arguments
- * of the given method.
- * @param token access check
- * @param newType required call type
- * @param target original method handle
- * @param argumentMap for each target argument, position of its source in newType
- * @return an adapter to the original handle with the desired new type,
- * or the original target if the types are already identical
- * and the permutation is null
- * @throws IllegalArgumentException if the adaptation cannot be made
- * directly by a JVM-level adapter, without help from Java code
- */
- public static MethodHandle makePermutation(Access token,
- MethodType newType, MethodHandle target,
- int[] argumentMap) {
- MethodType oldType = target.type();
- boolean nullPermutation = true;
- for (int i = 0; i < argumentMap.length; i++) {
- int pos = argumentMap[i];
- if (pos != i)
- nullPermutation = false;
- if (pos < 0 || pos >= newType.parameterCount()) {
- argumentMap = new int[0]; break;
- }
- }
- if (argumentMap.length != oldType.parameterCount())
- throw newIllegalArgumentException("bad permutation: "+Arrays.toString(argumentMap));
- if (nullPermutation) {
- MethodHandle res = makePairwiseConvert(token, newType, target);
- // well, that was easy
- if (res == null)
- throw newIllegalArgumentException("cannot convert pairwise: "+newType);
- return res;
- }
-
- // Check return type. (Not much can be done with it.)
- Class<?> exp = newType.returnType();
- Class<?> ret = oldType.returnType();
- if (!VerifyType.isNullConversion(ret, exp))
- throw newIllegalArgumentException("bad return conversion for "+newType);
-
- // See if the argument types match up.
- for (int i = 0; i < argumentMap.length; i++) {
- int j = argumentMap[i];
- Class<?> src = newType.parameterType(j);
- Class<?> dst = oldType.parameterType(i);
- if (!VerifyType.isNullConversion(src, dst))
- throw newIllegalArgumentException("bad argument #"+j+" conversion for "+newType);
- }
-
- // Now figure out a nice mix of SWAP, ROT, DUP, and DROP adapters.
- // A workable greedy algorithm is as follows:
- // Drop unused outgoing arguments (right to left: shallowest first).
- // Duplicate doubly-used outgoing arguments (left to right: deepest first).
- // Then the remaining problem is a true argument permutation.
- // Marshal the outgoing arguments as required from left to right.
- // That is, find the deepest outgoing stack position that does not yet
- // have the correct argument value, and correct at least that position
- // by swapping or rotating in the misplaced value (from a shallower place).
- // If the misplaced value is followed by one or more consecutive values
- // (also misplaced) issue a rotation which brings as many as possible
- // into position. Otherwise make progress with either a swap or a
- // rotation. Prefer the swap as cheaper, but do not use it if it
- // breaks a slot pair. Prefer the rotation over the swap if it would
- // preserve more consecutive values shallower than the target position.
- // When more than one rotation will work (because the required value
- // is already adjacent to the target position), then use a rotation
- // which moves the old value in the target position adjacent to
- // one of its consecutive values. Also, prefer shorter rotation
- // spans, since they use fewer memory cycles for shuffling.
-
- throw new UnsupportedOperationException("NYI");
- }
-
- private static byte basicType(Class<?> type) {
- if (type == null) return T_VOID;
- switch (Wrapper.forBasicType(type)) {
- case BOOLEAN: return T_BOOLEAN;
- case CHAR: return T_CHAR;
- case FLOAT: return T_FLOAT;
- case DOUBLE: return T_DOUBLE;
- case BYTE: return T_BYTE;
- case SHORT: return T_SHORT;
- case INT: return T_INT;
- case LONG: return T_LONG;
- case OBJECT: return T_OBJECT;
- case VOID: return T_VOID;
- }
- return 99; // T_ILLEGAL or some such
- }
-
- /** Number of stack slots for the given type.
- * Two for T_DOUBLE and T_FLOAT, one for the rest.
- */
- private static int type2size(int type) {
- assert(type >= T_BOOLEAN && type <= T_OBJECT);
- return (type == T_LONG || type == T_DOUBLE) ? 2 : 1;
- }
- private static int type2size(Class<?> type) {
- return type2size(basicType(type));
- }
-
- /** The given stackMove is the number of slots pushed.
- * It might be negative. Scale it (multiply) by the
- * VM's notion of how an address changes with a push,
- * to get the raw SP change for stackMove.
- * Then shift and mask it into the correct field.
- */
- private static long insertStackMove(int stackMove) {
- // following variable must be long to avoid sign extension after '<<'
- long spChange = stackMove * MethodHandleNatives.JVM_STACK_MOVE_UNIT;
- return (spChange & CONV_STACK_MOVE_MASK) << CONV_STACK_MOVE_SHIFT;
- }
-
- /** Construct an adapter conversion descriptor for a single-argument conversion. */
- private static long makeConv(int convOp, int argnum, int src, int dest) {
- assert(src == (src & 0xF));
- assert(dest == (dest & 0xF));
- assert(convOp >= OP_CHECK_CAST && convOp <= OP_PRIM_TO_REF);
- int stackMove = type2size(dest) - type2size(src);
- return ((long) argnum << 32 |
- (long) convOp << CONV_OP_SHIFT |
- (int) src << CONV_SRC_TYPE_SHIFT |
- (int) dest << CONV_DEST_TYPE_SHIFT |
- insertStackMove(stackMove)
- );
- }
- private static long makeConv(int convOp, int argnum, int stackMove) {
- assert(convOp >= OP_DUP_ARGS && convOp <= OP_SPREAD_ARGS);
- byte src = 0, dest = 0;
- if (convOp >= OP_COLLECT_ARGS && convOp <= OP_SPREAD_ARGS)
- src = dest = T_OBJECT;
- return ((long) argnum << 32 |
- (long) convOp << CONV_OP_SHIFT |
- (int) src << CONV_SRC_TYPE_SHIFT |
- (int) dest << CONV_DEST_TYPE_SHIFT |
- insertStackMove(stackMove)
- );
- }
- private static long makeSwapConv(int convOp, int srcArg, byte type, int destSlot) {
- assert(convOp >= OP_SWAP_ARGS && convOp <= OP_ROT_ARGS);
- return ((long) srcArg << 32 |
- (long) convOp << CONV_OP_SHIFT |
- (int) type << CONV_SRC_TYPE_SHIFT |
- (int) type << CONV_DEST_TYPE_SHIFT |
- (int) destSlot << CONV_VMINFO_SHIFT
- );
- }
- private static long makeConv(int convOp) {
- assert(convOp == OP_RETYPE_ONLY || convOp == OP_RETYPE_RAW);
- return ((long)-1 << 32) | (convOp << CONV_OP_SHIFT); // stackMove, src, dst all zero
- }
- private static int convCode(long conv) {
- return (int)conv;
- }
- private static int convArgPos(long conv) {
- return (int)(conv >>> 32);
- }
- private static boolean convOpSupported(int convOp) {
- assert(convOp >= 0 && convOp <= CONV_OP_LIMIT);
- return ((1<<convOp) & MethodHandleNatives.CONV_OP_IMPLEMENTED_MASK) != 0;
- }
-
- /** One of OP_RETYPE_ONLY, etc. */
- int conversionOp() { return (conversion & CONV_OP_MASK) >> CONV_OP_SHIFT; }
-
- /* Return one plus the position of the first non-trivial difference
- * between the given types. This is not a symmetric operation;
- * we are considering adapting the targetType to adapterType.
- * Trivial differences are those which could be ignored by the JVM
- * without subverting the verifier. Otherwise, adaptable differences
- * are ones for which we could create an adapter to make the type change.
- * Return zero if there are no differences (other than trivial ones).
- * Return 1+N if N is the only adaptable argument difference.
- * Return the -2-N where N is the first of several adaptable
- * argument differences.
- * Return -1 if there there are differences which are not adaptable.
- */
- private static int diffTypes(MethodType adapterType,
- MethodType targetType,
- boolean raw) {
- int diff;
- diff = diffReturnTypes(adapterType, targetType, raw);
- if (diff != 0) return diff;
- int nargs = adapterType.parameterCount();
- if (nargs != targetType.parameterCount())
- return -1;
- diff = diffParamTypes(adapterType, 0, targetType, 0, nargs, raw);
- //System.out.println("diff "+adapterType);
- //System.out.println(" "+diff+" "+targetType);
- return diff;
- }
- private static int diffReturnTypes(MethodType adapterType,
- MethodType targetType,
- boolean raw) {
- Class<?> src = targetType.returnType();
- Class<?> dst = adapterType.returnType();
- if ((!raw
- ? VerifyType.canPassUnchecked(src, dst)
- : VerifyType.canPassRaw(src, dst)
- ) > 0)
- return 0; // no significant difference
- if (raw && !src.isPrimitive() && !dst.isPrimitive())
- return 0; // can force a reference return (very carefully!)
- //if (false) return 1; // never adaptable!
- return -1; // some significant difference
- }
- private static int diffParamTypes(MethodType adapterType, int astart,
- MethodType targetType, int tstart,
- int nargs, boolean raw) {
- assert(nargs >= 0);
- int res = 0;
- for (int i = 0; i < nargs; i++) {
- Class<?> src = adapterType.parameterType(astart+i);
- Class<?> dest = targetType.parameterType(tstart+i);
- if ((!raw
- ? VerifyType.canPassUnchecked(src, dest)
- : VerifyType.canPassRaw(src, dest)
- ) <= 0) {
- // found a difference; is it the only one so far?
- if (res != 0)
- return -1-res; // return -2-i for prev. i
- res = 1+i;
- }
- }
- return res;
- }
-
- /** Can a retyping adapter (alone) validly convert the target to newType? */
- public static boolean canRetypeOnly(MethodType newType, MethodType targetType) {
- return canRetype(newType, targetType, false);
- }
- /** Can a retyping adapter (alone) convert the target to newType?
- * It is allowed to widen subword types and void to int, to make bitwise
- * conversions between float/int and double/long, and to perform unchecked
- * reference conversions on return. This last feature requires that the
- * caller be trusted, and perform explicit cast conversions on return values.
- */
- public static boolean canRetypeRaw(MethodType newType, MethodType targetType) {
- return canRetype(newType, targetType, true);
- }
- static boolean canRetype(MethodType newType, MethodType targetType, boolean raw) {
- if (!convOpSupported(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY)) return false;
- int diff = diffTypes(newType, targetType, raw);
- // %%% This assert is too strong. Factor diff into VerifyType and reconcile.
- assert(raw || (diff == 0) == VerifyType.isNullConversion(newType, targetType));
- return diff == 0;
- }
-
- /** Factory method: Performs no conversions; simply retypes the adapter.
- * Allows unchecked argument conversions pairwise, if they are safe.
- * Returns null if not possible.
- */
- public static MethodHandle makeRetypeOnly(Access token,
- MethodType newType, MethodHandle target) {
- return makeRetype(token, newType, target, false);
- }
- public static MethodHandle makeRetypeRaw(Access token,
- MethodType newType, MethodHandle target) {
- return makeRetype(token, newType, target, true);
- }
- static MethodHandle makeRetype(Access token,
- MethodType newType, MethodHandle target, boolean raw) {
- Access.check(token);
- MethodType oldType = target.type();
- if (oldType == newType) return target;
- if (!canRetype(newType, oldType, raw))
- return null;
- // TO DO: clone the target guy, whatever he is, with new type.
- return new AdapterMethodHandle(target, newType, makeConv(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY));
- }
-
- static MethodHandle makeVarargsCollector(Access token,
- MethodHandle target, Class<?> arrayType) {
- Access.check(token);
- return new AsVarargsCollector(target, arrayType);
- }
-
- static class AsVarargsCollector extends AdapterMethodHandle {
- final MethodHandle target;
- final Class<?> arrayType;
- MethodHandle cache;
-
- AsVarargsCollector(MethodHandle target, Class<?> arrayType) {
- super(target, target.type(), makeConv(OP_RETYPE_ONLY));
- this.target = target;
- this.arrayType = arrayType;
- this.cache = target.asCollector(arrayType, 0);
- }
-
- @Override
- public boolean isVarargsCollector() {
- return true;
- }
-
- @Override
- public MethodHandle asType(MethodType newType) {
- MethodType type = this.type();
- int collectArg = type.parameterCount() - 1;
- int newArity = newType.parameterCount();
- if (newArity == collectArg+1 &&
- type.parameterType(collectArg).isAssignableFrom(newType.parameterType(collectArg))) {
- // if arity and trailing parameter are compatible, do normal thing
- return super.asType(newType);
- }
- // check cache
- if (cache.type().parameterCount() == newArity)
- return cache.asType(newType);
- // build and cache a collector
- int arrayLength = newArity - collectArg;
- MethodHandle collector;
- try {
- collector = target.asCollector(arrayType, arrayLength);
- } catch (IllegalArgumentException ex) {
- throw new WrongMethodTypeException("cannot build collector");
- }
- cache = collector;
- return collector.asType(newType);
- }
-
- public MethodHandle asVarargsCollector(Class<?> arrayType) {
- MethodType type = this.type();
- if (type.parameterType(type.parameterCount()-1) == arrayType)
- return this;
- return super.asVarargsCollector(arrayType);
- }
- }
-
- /** Can a checkcast adapter validly convert the target to newType?
- * The JVM supports all kind of reference casts, even silly ones.
- */
- public static boolean canCheckCast(MethodType newType, MethodType targetType,
- int arg, Class<?> castType) {
- if (!convOpSupported(OP_CHECK_CAST)) return false;
- Class<?> src = newType.parameterType(arg);
- Class<?> dst = targetType.parameterType(arg);
- if (!canCheckCast(src, castType)
- || !VerifyType.isNullConversion(castType, dst))
- return false;
- int diff = diffTypes(newType, targetType, false);
- return (diff == arg+1); // arg is sole non-trivial diff
- }
- /** Can an primitive conversion adapter validly convert src to dst? */
- public static boolean canCheckCast(Class<?> src, Class<?> dst) {
- return (!src.isPrimitive() && !dst.isPrimitive());
- }
-
- /** Factory method: Forces a cast at the given argument.
- * The castType is the target of the cast, and can be any type
- * with a null conversion to the corresponding target parameter.
- * Return null if this cannot be done.
- */
- public static MethodHandle makeCheckCast(Access token,
- MethodType newType, MethodHandle target,
- int arg, Class<?> castType) {
- Access.check(token);
- if (!canCheckCast(newType, target.type(), arg, castType))
- return null;
- long conv = makeConv(OP_CHECK_CAST, arg, T_OBJECT, T_OBJECT);
- return new AdapterMethodHandle(target, newType, conv, castType);
- }
-
- /** Can an primitive conversion adapter validly convert the target to newType?
- * The JVM currently supports all conversions except those between
- * floating and integral types.
- */
- public static boolean canPrimCast(MethodType newType, MethodType targetType,
- int arg, Class<?> convType) {
- if (!convOpSupported(OP_PRIM_TO_PRIM)) return false;
- Class<?> src = newType.parameterType(arg);
- Class<?> dst = targetType.parameterType(arg);
- if (!canPrimCast(src, convType)
- || !VerifyType.isNullConversion(convType, dst))
- return false;
- int diff = diffTypes(newType, targetType, false);
- return (diff == arg+1); // arg is sole non-trivial diff
- }
- /** Can an primitive conversion adapter validly convert src to dst? */
- public static boolean canPrimCast(Class<?> src, Class<?> dst) {
- if (src == dst || !src.isPrimitive() || !dst.isPrimitive()) {
- return false;
- } else if (Wrapper.forPrimitiveType(dst).isFloating()) {
- // both must be floating types
- return Wrapper.forPrimitiveType(src).isFloating();
- } else {
- // both are integral, and all combinations work fine
- assert(Wrapper.forPrimitiveType(src).isIntegral() &&
- Wrapper.forPrimitiveType(dst).isIntegral());
- return true;
- }
- }
-
- /** Factory method: Truncate the given argument with zero or sign extension,
- * and/or convert between single and doubleword versions of integer or float.
- * The convType is the target of the conversion, and can be any type
- * with a null conversion to the corresponding target parameter.
- * Return null if this cannot be done.
- */
- public static MethodHandle makePrimCast(Access token,
- MethodType newType, MethodHandle target,
- int arg, Class<?> convType) {
- Access.check(token);
- MethodType oldType = target.type();
- if (!canPrimCast(newType, oldType, arg, convType))
- return null;
- Class<?> src = newType.parameterType(arg);
- long conv = makeConv(OP_PRIM_TO_PRIM, arg, basicType(src), basicType(convType));
- return new AdapterMethodHandle(target, newType, conv);
- }
-
- /** Can an unboxing conversion validly convert src to dst?
- * The JVM currently supports all kinds of casting and unboxing.
- * The convType is the unboxed type; it can be either a primitive or wrapper.
- */
- public static boolean canUnboxArgument(MethodType newType, MethodType targetType,
- int arg, Class<?> convType) {
- if (!convOpSupported(OP_REF_TO_PRIM)) return false;
- Class<?> src = newType.parameterType(arg);
- Class<?> dst = targetType.parameterType(arg);
- Class<?> boxType = Wrapper.asWrapperType(convType);
- convType = Wrapper.asPrimitiveType(convType);
- if (!canCheckCast(src, boxType)
- || boxType == convType
- || !VerifyType.isNullConversion(convType, dst))
- return false;
- int diff = diffTypes(newType, targetType, false);
- return (diff == arg+1); // arg is sole non-trivial diff
- }
- /** Can an primitive unboxing adapter validly convert src to dst? */
- public static boolean canUnboxArgument(Class<?> src, Class<?> dst) {
- return (!src.isPrimitive() && Wrapper.asPrimitiveType(dst).isPrimitive());
- }
-
- /** Factory method: Unbox the given argument.
- * Return null if this cannot be done.
- */
- public static MethodHandle makeUnboxArgument(Access token,
- MethodType newType, MethodHandle target,
- int arg, Class<?> convType) {
- MethodType oldType = target.type();
- Class<?> src = newType.parameterType(arg);
- Class<?> dst = oldType.parameterType(arg);
- Class<?> boxType = Wrapper.asWrapperType(convType);
- Class<?> primType = Wrapper.asPrimitiveType(convType);
- if (!canUnboxArgument(newType, oldType, arg, convType))
- return null;
- MethodType castDone = newType;
- if (!VerifyType.isNullConversion(src, boxType))
- castDone = newType.changeParameterType(arg, boxType);
- long conv = makeConv(OP_REF_TO_PRIM, arg, T_OBJECT, basicType(primType));
- MethodHandle adapter = new AdapterMethodHandle(target, castDone, conv, boxType);
- if (castDone == newType)
- return adapter;
- return makeCheckCast(token, newType, adapter, arg, boxType);
- }
-
- /** Can an primitive boxing adapter validly convert src to dst? */
- public static boolean canBoxArgument(Class<?> src, Class<?> dst) {
- if (!convOpSupported(OP_PRIM_TO_REF)) return false;
- throw new UnsupportedOperationException("NYI");
- }
-
- /** Factory method: Unbox the given argument.
- * Return null if this cannot be done.
- */
- public static MethodHandle makeBoxArgument(Access token,
- MethodType newType, MethodHandle target,
- int arg, Class<?> convType) {
- // this is difficult to do in the JVM because it must GC
- return null;
- }
-
- /** Can an adapter simply drop arguments to convert the target to newType? */
- public static boolean canDropArguments(MethodType newType, MethodType targetType,
- int dropArgPos, int dropArgCount) {
- if (dropArgCount == 0)
- return canRetypeOnly(newType, targetType);
- if (!convOpSupported(OP_DROP_ARGS)) return false;
- if (diffReturnTypes(newType, targetType, false) != 0)
- return false;
- int nptypes = newType.parameterCount();
- // parameter types must be the same up to the drop point
- if (dropArgPos != 0 && diffParamTypes(newType, 0, targetType, 0, dropArgPos, false) != 0)
- return false;
- int afterPos = dropArgPos + dropArgCount;
- int afterCount = nptypes - afterPos;
- if (dropArgPos < 0 || dropArgPos >= nptypes ||
- dropArgCount < 1 || afterPos > nptypes ||
- targetType.parameterCount() != nptypes - dropArgCount)
- return false;
- // parameter types after the drop point must also be the same
- if (afterCount != 0 && diffParamTypes(newType, afterPos, targetType, dropArgPos, afterCount, false) != 0)
- return false;
- return true;
- }
-
- /** Factory method: Drop selected arguments.
- * Allow unchecked retyping of remaining arguments, pairwise.
- * Return null if this is not possible.
- */
- public static MethodHandle makeDropArguments(Access token,
- MethodType newType, MethodHandle target,
- int dropArgPos, int dropArgCount) {
- Access.check(token);
- if (dropArgCount == 0)
- return makeRetypeOnly(IMPL_TOKEN, newType, target);
- if (!canDropArguments(newType, target.type(), dropArgPos, dropArgCount))
- return null;
- // in arglist: [0: ...keep1 | dpos: drop... | dpos+dcount: keep2... ]
- // out arglist: [0: ...keep1 | dpos: keep2... ]
- int keep2InPos = dropArgPos + dropArgCount;
- int dropSlot = newType.parameterSlotDepth(keep2InPos);
- int keep1InSlot = newType.parameterSlotDepth(dropArgPos);
- int slotCount = keep1InSlot - dropSlot;
- assert(slotCount >= dropArgCount);
- assert(target.type().parameterSlotCount() + slotCount == newType.parameterSlotCount());
- long conv = makeConv(OP_DROP_ARGS, dropArgPos + dropArgCount - 1, -slotCount);
- return new AdapterMethodHandle(target, newType, conv);
- }
-
- /** Can an adapter duplicate an argument to convert the target to newType? */
- public static boolean canDupArguments(MethodType newType, MethodType targetType,
- int dupArgPos, int dupArgCount) {
- if (!convOpSupported(OP_DUP_ARGS)) return false;
- if (diffReturnTypes(newType, targetType, false) != 0)
- return false;
- int nptypes = newType.parameterCount();
- if (dupArgCount < 0 || dupArgPos + dupArgCount > nptypes)
- return false;
- if (targetType.parameterCount() != nptypes + dupArgCount)
- return false;
- // parameter types must be the same up to the duplicated arguments
- if (diffParamTypes(newType, 0, targetType, 0, nptypes, false) != 0)
- return false;
- // duplicated types must be, well, duplicates
- if (diffParamTypes(newType, dupArgPos, targetType, nptypes, dupArgCount, false) != 0)
- return false;
- return true;
- }
-
- /** Factory method: Duplicate the selected argument.
- * Return null if this is not possible.
- */
- public static MethodHandle makeDupArguments(Access token,
- MethodType newType, MethodHandle target,
- int dupArgPos, int dupArgCount) {
- Access.check(token);
- if (!canDupArguments(newType, target.type(), dupArgPos, dupArgCount))
- return null;
- if (dupArgCount == 0)
- return target;
- // in arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... ]
- // out arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... | dup... ]
- int keep2InPos = dupArgPos + dupArgCount;
- int dupSlot = newType.parameterSlotDepth(keep2InPos);
- int keep1InSlot = newType.parameterSlotDepth(dupArgPos);
- int slotCount = keep1InSlot - dupSlot;
- assert(target.type().parameterSlotCount() - slotCount == newType.parameterSlotCount());
- long conv = makeConv(OP_DUP_ARGS, dupArgPos + dupArgCount - 1, slotCount);
- return new AdapterMethodHandle(target, newType, conv);
- }
-
- /** Can an adapter swap two arguments to convert the target to newType? */
- public static boolean canSwapArguments(MethodType newType, MethodType targetType,
- int swapArg1, int swapArg2) {
- if (!convOpSupported(OP_SWAP_ARGS)) return false;
- if (diffReturnTypes(newType, targetType, false) != 0)
- return false;
- if (swapArg1 >= swapArg2) return false; // caller resp
- int nptypes = newType.parameterCount();
- if (targetType.parameterCount() != nptypes)
- return false;
- if (swapArg1 < 0 || swapArg2 >= nptypes)
- return false;
- if (diffParamTypes(newType, 0, targetType, 0, swapArg1, false) != 0)
- return false;
- if (diffParamTypes(newType, swapArg1, targetType, swapArg2, 1, false) != 0)
- return false;
- if (diffParamTypes(newType, swapArg1+1, targetType, swapArg1+1, swapArg2-swapArg1-1, false) != 0)
- return false;
- if (diffParamTypes(newType, swapArg2, targetType, swapArg1, 1, false) != 0)
- return false;
- if (diffParamTypes(newType, swapArg2+1, targetType, swapArg2+1, nptypes-swapArg2-1, false) != 0)
- return false;
- return true;
- }
-
- /** Factory method: Swap the selected arguments.
- * Return null if this is not possible.
- */
- public static MethodHandle makeSwapArguments(Access token,
- MethodType newType, MethodHandle target,
- int swapArg1, int swapArg2) {
- Access.check(token);
- if (swapArg1 == swapArg2)
- return target;
- if (swapArg1 > swapArg2) { int t = swapArg1; swapArg1 = swapArg2; swapArg2 = t; }
- if (!canSwapArguments(newType, target.type(), swapArg1, swapArg2))
- return null;
- Class<?> swapType = newType.parameterType(swapArg1);
- // in arglist: [0: ...keep1 | pos1: a1 | pos1+1: keep2... | pos2: a2 | pos2+1: keep3... ]
- // out arglist: [0: ...keep1 | pos1: a2 | pos1+1: keep2... | pos2: a1 | pos2+1: keep3... ]
- int swapSlot2 = newType.parameterSlotDepth(swapArg2 + 1);
- long conv = makeSwapConv(OP_SWAP_ARGS, swapArg1, basicType(swapType), swapSlot2);
- return new AdapterMethodHandle(target, newType, conv);
- }
-
- static int positiveRotation(int argCount, int rotateBy) {
- assert(argCount > 0);
- if (rotateBy >= 0) {
- if (rotateBy < argCount)
- return rotateBy;
- return rotateBy % argCount;
- } else if (rotateBy >= -argCount) {
- return rotateBy + argCount;
- } else {
- return (-1-((-1-rotateBy) % argCount)) + argCount;
- }
- }
-
- final static int MAX_ARG_ROTATION = 1;
-
- /** Can an adapter rotate arguments to convert the target to newType? */
- public static boolean canRotateArguments(MethodType newType, MethodType targetType,
- int firstArg, int argCount, int rotateBy) {
- if (!convOpSupported(OP_ROT_ARGS)) return false;
- if (argCount <= 2) return false; // must be a swap, not a rotate
- rotateBy = positiveRotation(argCount, rotateBy);
- if (rotateBy == 0) return false; // no rotation
- if (rotateBy > MAX_ARG_ROTATION && rotateBy < argCount - MAX_ARG_ROTATION)
- return false; // too many argument positions
- // Rotate incoming args right N to the out args, N in 1..(argCouunt-1).
- if (diffReturnTypes(newType, targetType, false) != 0)
- return false;
- int nptypes = newType.parameterCount();
- if (targetType.parameterCount() != nptypes)
- return false;
- if (firstArg < 0 || firstArg >= nptypes) return false;
- int argLimit = firstArg + argCount;
- if (argLimit > nptypes) return false;
- if (diffParamTypes(newType, 0, targetType, 0, firstArg, false) != 0)
- return false;
- int newChunk1 = argCount - rotateBy, newChunk2 = rotateBy;
- // swap new chunk1 with target chunk2
- if (diffParamTypes(newType, firstArg, targetType, argLimit-newChunk1, newChunk1, false) != 0)
- return false;
- // swap new chunk2 with target chunk1
- if (diffParamTypes(newType, firstArg+newChunk1, targetType, firstArg, newChunk2, false) != 0)
- return false;
- return true;
- }
-
- /** Factory method: Rotate the selected argument range.
- * Return null if this is not possible.
- */
- public static MethodHandle makeRotateArguments(Access token,
- MethodType newType, MethodHandle target,
- int firstArg, int argCount, int rotateBy) {
- Access.check(token);
- rotateBy = positiveRotation(argCount, rotateBy);
- if (!canRotateArguments(newType, target.type(), firstArg, argCount, rotateBy))
- return null;
- // Decide whether it should be done as a right or left rotation,
- // on the JVM stack. Return the number of stack slots to rotate by,
- // positive if right, negative if left.
- int limit = firstArg + argCount;
- int depth0 = newType.parameterSlotDepth(firstArg);
- int depth1 = newType.parameterSlotDepth(limit-rotateBy);
- int depth2 = newType.parameterSlotDepth(limit);
- int chunk1Slots = depth0 - depth1; assert(chunk1Slots > 0);
- int chunk2Slots = depth1 - depth2; assert(chunk2Slots > 0);
- // From here on out, it assumes a single-argument shift.
- assert(MAX_ARG_ROTATION == 1);
- int srcArg, dstArg;
- byte basicType;
- if (chunk2Slots <= chunk1Slots) {
- // Rotate right/down N (rotateBy = +N, N small, c2 small):
- // in arglist: [0: ...keep1 | arg1: c1... | limit-N: c2 | limit: keep2... ]
- // out arglist: [0: ...keep1 | arg1: c2 | arg1+N: c1... | limit: keep2... ]
- srcArg = limit-1;
- dstArg = firstArg;
- basicType = basicType(newType.parameterType(srcArg));
- assert(chunk2Slots == type2size(basicType));
- } else {
- // Rotate left/up N (rotateBy = -N, N small, c1 small):
- // in arglist: [0: ...keep1 | arg1: c1 | arg1+N: c2... | limit: keep2... ]
- // out arglist: [0: ...keep1 | arg1: c2 ... | limit-N: c1 | limit: keep2... ]
- srcArg = firstArg;
- dstArg = limit-1;
- basicType = basicType(newType.parameterType(srcArg));
- assert(chunk1Slots == type2size(basicType));
- }
- int dstSlot = newType.parameterSlotDepth(dstArg + 1);
- long conv = makeSwapConv(OP_ROT_ARGS, srcArg, basicType, dstSlot);
- return new AdapterMethodHandle(target, newType, conv);
- }
-
- /** Can an adapter spread an argument to convert the target to newType? */
- public static boolean canSpreadArguments(MethodType newType, MethodType targetType,
- Class<?> spreadArgType, int spreadArgPos, int spreadArgCount) {
- if (!convOpSupported(OP_SPREAD_ARGS)) return false;
- if (diffReturnTypes(newType, targetType, false) != 0)
- return false;
- int nptypes = newType.parameterCount();
- // parameter types must be the same up to the spread point
- if (spreadArgPos != 0 && diffParamTypes(newType, 0, targetType, 0, spreadArgPos, false) != 0)
- return false;
- int afterPos = spreadArgPos + spreadArgCount;
- int afterCount = nptypes - (spreadArgPos + 1);
- if (spreadArgPos < 0 || spreadArgPos >= nptypes ||
- spreadArgCount < 0 ||
- targetType.parameterCount() != afterPos + afterCount)
- return false;
- // parameter types after the spread point must also be the same
- if (afterCount != 0 && diffParamTypes(newType, spreadArgPos+1, targetType, afterPos, afterCount, false) != 0)
- return false;
- // match the array element type to the spread arg types
- Class<?> rawSpreadArgType = newType.parameterType(spreadArgPos);
- if (rawSpreadArgType != spreadArgType && !canCheckCast(rawSpreadArgType, spreadArgType))
- return false;
- for (int i = 0; i < spreadArgCount; i++) {
- Class<?> src = VerifyType.spreadArgElementType(spreadArgType, i);
- Class<?> dst = targetType.parameterType(spreadArgPos + i);
- if (src == null || !VerifyType.isNullConversion(src, dst))
- return false;
- }
- return true;
- }
-
-
- /** Factory method: Spread selected argument. */
- public static MethodHandle makeSpreadArguments(Access token,
- MethodType newType, MethodHandle target,
- Class<?> spreadArgType, int spreadArgPos, int spreadArgCount) {
- Access.check(token);
- MethodType targetType = target.type();
- if (!canSpreadArguments(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount))
- return null;
- // in arglist: [0: ...keep1 | spos: spreadArg | spos+1: keep2... ]
- // out arglist: [0: ...keep1 | spos: spread... | spos+scount: keep2... ]
- int keep2OutPos = spreadArgPos + spreadArgCount;
- int spreadSlot = targetType.parameterSlotDepth(keep2OutPos);
- int keep1OutSlot = targetType.parameterSlotDepth(spreadArgPos);
- int slotCount = keep1OutSlot - spreadSlot;
- assert(spreadSlot == newType.parameterSlotDepth(spreadArgPos+1));
- assert(slotCount >= spreadArgCount);
- long conv = makeConv(OP_SPREAD_ARGS, spreadArgPos, slotCount-1);
- MethodHandle res = new AdapterMethodHandle(target, newType, conv, spreadArgType);
- assert(res.type().parameterType(spreadArgPos) == spreadArgType);
- return res;
- }
-
- // TO DO: makeCollectArguments, makeFlyby, makeRicochet
-
- @Override
- public String toString() {
- return MethodHandleImpl.getNameString(IMPL_TOKEN, nonAdapter((MethodHandle)vmtarget), this);
- }
-
- private static MethodHandle nonAdapter(MethodHandle mh) {
- while (mh instanceof AdapterMethodHandle) {
- mh = (MethodHandle) mh.vmtarget;
- }
- return mh;
- }
-}
--- a/jdk/src/share/classes/sun/dyn/BoundMethodHandle.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import sun.dyn.util.VerifyType;
-import sun.dyn.util.Wrapper;
-import java.dyn.*;
-import java.util.List;
-import sun.dyn.MethodHandleNatives.Constants;
-import static sun.dyn.MethodHandleImpl.IMPL_LOOKUP;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-
-/**
- * The flavor of method handle which emulates an invoke instruction
- * on a predetermined argument. The JVM dispatches to the correct method
- * when the handle is created, not when it is invoked.
- * @author jrose
- */
-public class BoundMethodHandle extends MethodHandle {
- //MethodHandle vmtarget; // next BMH or final DMH or methodOop
- private final Object argument; // argument to insert
- private final int vmargslot; // position at which it is inserted
-
- private static final Access IMPL_TOKEN = Access.getToken();
- private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory(IMPL_TOKEN);
-
- // Constructors in this class *must* be package scoped or private.
-
- /** Bind a direct MH to its receiver (or first ref. argument).
- * The JVM will pre-dispatch the MH if it is not already static.
- */
- BoundMethodHandle(DirectMethodHandle mh, Object argument) {
- super(Access.TOKEN, mh.type().dropParameterTypes(0, 1));
- // check the type now, once for all:
- this.argument = checkReferenceArgument(argument, mh, 0);
- this.vmargslot = this.type().parameterSlotCount();
- if (MethodHandleNatives.JVM_SUPPORT) {
- this.vmtarget = null; // maybe updated by JVM
- MethodHandleNatives.init(this, mh, 0);
- } else {
- this.vmtarget = mh;
- }
- }
-
- /** Insert an argument into an arbitrary method handle.
- * If argnum is zero, inserts the first argument, etc.
- * The argument type must be a reference.
- */
- BoundMethodHandle(MethodHandle mh, Object argument, int argnum) {
- this(mh.type().dropParameterTypes(argnum, argnum+1),
- mh, argument, argnum);
- }
-
- /** Insert an argument into an arbitrary method handle.
- * If argnum is zero, inserts the first argument, etc.
- */
- BoundMethodHandle(MethodType type, MethodHandle mh, Object argument, int argnum) {
- super(Access.TOKEN, type);
- if (mh.type().parameterType(argnum).isPrimitive())
- this.argument = bindPrimitiveArgument(argument, mh, argnum);
- else {
- this.argument = checkReferenceArgument(argument, mh, argnum);
- }
- this.vmargslot = type.parameterSlotDepth(argnum);
- initTarget(mh, argnum);
- }
-
- private void initTarget(MethodHandle mh, int argnum) {
- if (MethodHandleNatives.JVM_SUPPORT) {
- this.vmtarget = null; // maybe updated by JVM
- MethodHandleNatives.init(this, mh, argnum);
- } else {
- this.vmtarget = mh;
- }
- }
-
- /** For the AdapterMethodHandle subclass.
- */
- BoundMethodHandle(MethodType type, Object argument, int vmargslot) {
- super(Access.TOKEN, type);
- this.argument = argument;
- this.vmargslot = vmargslot;
- assert(this instanceof AdapterMethodHandle);
- }
-
- /** Initialize the current object as a self-bound method handle, binding it
- * as the first argument of the method handle {@code entryPoint}.
- * The invocation type of the resulting method handle will be the
- * same as {@code entryPoint}, except that the first argument
- * type will be dropped.
- */
- protected BoundMethodHandle(Access token, MethodHandle entryPoint) {
- super(token, entryPoint.type().dropParameterTypes(0, 1));
- this.argument = this; // kludge; get rid of
- this.vmargslot = this.type().parameterSlotDepth(0);
- initTarget(entryPoint, 0);
- }
-
- /** Make sure the given {@code argument} can be used as {@code argnum}-th
- * parameter of the given method handle {@code mh}, which must be a reference.
- * <p>
- * If this fails, throw a suitable {@code WrongMethodTypeException},
- * which will prevent the creation of an illegally typed bound
- * method handle.
- */
- final static Object checkReferenceArgument(Object argument, MethodHandle mh, int argnum) {
- Class<?> ptype = mh.type().parameterType(argnum);
- if (ptype.isPrimitive()) {
- // fail
- } else if (argument == null) {
- return null;
- } else if (VerifyType.isNullReferenceConversion(argument.getClass(), ptype)) {
- return argument;
- }
- throw badBoundArgumentException(argument, mh, argnum);
- }
-
- /** Make sure the given {@code argument} can be used as {@code argnum}-th
- * parameter of the given method handle {@code mh}, which must be a primitive.
- * <p>
- * If this fails, throw a suitable {@code WrongMethodTypeException},
- * which will prevent the creation of an illegally typed bound
- * method handle.
- */
- final static Object bindPrimitiveArgument(Object argument, MethodHandle mh, int argnum) {
- Class<?> ptype = mh.type().parameterType(argnum);
- Wrapper wrap = Wrapper.forPrimitiveType(ptype);
- Object zero = wrap.zero();
- if (zero == null) {
- // fail
- } else if (argument == null) {
- if (ptype != int.class && wrap.isSubwordOrInt())
- return Integer.valueOf(0);
- else
- return zero;
- } else if (VerifyType.isNullReferenceConversion(argument.getClass(), zero.getClass())) {
- if (ptype != int.class && wrap.isSubwordOrInt())
- return Wrapper.INT.wrap(argument);
- else
- return argument;
- }
- throw badBoundArgumentException(argument, mh, argnum);
- }
-
- final static RuntimeException badBoundArgumentException(Object argument, MethodHandle mh, int argnum) {
- String atype = (argument == null) ? "null" : argument.getClass().toString();
- return new WrongMethodTypeException("cannot bind "+atype+" argument to parameter #"+argnum+" of "+mh.type());
- }
-
- @Override
- public String toString() {
- return MethodHandleImpl.addTypeString(baseName(), this);
- }
-
- /** Component of toString() before the type string. */
- protected String baseName() {
- MethodHandle mh = this;
- while (mh instanceof BoundMethodHandle) {
- Object info = MethodHandleNatives.getTargetInfo(mh);
- if (info instanceof MethodHandle) {
- mh = (MethodHandle) info;
- } else {
- String name = null;
- if (info instanceof MemberName)
- name = ((MemberName)info).getName();
- if (name != null)
- return name;
- else
- return noParens(super.toString()); // "invoke", probably
- }
- assert(mh != this);
- }
- return noParens(mh.toString());
- }
-
- private static String noParens(String str) {
- int paren = str.indexOf('(');
- if (paren >= 0) str = str.substring(0, paren);
- return str;
- }
-}
--- a/jdk/src/share/classes/sun/dyn/CallSiteImpl.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import static sun.dyn.MemberName.uncaughtException;
-
-/**
- * Parts of CallSite known to the JVM.
- * @author jrose
- */
-public class CallSiteImpl {
- // this implements the upcall from the JVM, MethodHandleNatives.makeDynamicCallSite:
- static CallSite makeSite(MethodHandle bootstrapMethod,
- // Callee information:
- String name, MethodType type,
- // Extra arguments for BSM, if any:
- Object info,
- // Caller information:
- MemberName callerMethod, int callerBCI) {
- Class<?> callerClass = callerMethod.getDeclaringClass();
- Object caller;
- if (bootstrapMethod.type().parameterType(0) == Class.class && TRANSITIONAL_BEFORE_PFD)
- caller = callerClass; // remove for PFD
- else
- caller = MethodHandleImpl.IMPL_LOOKUP.in(callerClass);
- if (bootstrapMethod == null && TRANSITIONAL_BEFORE_PFD) {
- // If there is no bootstrap method, throw IncompatibleClassChangeError.
- // This is a valid generic error type for resolution (JLS 12.3.3).
- throw new IncompatibleClassChangeError
- ("Class "+callerClass.getName()+" has not declared a bootstrap method for invokedynamic");
- }
- CallSite site;
- try {
- Object binding;
- info = maybeReBox(info);
- if (info == null) {
- binding = bootstrapMethod.invokeGeneric(caller, name, type);
- } else if (!info.getClass().isArray()) {
- binding = bootstrapMethod.invokeGeneric(caller, name, type, info);
- } else {
- Object[] argv = (Object[]) info;
- if (3 + argv.length > 255)
- new InvokeDynamicBootstrapError("too many bootstrap method arguments");
- MethodType bsmType = bootstrapMethod.type();
- if (bsmType.parameterCount() == 4 && bsmType.parameterType(3) == Object[].class)
- binding = bootstrapMethod.invokeGeneric(caller, name, type, argv);
- else
- binding = MethodHandles.spreadInvoker(bsmType, 3)
- .invokeGeneric(bootstrapMethod, caller, name, type, argv);
- }
- //System.out.println("BSM for "+name+type+" => "+binding);
- if (binding instanceof CallSite) {
- site = (CallSite) binding;
- } else if (binding instanceof MethodHandle && TRANSITIONAL_BEFORE_PFD) {
- // Transitional!
- MethodHandle target = (MethodHandle) binding;
- site = new ConstantCallSite(target);
- } else {
- throw new ClassCastException("bootstrap method failed to produce a CallSite");
- }
- if (TRANSITIONAL_BEFORE_PFD)
- PRIVATE_INITIALIZE_CALL_SITE.invokeExact(site, name, type,
- callerMethod, callerBCI);
- assert(site.getTarget() != null);
- assert(site.getTarget().type().equals(type));
- } catch (Throwable ex) {
- InvokeDynamicBootstrapError bex;
- if (ex instanceof InvokeDynamicBootstrapError)
- bex = (InvokeDynamicBootstrapError) ex;
- else
- bex = new InvokeDynamicBootstrapError("call site initialization exception", ex);
- throw bex;
- }
- return site;
- }
-
- private static boolean TRANSITIONAL_BEFORE_PFD = true; // FIXME: remove for PFD
-
- private static Object maybeReBox(Object x) {
- if (x instanceof Integer) {
- int xi = (int) x;
- if (xi == (byte) xi)
- x = xi; // must rebox; see JLS 5.1.7
- return x;
- } else if (x instanceof Object[]) {
- Object[] xa = (Object[]) x;
- for (int i = 0; i < xa.length; i++) {
- if (xa[i] instanceof Integer)
- xa[i] = maybeReBox(xa[i]);
- }
- return xa;
- } else {
- return x;
- }
- }
-
- // This method is private in CallSite because it touches private fields in CallSite.
- // These private fields (vmmethod, vmindex) are specific to the JVM.
- private static final MethodHandle PRIVATE_INITIALIZE_CALL_SITE;
- static {
- try {
- PRIVATE_INITIALIZE_CALL_SITE =
- !TRANSITIONAL_BEFORE_PFD ? null :
- MethodHandleImpl.IMPL_LOOKUP.findVirtual(CallSite.class, "initializeFromJVM",
- MethodType.methodType(void.class,
- String.class, MethodType.class,
- MemberName.class, int.class));
- } catch (ReflectiveOperationException ex) {
- throw uncaughtException(ex);
- }
- }
-
- public static void setCallSiteTarget(Access token, CallSite site, MethodHandle target) {
- Access.check(token);
- MethodHandleNatives.setCallSiteTarget(site, target);
- }
-}
--- a/jdk/src/share/classes/sun/dyn/DirectMethodHandle.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import static sun.dyn.MethodHandleNatives.Constants.*;
-
-/**
- * The flavor of method handle which emulates invokespecial or invokestatic.
- * @author jrose
- */
-class DirectMethodHandle extends MethodHandle {
- //inherited oop vmtarget; // methodOop or virtual class/interface oop
- private final int vmindex; // method index within class or interface
- { vmindex = VM_INDEX_UNINITIALIZED; } // JVM may change this
-
- // Constructors in this class *must* be package scoped or private.
- DirectMethodHandle(MethodType mtype, MemberName m, boolean doDispatch, Class<?> lookupClass) {
- super(Access.TOKEN, mtype);
-
- assert(m.isMethod() || !doDispatch && m.isConstructor());
- if (!m.isResolved())
- throw new InternalError();
-
- MethodHandleNatives.init(this, (Object) m, doDispatch, lookupClass);
- }
-
- boolean isValid() {
- return (vmindex != VM_INDEX_UNINITIALIZED);
- }
-}
--- a/jdk/src/share/classes/sun/dyn/FilterGeneric.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4496 +0,0 @@
-/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import java.lang.reflect.*;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-
-/**
- * These adapters apply arbitrary conversions to arguments
- * on the way to a ultimate target.
- * For simplicity, these are all generically typed.
- * @author jrose
- */
-class FilterGeneric {
- // type for the incoming call (will be generic)
- private final MethodType entryType;
- // prototype adapters (clone and customize for each new target & conversion!)
- private final Adapter[] adapters;
-
- /** Compute and cache information common to all filtering adapters
- * with the given generic type
- */
- FilterGeneric(MethodType entryType) {
- this.entryType = entryType;
- int tableSize = Kind.LIMIT.invokerIndex(1 + entryType.parameterCount());
- this.adapters = new Adapter[tableSize];
- }
-
- Adapter getAdapter(Kind kind, int pos) {
- int index = kind.invokerIndex(pos);
- Adapter ad = adapters[index];
- if (ad != null) return ad;
- ad = findAdapter(entryType, kind, pos);
- if (ad == null)
- ad = buildAdapterFromBytecodes(entryType, kind, pos);
- adapters[index] = ad;
- return ad;
- }
-
- Adapter makeInstance(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
- Adapter ad = getAdapter(kind, pos);
- return ad.makeInstance(ad.prototypeEntryPoint(), filter, target);
- }
-
- /** Build an adapter of the given generic type, which invokes filter
- * on the selected incoming argument before passing it to the target.
- * @param pos the argument to filter
- * @param filter the function to call on the argument
- * @param target the target to call with the modified argument list
- * @return an adapter method handle
- */
- public static MethodHandle makeArgumentFilter(int pos, MethodHandle filter, MethodHandle target) {
- return make(Kind.value, pos, filter, target);
- }
-
- /** Build an adapter of the given generic type, which invokes a combiner
- * on a selected group of leading arguments.
- * The result of the combiner is prepended before all those arguments.
- * @param combiner the function to call on the selected leading arguments
- * @param target the target to call with the modified argument list
- * @return an adapter method handle
- */
- public static MethodHandle makeArgumentFolder(MethodHandle combiner, MethodHandle target) {
- int num = combiner.type().parameterCount();
- return make(Kind.fold, num, combiner, target);
- }
-
- /** Build an adapter of the given generic type, which invokes a filter
- * on the incoming arguments, reified as a group.
- * The argument may be modified (by side effects in the filter).
- * The arguments, possibly modified, are passed on to the target.
- * @param filter the function to call on the arguments
- * @param target the target to call with the possibly-modified argument list
- * @return an adapter method handle
- */
- public static MethodHandle makeFlyby(MethodHandle filter, MethodHandle target) {
- return make(Kind.flyby, 0, filter, target);
- }
-
- /** Build an adapter of the given generic type, which invokes a collector
- * on the selected incoming argument and all following arguments.
- * The result of the collector replaces all those arguments.
- * @param collector the function to call on the selected trailing arguments
- * @param target the target to call with the modified argument list
- * @return an adapter method handle
- */
- public static MethodHandle makeArgumentCollector(MethodHandle collector, MethodHandle target) {
- int pos = target.type().parameterCount() - 1;
- return make(Kind.collect, pos, collector, target);
- }
-
- static MethodHandle make(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
- FilterGeneric fgen = of(kind, pos, filter.type(), target.type());
- return fgen.makeInstance(kind, pos, filter, target);
- }
-
- /** Return the adapter information for this target and filter type. */
- static FilterGeneric of(Kind kind, int pos, MethodType filterType, MethodType targetType) {
- MethodType entryType = entryType(kind, pos, filterType, targetType);
- if (entryType.generic() != entryType)
- throw newIllegalArgumentException("must be generic: "+entryType);
- MethodTypeImpl form = MethodTypeImpl.of(entryType);
- FilterGeneric filterGen = form.filterGeneric;
- if (filterGen == null)
- form.filterGeneric = filterGen = new FilterGeneric(entryType);
- return filterGen;
- }
-
- public String toString() {
- return "FilterGeneric/"+entryType;
- }
-
- static MethodType targetType(MethodType entryType, Kind kind, int pos, MethodType filterType) {
- MethodType type = entryType;
- switch (kind) {
- case value:
- case flyby:
- break; // no change
- case fold:
- type = type.insertParameterTypes(0, filterType.returnType());
- break;
- case collect:
- type = type.dropParameterTypes(pos, type.parameterCount());
- type = type.insertParameterTypes(pos, filterType.returnType());
- break;
- default:
- throw new InternalError();
- }
- return type;
- }
-
- static MethodType entryType(Kind kind, int pos, MethodType filterType, MethodType targetType) {
- MethodType type = targetType;
- switch (kind) {
- case value:
- case flyby:
- break; // no change
- case fold:
- type = type.dropParameterTypes(0, 1);
- break;
- case collect:
- type = type.dropParameterTypes(pos, pos+1);
- type = type.insertParameterTypes(pos, filterType.parameterList());
- break;
- default:
- throw new InternalError();
- }
- return type;
- }
-
- /* Create an adapter that handles spreading calls for the given type. */
- static Adapter findAdapter(MethodType entryType, Kind kind, int pos) {
- int argc = entryType.parameterCount();
- String cname0 = "F"+argc;
- String cname1 = "F"+argc+kind.key;
- String[] cnames = { cname0, cname1 };
- String iname = kind.invokerName(pos);
- // e.g., F5; invoke_C3
- for (String cname : cnames) {
- Class<? extends Adapter> acls = Adapter.findSubClass(cname);
- if (acls == null) continue;
- // see if it has the required invoke method
- MethodHandle entryPoint = null;
- try {
- entryPoint = MethodHandleImpl.IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
- } catch (ReflectiveOperationException ex) {
- }
- if (entryPoint == null) continue;
- Constructor<? extends Adapter> ctor = null;
- try {
- ctor = acls.getDeclaredConstructor(MethodHandle.class);
- } catch (NoSuchMethodException ex) {
- } catch (SecurityException ex) {
- }
- if (ctor == null) continue;
- try {
- // Produce an instance configured as a prototype.
- return ctor.newInstance(entryPoint);
- } catch (IllegalArgumentException ex) {
- } catch (InvocationTargetException wex) {
- Throwable ex = wex.getTargetException();
- if (ex instanceof Error) throw (Error)ex;
- if (ex instanceof RuntimeException) throw (RuntimeException)ex;
- } catch (InstantiationException ex) {
- } catch (IllegalAccessException ex) {
- }
- }
- return null;
- }
-
- static Adapter buildAdapterFromBytecodes(MethodType entryType, Kind kind, int pos) {
- throw new UnsupportedOperationException("NYI");
- }
-
- /**
- * This adapter takes some untyped arguments, and returns an untyped result.
- * Internally, it applies the invoker to the target, which causes the
- * objects to be unboxed; the result is a raw type in L/I/J/F/D.
- * This result is passed to convert, which is responsible for
- * converting the raw result into a boxed object.
- * The invoker is kept separate from the target because it can be
- * generated once per type erasure family, and reused across adapters.
- */
- static abstract class Adapter extends BoundMethodHandle {
- protected final MethodHandle filter; // transforms one or more arguments
- protected final MethodHandle target; // ultimate target
-
- @Override
- public String toString() {
- return MethodHandleImpl.addTypeString(target, this);
- }
-
- protected boolean isPrototype() { return target == null; }
- protected Adapter(MethodHandle entryPoint) {
- this(entryPoint, entryPoint, null);
- assert(isPrototype());
- }
- protected MethodHandle prototypeEntryPoint() {
- if (!isPrototype()) throw new InternalError();
- return filter;
- }
-
- protected Adapter(MethodHandle entryPoint,
- MethodHandle filter, MethodHandle target) {
- super(Access.TOKEN, entryPoint);
- this.filter = filter;
- this.target = target;
- }
-
- /** Make a copy of self, with new fields. */
- protected abstract Adapter makeInstance(MethodHandle entryPoint,
- MethodHandle filter, MethodHandle target);
- // { return new ThisType(entryPoint, filter, target); }
-
- static private final String CLASS_PREFIX; // "sun.dyn.FilterGeneric$"
- static {
- String aname = Adapter.class.getName();
- String sname = Adapter.class.getSimpleName();
- if (!aname.endsWith(sname)) throw new InternalError();
- CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
- }
- /** Find a sibing class of Adapter. */
- static Class<? extends Adapter> findSubClass(String name) {
- String cname = Adapter.CLASS_PREFIX + name;
- try {
- return Class.forName(cname).asSubclass(Adapter.class);
- } catch (ClassNotFoundException ex) {
- return null;
- } catch (ClassCastException ex) {
- return null;
- }
- }
- }
-
- static enum Kind {
- value('V'), // filter and replace Nth argument value
- fold('F'), // fold first N arguments, prepend result
- collect('C'), // collect last N arguments, replace with result
- flyby('Y'), // reify entire argument list, filter, pass to target
- LIMIT('?');
- static final int COUNT = LIMIT.ordinal();
-
- final char key;
- Kind(char key) { this.key = key; }
- String invokerName(int pos) { return "invoke_"+key+""+pos; }
- int invokerIndex(int pos) { return pos * COUNT + ordinal(); }
- }
-
- /* generated classes follow this pattern:
- static class F1X extends Adapter {
- protected F1X(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F1X(MethodHandle e, MethodHandle f, MethodHandle t)
- { super(e, f, t); }
- protected F1X makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
- { return new F1X(e, f, t); }
- protected Object invoke_V0(Object a0) { return target.invokeExact(filter.invokeExact(a0)); }
- protected Object invoke_F0(Object a0) { return target.invokeExact(filter.invokeExact(), a0); }
- protected Object invoke_F1(Object a0) { return target.invokeExact(filter.invokeExact(a0), a0); }
- protected Object invoke_C0(Object a0) { return target.invokeExact(filter.invokeExact(a0)); }
- protected Object invoke_C1(Object a0) { return target.invokeExact(a0, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0) { Object[] av = { a0 };
- filter.invokeExact(av); return target.invokeExact(av[0]); }
- }
- static class F2X extends Adapter {
- protected F2X(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F2X(MethodHandle e, MethodHandle f, MethodHandle t)
- { super(e, f, t); }
- protected F2X makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
- { return new F2X(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0), a1); }
- protected Object invoke_V1(Object a0, Object a1) { return target.invokeExact(a0, filter.invokeExact(a1)); }
- protected Object invoke_F0(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(), a0, a1); }
- protected Object invoke_F1(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0), a0, a1); }
- protected Object invoke_F2(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0, a1), a0, a1); }
- protected Object invoke_C0(Object a0, Object a1) { return target.invokeExact(filter.invokeExact(a0, a1)); }
- protected Object invoke_C1(Object a0, Object a1) { return target.invokeExact(a0, filter.invokeExact(a1)); }
- protected Object invoke_C2(Object a0, Object a1) { return target.invokeExact(a0, a1, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1) { Object[] av = { a0, a1 };
- filter.invokeExact(av); return target.invokeExact(av[0], av[1]); }
- }
- // */
-
- // This one is written by hand:
- static class F0 extends Adapter {
- protected F0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F0(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F0 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F0(e, f, t); }
- protected Object invoke_F0() throws Throwable {
- return target.invokeExact(filter.invokeExact()); }
- protected Object invoke_C0() throws Throwable {
- return target.invokeExact(filter.invokeExact()); }
- static final Object[] NO_ARGS = { };
- protected Object invoke_Y0() throws Throwable {
- filter.invokeExact(NO_ARGS); // make the flyby
- return target.invokeExact(); }
- }
-
-/*
- : SHELL; n=FilterGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -ea -cp . genclasses | sed 's| *[/]/ *$||') >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
-//{{{
-import java.util.*;
-class genclasses {
- static String[][] TEMPLATES = { {
- "@for@ N=1..20",
- " //@each-cat@",
- " static class @cat@ extends Adapter {",
- " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
- " protected @cat@(MethodHandle e, MethodHandle f, MethodHandle t) {",
- " super(e, f, t); }",
- " protected @cat@ makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {",
- " return new @cat@(e, f, t); }",
- " //@each-P@",
- " protected Object invoke_V@P@(@Tvav@) throws Throwable {",
- " return target.invokeExact(@a0_@@Psp@filter.invokeExact(a@P@)@_aN@); }",
- " //@end-P@",
- " //@each-P@",
- " protected Object invoke_F@P@(@Tvav@) throws Throwable {",
- " return target.invokeExact(filter.invokeExact(@a0@),",
- " @av@); }",
- " //@end-P@",
- " protected Object invoke_F@N@(@Tvav@) throws Throwable {",
- " return target.invokeExact(filter.invokeExact(@av@),",
- " @av@); }",
- " //@each-P@",
- " protected Object invoke_C@P@(@Tvav@) throws Throwable {",
- " return target.invokeExact(@a0_@filter.invokeExact(a@P@@_aN@)); }",
- " //@end-P@",
- " protected Object invoke_C@N@(@Tvav@) throws Throwable {",
- " return target.invokeExact(@av@, filter.invokeExact()); }",
- " protected Object invoke_Y0(@Tvav@) throws Throwable {",
- " Object[] av = { @av@ };",
- " filter.invokeExact(av); // make the flyby",
- " return target.invokeExact(@av[i]@); }",
- " }",
- } };
- static final String NEWLINE_INDENT = " //\n ";
- enum VAR {
- cat, N, P, Tvav, av, a0, a0_, _aN, Psp, av_i_;
- public final String pattern = "@"+toString().replace('_','.')+"@";
- public String binding = toString();
- static void makeBindings(boolean topLevel, int inargs, int pos) {
- assert(-1 <= pos && pos < inargs);
- VAR.cat.binding = "F"+inargs;
- VAR.N.binding = String.valueOf(inargs); // incoming arg count
- VAR.P.binding = String.valueOf(pos); // selected arg position
- String[] av = new String[inargs];
- String[] Tvav = new String[inargs];
- String[] av_i_ = new String[inargs];
- for (int i = 0; i < inargs; i++) {
- av[i] = arg(i);
- av_i_[i] = "av["+i+"]";
- String spc = "";
- if (i > 0 && i % 4 == 0) spc = NEWLINE_INDENT+(pos>9?" ":"")+" ";
- Tvav[i] = spc+param("Object", av[i]);
- }
- VAR.av.binding = comma(av);
- VAR.av_i_.binding = comma(av_i_);
- VAR.Tvav.binding = comma(Tvav);
- if (pos >= 0) {
- VAR.Psp.binding = (pos > 0 && pos % 10 == 0) ? NEWLINE_INDENT : "";
- String[] a0 = new String[pos];
- String[] aN = new String[inargs - (pos+1)];
- for (int i = 0; i < pos; i++) {
- String spc = "";
- if (i > 0 && i % 10 == 0) spc = NEWLINE_INDENT;
- a0[i] = spc+av[i];
- }
- VAR.a0.binding = comma(a0);
- VAR.a0_.binding = comma(a0, ", ");
- for (int i = pos+1; i < inargs; i++) {
- String spc = "";
- if (i > 0 && i % 10 == 0) spc = NEWLINE_INDENT;
- aN[i - (pos+1)] = spc+av[i];
- }
- VAR._aN.binding = comma(", ", aN);
- }
- }
- static String arg(int i) { return "a"+i; }
- static String param(String t, String a) { return t+" "+a; }
- static String comma(String[] v) { return comma(v, ""); }
- static String comma(String[] v, String sep) { return comma("", v, sep); }
- static String comma(String sep, String[] v) { return comma(sep, v, ""); }
- static String comma(String sep1, String[] v, String sep2) {
- if (v.length == 0) return "";
- String res = v[0];
- for (int i = 1; i < v.length; i++) res += ", "+v[i];
- return sep1 + res + sep2;
- }
- static String transform(String string) {
- for (VAR var : values())
- string = string.replaceAll(var.pattern, var.binding);
- return string;
- }
- }
- static String[] stringsIn(String[] strings, int beg, int end) {
- return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
- }
- static String[] stringsBefore(String[] strings, int pos) {
- return stringsIn(strings, 0, pos);
- }
- static String[] stringsAfter(String[] strings, int pos) {
- return stringsIn(strings, pos, strings.length);
- }
- static int indexAfter(String[] strings, int pos, String tag) {
- return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
- }
- static int indexBefore(String[] strings, int pos, String tag) {
- for (int i = pos, end = strings.length; ; i++) {
- if (i == end || strings[i].endsWith(tag)) return i;
- }
- }
- static int MIN_ARITY, MAX_ARITY;
- public static void main(String... av) {
- for (String[] template : TEMPLATES) {
- int forLinesLimit = indexBefore(template, 0, "@each-cat@");
- String[] forLines = stringsBefore(template, forLinesLimit);
- template = stringsAfter(template, forLinesLimit);
- for (String forLine : forLines)
- expandTemplate(forLine, template);
- }
- }
- static void expandTemplate(String forLine, String[] template) {
- String[] params = forLine.split("[^0-9]+");
- if (params[0].length() == 0) params = stringsAfter(params, 1);
- System.out.println("//params="+Arrays.asList(params));
- int pcur = 0;
- MIN_ARITY = Integer.valueOf(params[pcur++]);
- MAX_ARITY = Integer.valueOf(params[pcur++]);
- if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
- for (int inargs = MIN_ARITY; inargs <= MAX_ARITY; inargs++) {
- expandTemplate(template, true, inargs, -1);
- }
- }
- static void expandTemplate(String[] template, boolean topLevel, int inargs, int pos) {
- VAR.makeBindings(topLevel, inargs, pos);
- for (int i = 0; i < template.length; i++) {
- String line = template[i];
- if (line.endsWith("@each-cat@")) {
- // ignore
- } else if (line.endsWith("@each-P@")) {
- int blockEnd = indexAfter(template, i, "@end-P@");
- String[] block = stringsIn(template, i+1, blockEnd-1);
- for (int pos1 = Math.max(0,pos); pos1 < inargs; pos1++)
- expandTemplate(block, false, inargs, pos1);
- VAR.makeBindings(topLevel, inargs, pos);
- i = blockEnd-1; continue;
- } else {
- System.out.println(VAR.transform(line));
- }
- }
- }
-}
-//}}} */
-//params=[1, 20]
- static class F1 extends Adapter {
- protected F1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F1(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F1 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F1(e, f, t); }
- protected Object invoke_V0(Object a0) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0)); }
- protected Object invoke_F0(Object a0) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0); }
- protected Object invoke_F1(Object a0) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0); }
- protected Object invoke_C0(Object a0) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0)); }
- protected Object invoke_C1(Object a0) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0) throws Throwable {
- Object[] av = { a0 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0]); }
- }
- static class F2 extends Adapter {
- protected F2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F2(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F2 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F2(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1); }
- protected Object invoke_V1(Object a0, Object a1) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1)); }
- protected Object invoke_F0(Object a0, Object a1) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1); }
- protected Object invoke_F1(Object a0, Object a1) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1); }
- protected Object invoke_F2(Object a0, Object a1) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1); }
- protected Object invoke_C0(Object a0, Object a1) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1)); }
- protected Object invoke_C1(Object a0, Object a1) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1)); }
- protected Object invoke_C2(Object a0, Object a1) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1) throws Throwable {
- Object[] av = { a0, a1 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1]); }
- }
- static class F3 extends Adapter {
- protected F3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F3(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F3 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F3(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2); }
- protected Object invoke_V1(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2); }
- protected Object invoke_V2(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2); }
- protected Object invoke_F1(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2); }
- protected Object invoke_F2(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2); }
- protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2); }
- protected Object invoke_C0(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2) throws Throwable {
- Object[] av = { a0, a1, a2 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2]); }
- }
- static class F4 extends Adapter {
- protected F4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F4(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F4 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F4(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- Object[] av = { a0, a1, a2, a3 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3]); }
- }
- static class F5 extends Adapter {
- protected F5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F5(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F5 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F5(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4]); }
- }
- static class F6 extends Adapter {
- protected F6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F6(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F6 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F6(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5]); }
- }
- static class F7 extends Adapter {
- protected F7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F7(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F7 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F7(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6]); }
- }
- static class F8 extends Adapter {
- protected F8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F8(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F8 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F8(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7]); }
- }
- static class F9 extends Adapter {
- protected F9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F9(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F9 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F9(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8]); }
- }
- static class F10 extends Adapter {
- protected F10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F10(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F10 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F10(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9]); }
- }
- static class F11 extends Adapter {
- protected F11(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F11(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F11 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F11(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10]); }
- }
- static class F12 extends Adapter {
- protected F12(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F12(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F12 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F12(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11]); }
- }
- static class F13 extends Adapter {
- protected F13(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F13(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F13 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F13(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12]); }
- }
- static class F14 extends Adapter {
- protected F14(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F14(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F14 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F14(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12, a13); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12, a13); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12, a13); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12, a13); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12, a13); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12), a13); }
- protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12, a13)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12, a13)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12, a13)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13)); }
- protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13]); }
- }
- static class F15 extends Adapter {
- protected F15(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F15(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F15 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F15(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12, a13, a14); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12, a13, a14); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12, a13, a14); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12, a13, a14); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12), a13, a14); }
- protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13), a14); }
- protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12, a13, a14)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12, a13, a14)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12, a13, a14)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13, a14)); }
- protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14)); }
- protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14]); }
- }
- static class F16 extends Adapter {
- protected F16(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F16(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F16 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F16(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12, a13, a14, a15); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12, a13, a14, a15); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12, a13, a14, a15); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12), a13, a14, a15); }
- protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13), a14, a15); }
- protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14), a15); }
- protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12, a13, a14, a15)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12, a13, a14, a15)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13, a14, a15)); }
- protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14, a15)); }
- protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15)); }
- protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15]); }
- }
- static class F17 extends Adapter {
- protected F17(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F17(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F17 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F17(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12, a13, a14, a15, a16); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12, a13, a14, a15, a16); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12), a13, a14, a15, a16); }
- protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13), a14, a15, a16); }
- protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14), a15, a16); }
- protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15), a16); }
- protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12, a13, a14, a15, a16)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12, a13, a14, a15, a16)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13, a14, a15, a16)); }
- protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14, a15, a16)); }
- protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15, a16)); }
- protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16)); }
- protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16]); }
- }
- static class F18 extends Adapter {
- protected F18(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F18(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F18 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F18(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12, a13, a14, a15, a16, a17); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12), a13, a14, a15, a16, a17); }
- protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13), a14, a15, a16, a17); }
- protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14), a15, a16, a17); }
- protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15), a16, a17); }
- protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16), a17); }
- protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12, a13, a14, a15, a16, a17)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13, a14, a15, a16, a17)); }
- protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14, a15, a16, a17)); }
- protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15, a16, a17)); }
- protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16, a17)); }
- protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17)); }
- protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17]); }
- }
- static class F19 extends Adapter {
- protected F19(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F19(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F19 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F19(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12), a13, a14, a15, a16, a17, a18); }
- protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13), a14, a15, a16, a17, a18); }
- protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14), a15, a16, a17, a18); }
- protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15), a16, a17, a18); }
- protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16), a17, a18); }
- protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17), a18); }
- protected Object invoke_V18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_F19(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12, a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13, a14, a15, a16, a17, a18)); }
- protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14, a15, a16, a17, a18)); }
- protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15, a16, a17, a18)); }
- protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16, a17, a18)); }
- protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17, a18)); }
- protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18)); }
- protected Object invoke_C19(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17], av[18]); }
- }
- static class F20 extends Adapter {
- protected F20(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected F20(MethodHandle e, MethodHandle f, MethodHandle t) {
- super(e, f, t); }
- protected F20 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
- return new F20(e, f, t); }
- protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1), a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2), a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3), a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4), a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5), a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6), a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7), a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8), a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9),
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- filter.invokeExact(a10), a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11), a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12), a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13), a14, a15, a16, a17, a18, a19); }
- protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14), a15, a16, a17, a18, a19); }
- protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15), a16, a17, a18, a19); }
- protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16), a17, a18, a19); }
- protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17), a18, a19); }
- protected Object invoke_V18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18), a19); }
- protected Object invoke_V19(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invokeExact(a19)); }
- protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F19(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_F20(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19),
- a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
- protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(filter.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, filter.invokeExact(a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, filter.invokeExact(a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, filter.invokeExact(a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, filter.invokeExact(a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, filter.invokeExact(a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, filter.invokeExact(a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, filter.invokeExact(a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, filter.invokeExact(a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invokeExact(a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invokeExact(a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, filter.invokeExact(a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, filter.invokeExact(a12, a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, filter.invokeExact(a13, a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, filter.invokeExact(a14, a15, a16, a17, a18, a19)); }
- protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, filter.invokeExact(a15, a16, a17, a18, a19)); }
- protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, filter.invokeExact(a16, a17, a18, a19)); }
- protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, filter.invokeExact(a17, a18, a19)); }
- protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, filter.invokeExact(a18, a19)); }
- protected Object invoke_C19(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
- a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invokeExact(a19)); }
- protected Object invoke_C20(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, filter.invokeExact()); }
- protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5, Object a6, Object a7,
- Object a8, Object a9, Object a10, Object a11,
- Object a12, Object a13, Object a14, Object a15,
- Object a16, Object a17, Object a18, Object a19) throws Throwable {
- Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19 };
- filter.invokeExact(av); // make the flyby
- return target.invokeExact(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11], av[12], av[13], av[14], av[15], av[16], av[17], av[18], av[19]); }
- }
-}
--- a/jdk/src/share/classes/sun/dyn/FilterOneArgument.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import static sun.dyn.MemberName.uncaughtException;
-
-/**
- * Unary function composition, useful for many small plumbing jobs.
- * The invoke method takes a single reference argument, and returns a reference
- * Internally, it first calls the {@code filter} method on the argument,
- * Making up the difference between the raw method type and the
- * final method type is the responsibility of a JVM-level adapter.
- * @author jrose
- */
-public class FilterOneArgument extends BoundMethodHandle {
- protected final MethodHandle filter; // Object -> Object
- protected final MethodHandle target; // Object -> Object
-
- @Override
- public String toString() {
- return target.toString();
- }
-
- protected Object invoke(Object argument) throws Throwable {
- Object filteredArgument = filter.invokeExact(argument);
- return target.invokeExact(filteredArgument);
- }
-
- private static final MethodHandle INVOKE;
- static {
- try {
- INVOKE =
- MethodHandleImpl.IMPL_LOOKUP.findVirtual(FilterOneArgument.class, "invoke",
- MethodType.genericMethodType(1));
- } catch (ReflectiveOperationException ex) {
- throw uncaughtException(ex);
- }
- }
-
- protected FilterOneArgument(MethodHandle filter, MethodHandle target) {
- super(Access.TOKEN, INVOKE);
- this.filter = filter;
- this.target = target;
- }
-
- public static MethodHandle make(MethodHandle filter, MethodHandle target) {
- if (filter == null) return target;
- if (target == null) return filter;
- return new FilterOneArgument(filter, target);
- }
-
-// MethodHandle make(MethodHandle filter1, MethodHandle filter2, MethodHandle target) {
-// MethodHandle filter = make(filter1, filter2);
-// return make(filter, target);
-// }
-}
--- a/jdk/src/share/classes/sun/dyn/FromGeneric.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,629 +0,0 @@
-/*
- * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import java.lang.reflect.*;
-import sun.dyn.util.*;
-import static sun.dyn.MethodTypeImpl.invokers;
-
-/**
- * Adapters which mediate between incoming calls which are generic
- * and outgoing calls which are not. Any call can be represented generically
- * boxing up its arguments, and (on return) unboxing the return value.
- * <p>
- * A call is "generic" (in MethodHandle terms) if its MethodType features
- * only Object arguments. A non-generic call therefore features
- * primitives and/or reference types other than Object.
- * An adapter has types for its incoming and outgoing calls.
- * The incoming call type is simply determined by the adapter's type
- * (the MethodType it presents to callers). The outgoing call type
- * is determined by the adapter's target (a MethodHandle that the adapter
- * either binds internally or else takes as a leading argument).
- * (To stretch the term, adapter-like method handles may have multiple
- * targets or be polymorphic across multiple call types.)
- * @author jrose
- */
-class FromGeneric {
- // type for the outgoing call (may have primitives, etc.)
- private final MethodType targetType;
- // type of the outgoing call internal to the adapter
- private final MethodType internalType;
- // prototype adapter (clone and customize for each new target!)
- private final Adapter adapter;
- // entry point for adapter (Adapter mh, a...) => ...
- private final MethodHandle entryPoint;
- // unboxing invoker of type (MH, Object**N) => raw return value
- // it makes up the difference of internalType => targetType
- private final MethodHandle unboxingInvoker;
- // conversion which boxes a the target's raw return value
- private final MethodHandle returnConversion;
-
- /** Compute and cache information common to all unboxing adapters
- * that can call out to targets of the erasure-family of the given erased type.
- */
- private FromGeneric(MethodType targetType) {
- this.targetType = targetType;
- MethodType internalType0;
- // the target invoker will generally need casts on reference arguments
- Adapter ad = findAdapter(internalType0 = targetType.erase());
- if (ad != null) {
- // Immediate hit to exactly the adapter we want,
- // with no monkeying around with primitive types.
- this.internalType = internalType0;
- this.adapter = ad;
- this.entryPoint = ad.prototypeEntryPoint();
- this.returnConversion = computeReturnConversion(targetType, internalType0);
- this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
- return;
- }
-
- // outgoing primitive arguments will be wrapped; unwrap them
- MethodType primsAsObj = MethodTypeImpl.of(targetType).primArgsAsBoxes();
- MethodType objArgsRawRet = MethodTypeImpl.of(primsAsObj).primsAsInts();
- if (objArgsRawRet != targetType)
- ad = findAdapter(internalType0 = objArgsRawRet);
- if (ad == null) {
- ad = buildAdapterFromBytecodes(internalType0 = targetType);
- }
- this.internalType = internalType0;
- this.adapter = ad;
- MethodType tepType = targetType.insertParameterTypes(0, adapter.getClass());
- this.entryPoint = ad.prototypeEntryPoint();
- this.returnConversion = computeReturnConversion(targetType, internalType0);
- this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
- }
-
- /**
- * The typed target will be called according to targetType.
- * The adapter code will in fact see the raw result from internalType,
- * and must box it into an object. Produce a converter for this.
- */
- private static MethodHandle computeReturnConversion(
- MethodType targetType, MethodType internalType) {
- Class<?> tret = targetType.returnType();
- Class<?> iret = internalType.returnType();
- Wrapper wrap = Wrapper.forBasicType(tret);
- if (!iret.isPrimitive()) {
- assert(iret == Object.class);
- return ValueConversions.identity();
- } else if (wrap.primitiveType() == iret) {
- return ValueConversions.box(wrap, false);
- } else {
- assert(tret == double.class ? iret == long.class : iret == int.class);
- return ValueConversions.boxRaw(wrap, false);
- }
- }
-
- /**
- * The typed target will need an exact invocation point; provide it here.
- * The adapter will possibly need to make a slightly different call,
- * so adapt the invoker. This way, the logic for making up the
- * difference between what the adapter can call and what the target
- * needs can be cached once per type.
- */
- private static MethodHandle computeUnboxingInvoker(
- MethodType targetType, MethodType internalType) {
- // All the adapters we have here have reference-untyped internal calls.
- assert(internalType == internalType.erase());
- MethodHandle invoker = invokers(targetType).exactInvoker();
- // cast all narrow reference types, unbox all primitive arguments:
- MethodType fixArgsType = internalType.changeReturnType(targetType.returnType());
- MethodHandle fixArgs = AdapterMethodHandle.convertArguments(Access.TOKEN,
- invoker, Invokers.invokerType(fixArgsType),
- invoker.type(), null);
- if (fixArgs == null)
- throw new InternalError("bad fixArgs");
- // reinterpret the calling sequence as raw:
- MethodHandle retyper = AdapterMethodHandle.makeRetypeRaw(Access.TOKEN,
- Invokers.invokerType(internalType), fixArgs);
- if (retyper == null)
- throw new InternalError("bad retyper");
- return retyper;
- }
-
- Adapter makeInstance(MethodHandle typedTarget) {
- MethodType type = typedTarget.type();
- if (type == targetType) {
- return adapter.makeInstance(entryPoint, unboxingInvoker, returnConversion, typedTarget);
- }
- // my erased-type is not exactly the same as the desired type
- assert(type.erase() == targetType); // else we are busted
- MethodHandle invoker = computeUnboxingInvoker(type, internalType);
- return adapter.makeInstance(entryPoint, invoker, returnConversion, typedTarget);
- }
-
- /** Build an adapter of the given generic type, which invokes typedTarget
- * on the incoming arguments, after unboxing as necessary.
- * The return value is boxed if necessary.
- * @param genericType the required type of the result
- * @param typedTarget the target
- * @return an adapter method handle
- */
- public static MethodHandle make(MethodHandle typedTarget) {
- MethodType type = typedTarget.type();
- if (type == type.generic()) return typedTarget;
- return FromGeneric.of(type).makeInstance(typedTarget);
- }
-
- /** Return the adapter information for this type's erasure. */
- static FromGeneric of(MethodType type) {
- MethodTypeImpl form = MethodTypeImpl.of(type);
- FromGeneric fromGen = form.fromGeneric;
- if (fromGen == null)
- form.fromGeneric = fromGen = new FromGeneric(form.erasedType());
- return fromGen;
- }
-
- public String toString() {
- return "FromGeneric"+targetType;
- }
-
- /* Create an adapter that handles spreading calls for the given type. */
- static Adapter findAdapter(MethodType internalType) {
- MethodType entryType = internalType.generic();
- MethodTypeImpl form = MethodTypeImpl.of(internalType);
- Class<?> rtype = internalType.returnType();
- int argc = form.parameterCount();
- int lac = form.longPrimitiveParameterCount();
- int iac = form.primitiveParameterCount() - lac;
- String intsAndLongs = (iac > 0 ? "I"+iac : "")+(lac > 0 ? "J"+lac : "");
- String rawReturn = String.valueOf(Wrapper.forPrimitiveType(rtype).basicTypeChar());
- String cname0 = rawReturn + argc;
- String cname1 = "A" + argc;
- String[] cnames = { cname0+intsAndLongs, cname0, cname1+intsAndLongs, cname1 };
- String iname = "invoke_"+cname0+intsAndLongs;
- // e.g., D5I2, D5, L5I2, L5; invoke_D5
- for (String cname : cnames) {
- Class<? extends Adapter> acls = Adapter.findSubClass(cname);
- if (acls == null) continue;
- // see if it has the required invoke method
- MethodHandle entryPoint = null;
- try {
- entryPoint = MethodHandleImpl.IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
- } catch (ReflectiveOperationException ex) {
- }
- if (entryPoint == null) continue;
- Constructor<? extends Adapter> ctor = null;
- try {
- ctor = acls.getDeclaredConstructor(MethodHandle.class);
- } catch (NoSuchMethodException ex) {
- } catch (SecurityException ex) {
- }
- if (ctor == null) continue;
- try {
- // Produce an instance configured as a prototype.
- return ctor.newInstance(entryPoint);
- } catch (IllegalArgumentException ex) {
- } catch (InvocationTargetException wex) {
- Throwable ex = wex.getTargetException();
- if (ex instanceof Error) throw (Error)ex;
- if (ex instanceof RuntimeException) throw (RuntimeException)ex;
- } catch (InstantiationException ex) {
- } catch (IllegalAccessException ex) {
- }
- }
- return null;
- }
-
- static Adapter buildAdapterFromBytecodes(MethodType internalType) {
- throw new UnsupportedOperationException("NYI");
- }
-
- /**
- * This adapter takes some untyped arguments, and returns an untyped result.
- * Internally, it applies the invoker to the target, which causes the
- * objects to be unboxed; the result is a raw type in L/I/J/F/D.
- * This result is passed to convert, which is responsible for
- * converting the raw result into a boxed object.
- * The invoker is kept separate from the target because it can be
- * generated once per type erasure family, and reused across adapters.
- */
- static abstract class Adapter extends BoundMethodHandle {
- /*
- * class X<<R,int N>> extends Adapter {
- * (MH, Object**N)=>raw(R) invoker;
- * (any**N)=>R target;
- * raw(R)=>Object convert;
- * Object invoke(Object**N a) = convert(invoker(target, a...))
- * }
- */
- protected final MethodHandle invoker; // (MH, Object**N) => raw(R)
- protected final MethodHandle convert; // raw(R) => Object
- protected final MethodHandle target; // (any**N) => R
-
- @Override
- public String toString() {
- return MethodHandleImpl.addTypeString(target, this);
- }
-
- protected boolean isPrototype() { return target == null; }
- protected Adapter(MethodHandle entryPoint) {
- this(entryPoint, null, entryPoint, null);
- assert(isPrototype());
- }
- protected MethodHandle prototypeEntryPoint() {
- if (!isPrototype()) throw new InternalError();
- return convert;
- }
-
- protected Adapter(MethodHandle entryPoint,
- MethodHandle invoker, MethodHandle convert, MethodHandle target) {
- super(Access.TOKEN, entryPoint);
- this.invoker = invoker;
- this.convert = convert;
- this.target = target;
- }
-
- /** Make a copy of self, with new fields. */
- protected abstract Adapter makeInstance(MethodHandle entryPoint,
- MethodHandle invoker, MethodHandle convert, MethodHandle target);
- // { return new ThisType(entryPoint, convert, target); }
-
- /// Conversions on the value returned from the target.
- protected Object convert_L(Object result) throws Throwable { return convert.invokeExact(result); }
- protected Object convert_I(int result) throws Throwable { return convert.invokeExact(result); }
- protected Object convert_J(long result) throws Throwable { return convert.invokeExact(result); }
- protected Object convert_F(float result) throws Throwable { return convert.invokeExact(result); }
- protected Object convert_D(double result) throws Throwable { return convert.invokeExact(result); }
-
- static private final String CLASS_PREFIX; // "sun.dyn.FromGeneric$"
- static {
- String aname = Adapter.class.getName();
- String sname = Adapter.class.getSimpleName();
- if (!aname.endsWith(sname)) throw new InternalError();
- CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
- }
- /** Find a sibing class of Adapter. */
- static Class<? extends Adapter> findSubClass(String name) {
- String cname = Adapter.CLASS_PREFIX + name;
- try {
- return Class.forName(cname).asSubclass(Adapter.class);
- } catch (ClassNotFoundException ex) {
- return null;
- } catch (ClassCastException ex) {
- return null;
- }
- }
- }
-
- /* generated classes follow this pattern:
- static class xA2 extends Adapter {
- protected xA2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected xA2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected xA2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new xA2(e, i, c, t); }
- protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
- }
- // */
-
-/*
-: SHELL; n=FromGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
-//{{{
-import java.util.*;
-class genclasses {
- static String[] TYPES = { "Object", "int ", "long ", "float ", "double" };
- static String[] WRAPS = { " ", "(Integer)", "(Long) ", "(Float) ", "(Double) " };
- static String[] TCHARS = { "L", "I", "J", "F", "D", "A" };
- static String[][] TEMPLATES = { {
- "@for@ arity=0..10 rcat<=4 nrefs<=99 nints=0 nlongs=0",
- " //@each-cat@",
- " static class @cat@ extends Adapter {",
- " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
- " protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
- " { super(e, i, c, t); }",
- " protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
- " { return new @cat@(e, i, c, t); }",
- " //@each-R@",
- " protected Object invoke_@catN@(@Tvav@) throws Throwable { return convert_@Rc@((@R@)@W@invoker.invokeExact(target@av@)); }",
- " //@end-R@",
- " }",
- } };
- static final String NEWLINE_INDENT = "\n ";
- enum VAR {
- cat, catN, R, Rc, W, av, Tvav, Ovav;
- public final String pattern = "@"+toString().replace('_','.')+"@";
- public String binding;
- static void makeBindings(boolean topLevel, int rcat, int nrefs, int nints, int nlongs) {
- int nargs = nrefs + nints + nlongs;
- if (topLevel)
- VAR.cat.binding = catstr(ALL_RETURN_TYPES ? TYPES.length : rcat, nrefs, nints, nlongs);
- VAR.catN.binding = catstr(rcat, nrefs, nints, nlongs);
- VAR.R.binding = TYPES[rcat];
- VAR.Rc.binding = TCHARS[rcat];
- VAR.W.binding = WRAPS[rcat];
- String[] Tv = new String[nargs];
- String[] av = new String[nargs];
- String[] Tvav = new String[nargs];
- String[] Ovav = new String[nargs];
- for (int i = 0; i < nargs; i++) {
- int tcat = (i < nrefs) ? 0 : (i < nrefs + nints) ? 1 : 2;
- Tv[i] = TYPES[tcat];
- av[i] = arg(i);
- Tvav[i] = param(Tv[i], av[i]);
- Ovav[i] = param("Object", av[i]);
- }
- VAR.av.binding = comma(", ", av);
- VAR.Tvav.binding = comma(Tvav);
- VAR.Ovav.binding = comma(Ovav);
- }
- static String arg(int i) { return "a"+i; }
- static String param(String t, String a) { return t+" "+a; }
- static String comma(String[] v) { return comma("", v); }
- static String comma(String sep, String[] v) {
- if (v.length == 0) return "";
- String res = sep+v[0];
- for (int i = 1; i < v.length; i++) res += ", "+v[i];
- return res;
- }
- static String transform(String string) {
- for (VAR var : values())
- string = string.replaceAll(var.pattern, var.binding);
- return string;
- }
- }
- static String[] stringsIn(String[] strings, int beg, int end) {
- return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
- }
- static String[] stringsBefore(String[] strings, int pos) {
- return stringsIn(strings, 0, pos);
- }
- static String[] stringsAfter(String[] strings, int pos) {
- return stringsIn(strings, pos, strings.length);
- }
- static int indexAfter(String[] strings, int pos, String tag) {
- return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
- }
- static int indexBefore(String[] strings, int pos, String tag) {
- for (int i = pos, end = strings.length; ; i++) {
- if (i == end || strings[i].endsWith(tag)) return i;
- }
- }
- static int MIN_ARITY, MAX_ARITY, MAX_RCAT, MAX_REFS, MAX_INTS, MAX_LONGS;
- static boolean ALL_ARG_TYPES, ALL_RETURN_TYPES;
- static HashSet<String> done = new HashSet<String>();
- public static void main(String... av) {
- for (String[] template : TEMPLATES) {
- int forLinesLimit = indexBefore(template, 0, "@each-cat@");
- String[] forLines = stringsBefore(template, forLinesLimit);
- template = stringsAfter(template, forLinesLimit);
- for (String forLine : forLines)
- expandTemplate(forLine, template);
- }
- }
- static void expandTemplate(String forLine, String[] template) {
- String[] params = forLine.split("[^0-9]+");
- if (params[0].length() == 0) params = stringsAfter(params, 1);
- System.out.println("//params="+Arrays.asList(params));
- int pcur = 0;
- MIN_ARITY = Integer.valueOf(params[pcur++]);
- MAX_ARITY = Integer.valueOf(params[pcur++]);
- MAX_RCAT = Integer.valueOf(params[pcur++]);
- MAX_REFS = Integer.valueOf(params[pcur++]);
- MAX_INTS = Integer.valueOf(params[pcur++]);
- MAX_LONGS = Integer.valueOf(params[pcur++]);
- if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
- if (MAX_RCAT >= TYPES.length) MAX_RCAT = TYPES.length - 1;
- ALL_ARG_TYPES = (indexBefore(template, 0, "@each-Tv@") < template.length);
- ALL_RETURN_TYPES = (indexBefore(template, 0, "@each-R@") < template.length);
- for (int nargs = MIN_ARITY; nargs <= MAX_ARITY; nargs++) {
- for (int rcat = 0; rcat <= MAX_RCAT; rcat++) {
- expandTemplate(template, true, rcat, nargs, 0, 0);
- if (ALL_ARG_TYPES) break;
- expandTemplateForPrims(template, true, rcat, nargs, 1, 1);
- if (ALL_RETURN_TYPES) break;
- }
- }
- }
- static String catstr(int rcat, int nrefs, int nints, int nlongs) {
- int nargs = nrefs + nints + nlongs;
- String cat = TCHARS[rcat] + nargs;
- if (!ALL_ARG_TYPES) cat += (nints==0?"":"I"+nints)+(nlongs==0?"":"J"+nlongs);
- return cat;
- }
- static void expandTemplateForPrims(String[] template, boolean topLevel, int rcat, int nargs, int minints, int minlongs) {
- for (int isLong = 0; isLong <= 1; isLong++) {
- for (int nprims = 1; nprims <= nargs; nprims++) {
- int nrefs = nargs - nprims;
- int nints = ((1-isLong) * nprims);
- int nlongs = (isLong * nprims);
- expandTemplate(template, topLevel, rcat, nrefs, nints, nlongs);
- }
- }
- }
- static void expandTemplate(String[] template, boolean topLevel,
- int rcat, int nrefs, int nints, int nlongs) {
- int nargs = nrefs + nints + nlongs;
- if (nrefs > MAX_REFS || nints > MAX_INTS || nlongs > MAX_LONGS) return;
- VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
- if (topLevel && !done.add(VAR.cat.binding)) {
- System.out.println(" //repeat "+VAR.cat.binding);
- return;
- }
- for (int i = 0; i < template.length; i++) {
- String line = template[i];
- if (line.endsWith("@each-cat@")) {
- // ignore
- } else if (line.endsWith("@each-R@")) {
- int blockEnd = indexAfter(template, i, "@end-R@");
- String[] block = stringsIn(template, i+1, blockEnd-1);
- for (int rcat1 = rcat; rcat1 <= MAX_RCAT; rcat1++)
- expandTemplate(block, false, rcat1, nrefs, nints, nlongs);
- VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
- i = blockEnd-1; continue;
- } else if (line.endsWith("@each-Tv@")) {
- int blockEnd = indexAfter(template, i, "@end-Tv@");
- String[] block = stringsIn(template, i+1, blockEnd-1);
- expandTemplate(block, false, rcat, nrefs, nints, nlongs);
- expandTemplateForPrims(block, false, rcat, nargs, nints+1, nlongs+1);
- VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
- i = blockEnd-1; continue;
- } else {
- System.out.println(VAR.transform(line));
- }
- }
- }
-}
-//}}} */
-//params=[0, 10, 4, 99, 0, 0]
- static class A0 extends Adapter {
- protected A0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A0(e, i, c, t); }
- protected Object invoke_L0() throws Throwable { return convert_L((Object)invoker.invokeExact(target)); }
- protected Object invoke_I0() throws Throwable { return convert_I((int) invoker.invokeExact(target)); }
- protected Object invoke_J0() throws Throwable { return convert_J((long) invoker.invokeExact(target)); }
- protected Object invoke_F0() throws Throwable { return convert_F((float) invoker.invokeExact(target)); }
- protected Object invoke_D0() throws Throwable { return convert_D((double)invoker.invokeExact(target)); }
- }
- static class A1 extends Adapter {
- protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A1(e, i, c, t); }
- protected Object invoke_L1(Object a0) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0)); }
- protected Object invoke_I1(Object a0) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0)); }
- protected Object invoke_J1(Object a0) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0)); }
- protected Object invoke_F1(Object a0) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0)); }
- protected Object invoke_D1(Object a0) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0)); }
- }
- static class A2 extends Adapter {
- protected A2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A2(e, i, c, t); }
- protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
- protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
- }
- static class A3 extends Adapter {
- protected A3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A3(e, i, c, t); }
- protected Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2)); }
- protected Object invoke_I3(Object a0, Object a1, Object a2) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2)); }
- protected Object invoke_J3(Object a0, Object a1, Object a2) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2)); }
- protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2)); }
- protected Object invoke_D3(Object a0, Object a1, Object a2) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2)); }
- }
- static class A4 extends Adapter {
- protected A4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A4(e, i, c, t); }
- protected Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3)); }
- protected Object invoke_I4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3)); }
- protected Object invoke_J4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3)); }
- protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3)); }
- protected Object invoke_D4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3)); }
- }
- static class A5 extends Adapter {
- protected A5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A5(e, i, c, t); }
- protected Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
- protected Object invoke_I5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
- protected Object invoke_J5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
- protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
- protected Object invoke_D5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
- }
- static class A6 extends Adapter {
- protected A6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A6(e, i, c, t); }
- protected Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_I6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_J6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_D6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
- }
- static class A7 extends Adapter {
- protected A7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A7(e, i, c, t); }
- protected Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_I7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_J7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_D7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
- }
- static class A8 extends Adapter {
- protected A8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A8(e, i, c, t); }
- protected Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_I8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_J8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_D8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
- }
- static class A9 extends Adapter {
- protected A9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A9(e, i, c, t); }
- protected Object invoke_L9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_I9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_J9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_D9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- }
- static class A10 extends Adapter {
- protected A10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { super(e, i, c, t); }
- protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
- { return new A10(e, i, c, t); }
- protected Object invoke_L10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_I10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_I((int) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_J10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_J((long) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_D10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- }
-}
--- a/jdk/src/share/classes/sun/dyn/InvokeGeneric.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,161 +0,0 @@
-/*
- * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import java.lang.reflect.*;
-import sun.dyn.util.*;
-import static sun.dyn.MethodTypeImpl.invokers;
-
-/**
- * Adapters which manage MethodHanndle.invokeGeneric calls.
- * The JVM calls one of these when the exact type match fails.
- * @author jrose
- */
-class InvokeGeneric {
- // erased type for the call, which originates from an invokeGeneric site
- private final MethodType erasedCallerType;
- // an invoker of type (MT, MH; A...) -> R
- private final MethodHandle initialInvoker;
-
- /** Compute and cache information for this adapter, so that it can
- * call out to targets of the erasure-family of the given erased type.
- */
- private InvokeGeneric(MethodType erasedCallerType) throws ReflectiveOperationException {
- this.erasedCallerType = erasedCallerType;
- this.initialInvoker = makeInitialInvoker();
- assert initialInvoker.type().equals(erasedCallerType
- .insertParameterTypes(0, MethodType.class, MethodHandle.class))
- : initialInvoker.type();
- }
-
- private static MethodHandles.Lookup lookup() {
- return MethodHandleImpl.IMPL_LOOKUP;
- }
-
- /** Return the adapter information for this type's erasure. */
- static MethodHandle genericInvokerOf(MethodType type) {
- MethodTypeImpl form = MethodTypeImpl.of(type);
- MethodHandle genericInvoker = form.genericInvoker;
- if (genericInvoker == null) {
- try {
- InvokeGeneric gen = new InvokeGeneric(form.erasedType());
- form.genericInvoker = genericInvoker = gen.initialInvoker;
- } catch (ReflectiveOperationException ex) {
- throw new RuntimeException(ex);
- }
- }
- return genericInvoker;
- }
-
- private MethodHandle makeInitialInvoker() throws ReflectiveOperationException {
- // postDispatch = #(MH'; MT, MH; A...){MH'(MT, MH; A)}
- MethodHandle postDispatch = makePostDispatchInvoker();
- MethodHandle invoker;
- if (returnConversionPossible()) {
- invoker = MethodHandles.foldArguments(postDispatch,
- dispatcher("dispatchWithConversion"));
- } else {
- invoker = MethodHandles.foldArguments(postDispatch, dispatcher("dispatch"));
- }
- return invoker;
- }
-
- private static final Class<?>[] EXTRA_ARGS = { MethodType.class, MethodHandle.class };
- private MethodHandle makePostDispatchInvoker() {
- // Take (MH'; MT, MH; A...) and run MH'(MT, MH; A...).
- MethodType invokerType = erasedCallerType.insertParameterTypes(0, EXTRA_ARGS);
- return invokers(invokerType).exactInvoker();
- }
- private MethodHandle dropDispatchArguments(MethodHandle targetInvoker) {
- assert(targetInvoker.type().parameterType(0) == MethodHandle.class);
- return MethodHandles.dropArguments(targetInvoker, 1, EXTRA_ARGS);
- }
-
- private MethodHandle dispatcher(String dispatchName) throws ReflectiveOperationException {
- return lookup().bind(this, dispatchName,
- MethodType.methodType(MethodHandle.class,
- MethodType.class, MethodHandle.class));
- }
-
- static final boolean USE_AS_TYPE_PATH = true;
-
- /** Return a method handle to invoke on the callerType, target, and remaining arguments.
- * The method handle must finish the call.
- * This is the first look at the caller type and target.
- */
- private MethodHandle dispatch(MethodType callerType, MethodHandle target) {
- MethodType targetType = target.type();
- if (USE_AS_TYPE_PATH || target.isVarargsCollector()) {
- MethodHandle newTarget = target.asType(callerType);
- targetType = callerType;
- Invokers invokers = MethodTypeImpl.invokers(Access.TOKEN, targetType);
- MethodHandle invoker = invokers.erasedInvokerWithDrops;
- if (invoker == null) {
- invokers.erasedInvokerWithDrops = invoker =
- dropDispatchArguments(invokers.erasedInvoker());
- }
- return invoker.bindTo(newTarget);
- }
- throw new RuntimeException("NYI");
- }
-
- private MethodHandle dispatchWithConversion(MethodType callerType, MethodHandle target) {
- MethodHandle finisher = dispatch(callerType, target);
- if (returnConversionNeeded(callerType, target))
- finisher = addReturnConversion(finisher, callerType.returnType()); //FIXME: slow
- return finisher;
- }
-
- private boolean returnConversionPossible() {
- Class<?> needType = erasedCallerType.returnType();
- return !needType.isPrimitive();
- }
- private boolean returnConversionNeeded(MethodType callerType, MethodHandle target) {
- Class<?> needType = callerType.returnType();
- if (needType == erasedCallerType.returnType())
- return false; // no conversions possible, since must be primitive or Object
- Class<?> haveType = target.type().returnType();
- if (VerifyType.isNullConversion(haveType, needType))
- return false;
- return true;
- }
- private MethodHandle addReturnConversion(MethodHandle target, Class<?> type) {
- if (true) throw new RuntimeException("NYI");
- // FIXME: This is slow because it creates a closure node on every call that requires a return cast.
- MethodType targetType = target.type();
- MethodHandle caster = ValueConversions.identity(type);
- caster = caster.asType(MethodType.methodType(type, targetType.returnType()));
- // Drop irrelevant arguments, because we only care about the return value:
- caster = MethodHandles.dropArguments(caster, 1, targetType.parameterList());
- MethodHandle result = MethodHandles.foldArguments(caster, target);
- return result.asType(target.type());
- }
-
- public String toString() {
- return "InvokeGeneric"+erasedCallerType;
- }
-}
--- a/jdk/src/share/classes/sun/dyn/Invokers.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import sun.dyn.empty.Empty;
-
-/**
- * Construction and caching of often-used invokers.
- * @author jrose
- */
-public class Invokers {
- // exact type (sans leading taget MH) for the outgoing call
- private final MethodType targetType;
-
- // exact invoker for the outgoing call
- private /*lazy*/ MethodHandle exactInvoker;
-
- // erased (partially untyped but with primitives) invoker for the outgoing call
- private /*lazy*/ MethodHandle erasedInvoker;
- /*lazy*/ MethodHandle erasedInvokerWithDrops; // for InvokeGeneric
-
- // generic (untyped) invoker for the outgoing call
- private /*lazy*/ MethodHandle genericInvoker;
-
- // generic (untyped) invoker for the outgoing call; accepts a single Object[]
- private final /*lazy*/ MethodHandle[] spreadInvokers;
-
- // invoker for an unbound callsite
- private /*lazy*/ MethodHandle uninitializedCallSite;
-
- /** Compute and cache information common to all collecting adapters
- * that implement members of the erasure-family of the given erased type.
- */
- /*non-public*/ Invokers(MethodType targetType) {
- this.targetType = targetType;
- this.spreadInvokers = new MethodHandle[targetType.parameterCount()+1];
- }
-
- public static MethodType invokerType(MethodType targetType) {
- return targetType.insertParameterTypes(0, MethodHandle.class);
- }
-
- public MethodHandle exactInvoker() {
- MethodHandle invoker = exactInvoker;
- if (invoker != null) return invoker;
- try {
- invoker = MethodHandleImpl.IMPL_LOOKUP.findVirtual(MethodHandle.class, "invokeExact", targetType);
- } catch (ReflectiveOperationException ex) {
- throw new InternalError("JVM cannot find invoker for "+targetType);
- }
- assert(invokerType(targetType) == invoker.type());
- exactInvoker = invoker;
- return invoker;
- }
-
- public MethodHandle genericInvoker() {
- MethodHandle invoker1 = exactInvoker();
- MethodHandle invoker = genericInvoker;
- if (invoker != null) return invoker;
- MethodType genericType = targetType.generic();
- invoker = MethodHandles.convertArguments(invoker1, invokerType(genericType));
- genericInvoker = invoker;
- return invoker;
- }
-
- public MethodHandle erasedInvoker() {
- MethodHandle invoker1 = exactInvoker();
- MethodHandle invoker = erasedInvoker;
- if (invoker != null) return invoker;
- MethodType erasedType = targetType.erase();
- if (erasedType == targetType.generic())
- invoker = genericInvoker();
- else
- invoker = MethodHandles.convertArguments(invoker1, invokerType(erasedType));
- erasedInvoker = invoker;
- return invoker;
- }
-
- public MethodHandle spreadInvoker(int objectArgCount) {
- MethodHandle vaInvoker = spreadInvokers[objectArgCount];
- if (vaInvoker != null) return vaInvoker;
- MethodHandle gInvoker = genericInvoker();
- vaInvoker = gInvoker.asSpreader(Object[].class, targetType.parameterCount() - objectArgCount);
- spreadInvokers[objectArgCount] = vaInvoker;
- return vaInvoker;
- }
-
- private static MethodHandle THROW_UCS = null;
-
- public MethodHandle uninitializedCallSite() {
- MethodHandle invoker = uninitializedCallSite;
- if (invoker != null) return invoker;
- if (targetType.parameterCount() > 0) {
- MethodType type0 = targetType.dropParameterTypes(0, targetType.parameterCount());
- Invokers invokers0 = MethodTypeImpl.invokers(type0);
- invoker = MethodHandles.dropArguments(invokers0.uninitializedCallSite(),
- 0, targetType.parameterList());
- assert(invoker.type().equals(targetType));
- uninitializedCallSite = invoker;
- return invoker;
- }
- if (THROW_UCS == null) {
- try {
- THROW_UCS = MethodHandleImpl.IMPL_LOOKUP
- .findStatic(CallSite.class, "uninitializedCallSite",
- MethodType.methodType(Empty.class));
- } catch (ReflectiveOperationException ex) {
- throw new RuntimeException(ex);
- }
- }
- invoker = AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, targetType, THROW_UCS);
- assert(invoker.type().equals(targetType));
- uninitializedCallSite = invoker;
- return invoker;
- }
-
- public String toString() {
- return "Invokers"+targetType;
- }
-}
--- a/jdk/src/share/classes/sun/dyn/MemberName.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,739 +0,0 @@
-/*
- * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import sun.dyn.util.BytecodeDescriptor;
-import java.dyn.*;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.lang.reflect.Member;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import static sun.dyn.MethodHandleNatives.Constants.*;
-
-/**
- * A {@code MemberName} is a compact symbolic datum which fully characterizes
- * a method or field reference.
- * A member name refers to a field, method, constructor, or member type.
- * Every member name has a simple name (a string) and a type (either a Class or MethodType).
- * A member name may also have a non-null declaring class, or it may be simply
- * a naked name/type pair.
- * A member name may also have non-zero modifier flags.
- * Finally, a member name may be either resolved or unresolved.
- * If it is resolved, the existence of the named
- * <p>
- * Whether resolved or not, a member name provides no access rights or
- * invocation capability to its possessor. It is merely a compact
- * representation of all symbolic information necessary to link to
- * and properly use the named member.
- * <p>
- * When resolved, a member name's internal implementation may include references to JVM metadata.
- * This representation is stateless and only decriptive.
- * It provides no private information and no capability to use the member.
- * <p>
- * By contrast, a {@linkplain java.lang.reflect.Method} contains fuller information
- * about the internals of a method (except its bytecodes) and also
- * allows invocation. A MemberName is much lighter than a Method,
- * since it contains about 7 fields to the 16 of Method (plus its sub-arrays),
- * and those seven fields omit much of the information in Method.
- * @author jrose
- */
-public final class MemberName implements Member, Cloneable {
- private Class<?> clazz; // class in which the method is defined
- private String name; // may be null if not yet materialized
- private Object type; // may be null if not yet materialized
- private int flags; // modifier bits; see reflect.Modifier
-
- private Object vmtarget; // VM-specific target value
- private int vmindex; // method index within class or interface
-
- { vmindex = VM_INDEX_UNINITIALIZED; }
-
- /** Return the declaring class of this member.
- * In the case of a bare name and type, the declaring class will be null.
- */
- public Class<?> getDeclaringClass() {
- if (clazz == null && isResolved()) {
- expandFromVM();
- }
- return clazz;
- }
-
- /** Utility method producing the class loader of the declaring class. */
- public ClassLoader getClassLoader() {
- return clazz.getClassLoader();
- }
-
- /** Return the simple name of this member.
- * For a type, it is the same as {@link Class#getSimpleName}.
- * For a method or field, it is the simple name of the member.
- * For a constructor, it is always {@code "<init>"}.
- */
- public String getName() {
- if (name == null) {
- expandFromVM();
- if (name == null) return null;
- }
- return name;
- }
-
- /** Return the declared type of this member, which
- * must be a method or constructor.
- */
- public MethodType getMethodType() {
- if (type == null) {
- expandFromVM();
- if (type == null) return null;
- }
- if (!isInvocable())
- throw newIllegalArgumentException("not invocable, no method type");
- if (type instanceof MethodType) {
- return (MethodType) type;
- }
- if (type instanceof String) {
- String sig = (String) type;
- MethodType res = MethodType.fromMethodDescriptorString(sig, getClassLoader());
- this.type = res;
- return res;
- }
- if (type instanceof Object[]) {
- Object[] typeInfo = (Object[]) type;
- Class<?>[] ptypes = (Class<?>[]) typeInfo[1];
- Class<?> rtype = (Class<?>) typeInfo[0];
- MethodType res = MethodType.methodType(rtype, ptypes);
- this.type = res;
- return res;
- }
- throw new InternalError("bad method type "+type);
- }
-
- /** Return the actual type under which this method or constructor must be invoked.
- * For non-static methods or constructors, this is the type with a leading parameter,
- * a reference to declaring class. For static methods, it is the same as the declared type.
- */
- public MethodType getInvocationType() {
- MethodType itype = getMethodType();
- if (!isStatic())
- itype = itype.insertParameterTypes(0, clazz);
- return itype;
- }
-
- /** Utility method producing the parameter types of the method type. */
- public Class<?>[] getParameterTypes() {
- return getMethodType().parameterArray();
- }
-
- /** Utility method producing the return type of the method type. */
- public Class<?> getReturnType() {
- return getMethodType().returnType();
- }
-
- /** Return the declared type of this member, which
- * must be a field or type.
- * If it is a type member, that type itself is returned.
- */
- public Class<?> getFieldType() {
- if (type == null) {
- expandFromVM();
- if (type == null) return null;
- }
- if (isInvocable())
- throw newIllegalArgumentException("not a field or nested class, no simple type");
- if (type instanceof Class<?>) {
- return (Class<?>) type;
- }
- if (type instanceof String) {
- String sig = (String) type;
- MethodType mtype = MethodType.fromMethodDescriptorString("()"+sig, getClassLoader());
- Class<?> res = mtype.returnType();
- this.type = res;
- return res;
- }
- throw new InternalError("bad field type "+type);
- }
-
- /** Utility method to produce either the method type or field type of this member. */
- public Object getType() {
- return (isInvocable() ? getMethodType() : getFieldType());
- }
-
- /** Utility method to produce the signature of this member,
- * used within the class file format to describe its type.
- */
- public String getSignature() {
- if (type == null) {
- expandFromVM();
- if (type == null) return null;
- }
- if (type instanceof String)
- return (String) type;
- if (isInvocable())
- return BytecodeDescriptor.unparse(getMethodType());
- else
- return BytecodeDescriptor.unparse(getFieldType());
- }
-
- /** Return the modifier flags of this member.
- * @see java.lang.reflect.Modifier
- */
- public int getModifiers() {
- return (flags & RECOGNIZED_MODIFIERS);
- }
-
- private void setFlags(int flags) {
- this.flags = flags;
- assert(testAnyFlags(ALL_KINDS));
- }
-
- private boolean testFlags(int mask, int value) {
- return (flags & mask) == value;
- }
- private boolean testAllFlags(int mask) {
- return testFlags(mask, mask);
- }
- private boolean testAnyFlags(int mask) {
- return !testFlags(mask, 0);
- }
-
- /** Utility method to query the modifier flags of this member. */
- public boolean isStatic() {
- return Modifier.isStatic(flags);
- }
- /** Utility method to query the modifier flags of this member. */
- public boolean isPublic() {
- return Modifier.isPublic(flags);
- }
- /** Utility method to query the modifier flags of this member. */
- public boolean isPrivate() {
- return Modifier.isPrivate(flags);
- }
- /** Utility method to query the modifier flags of this member. */
- public boolean isProtected() {
- return Modifier.isProtected(flags);
- }
- /** Utility method to query the modifier flags of this member. */
- public boolean isFinal() {
- return Modifier.isFinal(flags);
- }
- /** Utility method to query the modifier flags of this member. */
- public boolean isAbstract() {
- return Modifier.isAbstract(flags);
- }
- // let the rest (native, volatile, transient, etc.) be tested via Modifier.isFoo
-
- // unofficial modifier flags, used by HotSpot:
- static final int BRIDGE = 0x00000040;
- static final int VARARGS = 0x00000080;
- static final int SYNTHETIC = 0x00001000;
- static final int ANNOTATION= 0x00002000;
- static final int ENUM = 0x00004000;
- /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
- public boolean isBridge() {
- return testAllFlags(IS_METHOD | BRIDGE);
- }
- /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
- public boolean isVarargs() {
- return testAllFlags(VARARGS) && isInvocable();
- }
- /** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
- public boolean isSynthetic() {
- return testAllFlags(SYNTHETIC);
- }
-
- static final String CONSTRUCTOR_NAME = "<init>"; // the ever-popular
-
- // modifiers exported by the JVM:
- static final int RECOGNIZED_MODIFIERS = 0xFFFF;
-
- // private flags, not part of RECOGNIZED_MODIFIERS:
- static final int
- IS_METHOD = MN_IS_METHOD, // method (not constructor)
- IS_CONSTRUCTOR = MN_IS_CONSTRUCTOR, // constructor
- IS_FIELD = MN_IS_FIELD, // field
- IS_TYPE = MN_IS_TYPE; // nested type
- static final int // for MethodHandleNatives.getMembers
- SEARCH_SUPERCLASSES = MN_SEARCH_SUPERCLASSES,
- SEARCH_INTERFACES = MN_SEARCH_INTERFACES;
-
- static final int ALL_ACCESS = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED;
- static final int ALL_KINDS = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE;
- static final int IS_INVOCABLE = IS_METHOD | IS_CONSTRUCTOR;
- static final int IS_FIELD_OR_METHOD = IS_METHOD | IS_FIELD;
- static final int SEARCH_ALL_SUPERS = SEARCH_SUPERCLASSES | SEARCH_INTERFACES;
-
- /** Utility method to query whether this member is a method or constructor. */
- public boolean isInvocable() {
- return testAnyFlags(IS_INVOCABLE);
- }
- /** Utility method to query whether this member is a method, constructor, or field. */
- public boolean isFieldOrMethod() {
- return testAnyFlags(IS_FIELD_OR_METHOD);
- }
- /** Query whether this member is a method. */
- public boolean isMethod() {
- return testAllFlags(IS_METHOD);
- }
- /** Query whether this member is a constructor. */
- public boolean isConstructor() {
- return testAllFlags(IS_CONSTRUCTOR);
- }
- /** Query whether this member is a field. */
- public boolean isField() {
- return testAllFlags(IS_FIELD);
- }
- /** Query whether this member is a type. */
- public boolean isType() {
- return testAllFlags(IS_TYPE);
- }
- /** Utility method to query whether this member is neither public, private, nor protected. */
- public boolean isPackage() {
- return !testAnyFlags(ALL_ACCESS);
- }
-
- /** Initialize a query. It is not resolved. */
- private void init(Class<?> defClass, String name, Object type, int flags) {
- // defining class is allowed to be null (for a naked name/type pair)
- //name.toString(); // null check
- //type.equals(type); // null check
- // fill in fields:
- this.clazz = defClass;
- this.name = name;
- this.type = type;
- setFlags(flags);
- assert(!isResolved());
- }
-
- private void expandFromVM() {
- if (!isResolved()) return;
- if (type instanceof Object[])
- type = null; // don't saddle JVM w/ typeInfo
- MethodHandleNatives.expand(this);
- }
-
- // Capturing information from the Core Reflection API:
- private static int flagsMods(int flags, int mods) {
- assert((flags & RECOGNIZED_MODIFIERS) == 0);
- assert((mods & ~RECOGNIZED_MODIFIERS) == 0);
- return flags | mods;
- }
- /** Create a name for the given reflected method. The resulting name will be in a resolved state. */
- public MemberName(Method m) {
- Object[] typeInfo = { m.getReturnType(), m.getParameterTypes() };
- init(m.getDeclaringClass(), m.getName(), typeInfo, flagsMods(IS_METHOD, m.getModifiers()));
- // fill in vmtarget, vmindex while we have m in hand:
- MethodHandleNatives.init(this, m);
- assert(isResolved());
- }
- /** Create a name for the given reflected constructor. The resulting name will be in a resolved state. */
- public MemberName(Constructor ctor) {
- Object[] typeInfo = { void.class, ctor.getParameterTypes() };
- init(ctor.getDeclaringClass(), CONSTRUCTOR_NAME, typeInfo, flagsMods(IS_CONSTRUCTOR, ctor.getModifiers()));
- // fill in vmtarget, vmindex while we have ctor in hand:
- MethodHandleNatives.init(this, ctor);
- assert(isResolved());
- }
- /** Create a name for the given reflected field. The resulting name will be in a resolved state. */
- public MemberName(Field fld) {
- init(fld.getDeclaringClass(), fld.getName(), fld.getType(), flagsMods(IS_FIELD, fld.getModifiers()));
- // fill in vmtarget, vmindex while we have fld in hand:
- MethodHandleNatives.init(this, fld);
- assert(isResolved());
- }
- /** Create a name for the given class. The resulting name will be in a resolved state. */
- public MemberName(Class<?> type) {
- init(type.getDeclaringClass(), type.getSimpleName(), type, flagsMods(IS_TYPE, type.getModifiers()));
- vmindex = 0; // isResolved
- assert(isResolved());
- }
-
- // bare-bones constructor; the JVM will fill it in
- MemberName() { }
-
- // locally useful cloner
- @Override protected MemberName clone() {
- try {
- return (MemberName) super.clone();
- } catch (CloneNotSupportedException ex) {
- throw new InternalError();
- }
- }
-
- // %%% define equals/hashcode?
-
- // Construction from symbolic parts, for queries:
- /** Create a field or type name from the given components: Declaring class, name, type, modifiers.
- * The declaring class may be supplied as null if this is to be a bare name and type.
- * The resulting name will in an unresolved state.
- */
- public MemberName(Class<?> defClass, String name, Class<?> type, int modifiers) {
- init(defClass, name, type, IS_FIELD | (modifiers & RECOGNIZED_MODIFIERS));
- }
- /** Create a field or type name from the given components: Declaring class, name, type.
- * The declaring class may be supplied as null if this is to be a bare name and type.
- * The modifier flags default to zero.
- * The resulting name will in an unresolved state.
- */
- public MemberName(Class<?> defClass, String name, Class<?> type) {
- this(defClass, name, type, 0);
- }
- /** Create a method or constructor name from the given components: Declaring class, name, type, modifiers.
- * It will be a constructor if and only if the name is {@code "<init>"}.
- * The declaring class may be supplied as null if this is to be a bare name and type.
- * The resulting name will in an unresolved state.
- */
- public MemberName(Class<?> defClass, String name, MethodType type, int modifiers) {
- int flagBit = (name.equals(CONSTRUCTOR_NAME) ? IS_CONSTRUCTOR : IS_METHOD);
- init(defClass, name, type, flagBit | (modifiers & RECOGNIZED_MODIFIERS));
- }
- /** Create a method or constructor name from the given components: Declaring class, name, type, modifiers.
- * It will be a constructor if and only if the name is {@code "<init>"}.
- * The declaring class may be supplied as null if this is to be a bare name and type.
- * The modifier flags default to zero.
- * The resulting name will in an unresolved state.
- */
- public MemberName(Class<?> defClass, String name, MethodType type) {
- this(defClass, name, type, 0);
- }
-
- /** Query whether this member name is resolved.
- * A resolved member name is one for which the JVM has found
- * a method, constructor, field, or type binding corresponding exactly to the name.
- * (Document?)
- */
- public boolean isResolved() {
- return (vmindex != VM_INDEX_UNINITIALIZED);
- }
-
- /** Query whether this member name is resolved to a non-static, non-final method.
- */
- public boolean hasReceiverTypeDispatch() {
- return (isMethod() && getVMIndex(Access.TOKEN) >= 0);
- }
-
- /** Produce a string form of this member name.
- * For types, it is simply the type's own string (as reported by {@code toString}).
- * For fields, it is {@code "DeclaringClass.name/type"}.
- * For methods and constructors, it is {@code "DeclaringClass.name(ptype...)rtype"}.
- * If the declaring class is null, the prefix {@code "DeclaringClass."} is omitted.
- * If the member is unresolved, a prefix {@code "*."} is prepended.
- */
- @Override
- public String toString() {
- if (isType())
- return type.toString(); // class java.lang.String
- // else it is a field, method, or constructor
- StringBuilder buf = new StringBuilder();
- if (getDeclaringClass() != null) {
- buf.append(getName(clazz));
- buf.append('.');
- }
- String name = getName();
- buf.append(name == null ? "*" : name);
- Object type = getType();
- if (!isInvocable()) {
- buf.append('/');
- buf.append(type == null ? "*" : getName(type));
- } else {
- buf.append(type == null ? "(*)*" : getName(type));
- }
- /*
- buf.append('/');
- // key: Public, private, pRotected, sTatic, Final, sYnchronized,
- // transient/Varargs, native, (interface), abstract, sTrict, sYnthetic,
- // (annotation), Enum, (unused)
- final String FIELD_MOD_CHARS = "PprTF?vt????Y?E?";
- final String METHOD_MOD_CHARS = "PprTFybVn?atY???";
- String modChars = (isInvocable() ? METHOD_MOD_CHARS : FIELD_MOD_CHARS);
- for (int i = 0; i < modChars.length(); i++) {
- if ((flags & (1 << i)) != 0) {
- char mc = modChars.charAt(i);
- if (mc != '?')
- buf.append(mc);
- }
- }
- */
- return buf.toString();
- }
- private static String getName(Object obj) {
- if (obj instanceof Class<?>)
- return ((Class<?>)obj).getName();
- return String.valueOf(obj);
- }
-
- // Queries to the JVM:
- /** Document? */
- public int getVMIndex(Access token) {
- Access.check(token);
- if (!isResolved())
- throw newIllegalStateException("not resolved");
- return vmindex;
- }
-// public Object getVMTarget(Access token) {
-// Access.check(token);
-// if (!isResolved())
-// throw newIllegalStateException("not resolved");
-// return vmtarget;
-// }
- private RuntimeException newIllegalStateException(String message) {
- return new IllegalStateException(message+": "+this);
- }
-
- // handy shared exception makers (they simplify the common case code)
- public static RuntimeException newIllegalArgumentException(String message) {
- return new IllegalArgumentException(message);
- }
- public static IllegalAccessException newNoAccessException(MemberName name, Object from) {
- return newNoAccessException("cannot access", name, from);
- }
- public static IllegalAccessException newNoAccessException(String message,
- MemberName name, Object from) {
- message += ": " + name;
- if (from != null) message += ", from " + from;
- return new IllegalAccessException(message);
- }
- public static ReflectiveOperationException newNoAccessException(MemberName name) {
- if (name.isResolved())
- return new IllegalAccessException(name.toString());
- else if (name.isConstructor())
- return new NoSuchMethodException(name.toString());
- else if (name.isMethod())
- return new NoSuchMethodException(name.toString());
- else
- return new NoSuchFieldException(name.toString());
- }
- public static Error uncaughtException(Exception ex) {
- Error err = new InternalError("uncaught exception");
- err.initCause(ex);
- return err;
- }
-
- /** Actually making a query requires an access check. */
- public static Factory getFactory(Access token) {
- Access.check(token);
- return Factory.INSTANCE;
- }
- public static Factory getFactory() {
- return getFactory(Access.getToken());
- }
- /** A factory type for resolving member names with the help of the VM.
- * TBD: Define access-safe public constructors for this factory.
- */
- public static class Factory {
- private Factory() { } // singleton pattern
- static Factory INSTANCE = new Factory();
-
- private static int ALLOWED_FLAGS = SEARCH_ALL_SUPERS | ALL_KINDS;
-
- /// Queries
- List<MemberName> getMembers(Class<?> defc,
- String matchName, Object matchType,
- int matchFlags, Class<?> lookupClass) {
- matchFlags &= ALLOWED_FLAGS;
- String matchSig = null;
- if (matchType != null) {
- matchSig = BytecodeDescriptor.unparse(matchType);
- if (matchSig.startsWith("("))
- matchFlags &= ~(ALL_KINDS & ~IS_INVOCABLE);
- else
- matchFlags &= ~(ALL_KINDS & ~IS_FIELD);
- }
- final int BUF_MAX = 0x2000;
- int len1 = matchName == null ? 10 : matchType == null ? 4 : 1;
- MemberName[] buf = newMemberBuffer(len1);
- int totalCount = 0;
- ArrayList<MemberName[]> bufs = null;
- int bufCount = 0;
- for (;;) {
- bufCount = MethodHandleNatives.getMembers(defc,
- matchName, matchSig, matchFlags,
- lookupClass,
- totalCount, buf);
- if (bufCount <= buf.length) {
- if (bufCount < 0) bufCount = 0;
- totalCount += bufCount;
- break;
- }
- // JVM returned to us with an intentional overflow!
- totalCount += buf.length;
- int excess = bufCount - buf.length;
- if (bufs == null) bufs = new ArrayList<MemberName[]>(1);
- bufs.add(buf);
- int len2 = buf.length;
- len2 = Math.max(len2, excess);
- len2 = Math.max(len2, totalCount / 4);
- buf = newMemberBuffer(Math.min(BUF_MAX, len2));
- }
- ArrayList<MemberName> result = new ArrayList<MemberName>(totalCount);
- if (bufs != null) {
- for (MemberName[] buf0 : bufs) {
- Collections.addAll(result, buf0);
- }
- }
- result.addAll(Arrays.asList(buf).subList(0, bufCount));
- // Signature matching is not the same as type matching, since
- // one signature might correspond to several types.
- // So if matchType is a Class or MethodType, refilter the results.
- if (matchType != null && matchType != matchSig) {
- for (Iterator<MemberName> it = result.iterator(); it.hasNext();) {
- MemberName m = it.next();
- if (!matchType.equals(m.getType()))
- it.remove();
- }
- }
- return result;
- }
- boolean resolveInPlace(MemberName m, boolean searchSupers, Class<?> lookupClass) {
- if (m.name == null || m.type == null) { // find unique non-overloaded name
- Class<?> defc = m.getDeclaringClass();
- List<MemberName> choices = null;
- if (m.isMethod())
- choices = getMethods(defc, searchSupers, m.name, (MethodType) m.type, lookupClass);
- else if (m.isConstructor())
- choices = getConstructors(defc, lookupClass);
- else if (m.isField())
- choices = getFields(defc, searchSupers, m.name, (Class<?>) m.type, lookupClass);
- //System.out.println("resolving "+m+" to "+choices);
- if (choices == null || choices.size() != 1)
- return false;
- if (m.name == null) m.name = choices.get(0).name;
- if (m.type == null) m.type = choices.get(0).type;
- }
- MethodHandleNatives.resolve(m, lookupClass);
- if (m.isResolved()) return true;
- int matchFlags = m.flags | (searchSupers ? SEARCH_ALL_SUPERS : 0);
- String matchSig = m.getSignature();
- MemberName[] buf = { m };
- int n = MethodHandleNatives.getMembers(m.getDeclaringClass(),
- m.getName(), matchSig, matchFlags, lookupClass, 0, buf);
- if (n != 1) return false;
- return m.isResolved();
- }
- /** Produce a resolved version of the given member.
- * Super types are searched (for inherited members) if {@code searchSupers} is true.
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * If lookup fails or access is not permitted, null is returned.
- * Otherwise a fresh copy of the given member is returned, with modifier bits filled in.
- */
- public MemberName resolveOrNull(MemberName m, boolean searchSupers, Class<?> lookupClass) {
- MemberName result = m.clone();
- if (resolveInPlace(result, searchSupers, lookupClass))
- return result;
- return null;
- }
- /** Produce a resolved version of the given member.
- * Super types are searched (for inherited members) if {@code searchSupers} is true.
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * If lookup fails or access is not permitted, a {@linkplain ReflectiveOperationException} is thrown.
- * Otherwise a fresh copy of the given member is returned, with modifier bits filled in.
- */
- public
- <NoSuchMemberException extends ReflectiveOperationException>
- MemberName resolveOrFail(MemberName m, boolean searchSupers, Class<?> lookupClass,
- Class<NoSuchMemberException> nsmClass)
- throws IllegalAccessException, NoSuchMemberException {
- MemberName result = resolveOrNull(m, searchSupers, lookupClass);
- if (result != null)
- return result;
- ReflectiveOperationException ex = newNoAccessException(m);
- if (ex instanceof IllegalAccessException) throw (IllegalAccessException) ex;
- throw nsmClass.cast(ex);
- }
- /** Return a list of all methods defined by the given class.
- * Super types are searched (for inherited members) if {@code searchSupers} is true.
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * Inaccessible members are not added to the last.
- */
- public List<MemberName> getMethods(Class<?> defc, boolean searchSupers,
- Class<?> lookupClass) {
- return getMethods(defc, searchSupers, null, null, lookupClass);
- }
- /** Return a list of matching methods defined by the given class.
- * Super types are searched (for inherited members) if {@code searchSupers} is true.
- * Returned methods will match the name (if not null) and the type (if not null).
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * Inaccessible members are not added to the last.
- */
- public List<MemberName> getMethods(Class<?> defc, boolean searchSupers,
- String name, MethodType type, Class<?> lookupClass) {
- int matchFlags = IS_METHOD | (searchSupers ? SEARCH_ALL_SUPERS : 0);
- return getMembers(defc, name, type, matchFlags, lookupClass);
- }
- /** Return a list of all constructors defined by the given class.
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * Inaccessible members are not added to the last.
- */
- public List<MemberName> getConstructors(Class<?> defc, Class<?> lookupClass) {
- return getMembers(defc, null, null, IS_CONSTRUCTOR, lookupClass);
- }
- /** Return a list of all fields defined by the given class.
- * Super types are searched (for inherited members) if {@code searchSupers} is true.
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * Inaccessible members are not added to the last.
- */
- public List<MemberName> getFields(Class<?> defc, boolean searchSupers,
- Class<?> lookupClass) {
- return getFields(defc, searchSupers, null, null, lookupClass);
- }
- /** Return a list of all fields defined by the given class.
- * Super types are searched (for inherited members) if {@code searchSupers} is true.
- * Returned fields will match the name (if not null) and the type (if not null).
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * Inaccessible members are not added to the last.
- */
- public List<MemberName> getFields(Class<?> defc, boolean searchSupers,
- String name, Class<?> type, Class<?> lookupClass) {
- int matchFlags = IS_FIELD | (searchSupers ? SEARCH_ALL_SUPERS : 0);
- return getMembers(defc, name, type, matchFlags, lookupClass);
- }
- /** Return a list of all nested types defined by the given class.
- * Super types are searched (for inherited members) if {@code searchSupers} is true.
- * Access checking is performed on behalf of the given {@code lookupClass}.
- * Inaccessible members are not added to the last.
- */
- public List<MemberName> getNestedTypes(Class<?> defc, boolean searchSupers,
- Class<?> lookupClass) {
- int matchFlags = IS_TYPE | (searchSupers ? SEARCH_ALL_SUPERS : 0);
- return getMembers(defc, null, null, matchFlags, lookupClass);
- }
- private static MemberName[] newMemberBuffer(int length) {
- MemberName[] buf = new MemberName[length];
- // fill the buffer with dummy structs for the JVM to fill in
- for (int i = 0; i < length; i++)
- buf[i] = new MemberName();
- return buf;
- }
- }
-
-// static {
-// System.out.println("Hello world! My methods are:");
-// System.out.println(Factory.INSTANCE.getMethods(MemberName.class, true, null));
-// }
-}
--- a/jdk/src/share/classes/sun/dyn/MethodHandleImpl.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1284 +0,0 @@
-/*
- * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import java.dyn.MethodHandles.Lookup;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import sun.dyn.util.VerifyType;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import sun.dyn.empty.Empty;
-import sun.dyn.util.ValueConversions;
-import sun.dyn.util.Wrapper;
-import sun.misc.Unsafe;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-import static sun.dyn.MemberName.newNoAccessException;
-import static sun.dyn.MemberName.uncaughtException;
-
-/**
- * Base class for method handles, containing JVM-specific fields and logic.
- * TO DO: It should not be a base class.
- * @author jrose
- */
-public abstract class MethodHandleImpl {
-
- // Fields which really belong in MethodHandle:
- private byte vmentry; // adapter stub or method entry point
- //private int vmslots; // optionally, hoist type.form.vmslots
- protected Object vmtarget; // VM-specific, class-specific target value
- //MethodType type; // defined in MethodHandle
-
- // TO DO: vmtarget should be invisible to Java, since the JVM puts internal
- // managed pointers into it. Making it visible exposes it to debuggers,
- // which can cause errors when they treat the pointer as an Object.
-
- // These two dummy fields are present to force 'I' and 'J' signatures
- // into this class's constant pool, so they can be transferred
- // to vmentry when this class is loaded.
- static final int INT_FIELD = 0;
- static final long LONG_FIELD = 0;
-
- /** Access methods for the internals of MethodHandle, supplied to
- * MethodHandleImpl as a trusted agent.
- */
- static public interface MethodHandleFriend {
- void initType(MethodHandle mh, MethodType type);
- }
- public static void setMethodHandleFriend(Access token, MethodHandleFriend am) {
- Access.check(token);
- if (METHOD_HANDLE_FRIEND != null)
- throw new InternalError(); // just once
- METHOD_HANDLE_FRIEND = am;
- }
- static private MethodHandleFriend METHOD_HANDLE_FRIEND;
-
- // NOT public
- static void initType(MethodHandle mh, MethodType type) {
- METHOD_HANDLE_FRIEND.initType(mh, type);
- }
-
- // type is defined in java.dyn.MethodHandle, which is platform-independent
-
- // vmentry (a void* field) is used *only* by by the JVM.
- // The JVM adjusts its type to int or long depending on system wordsize.
- // Since it is statically typed as neither int nor long, it is impossible
- // to use this field from Java bytecode. (Please don't try to, either.)
-
- // The vmentry is an assembly-language stub which is jumped to
- // immediately after the method type is verified.
- // For a direct MH, this stub loads the vmtarget's entry point
- // and jumps to it.
-
- /**
- * VM-based method handles must have a security token.
- * This security token can only be obtained by trusted code.
- * Do not create method handles directly; use factory methods.
- */
- public MethodHandleImpl(Access token) {
- Access.check(token);
- }
-
- /** Initialize the method type form to participate in JVM calls.
- * This is done once for each erased type.
- */
- public static void init(Access token, MethodType self) {
- Access.check(token);
- if (MethodHandleNatives.JVM_SUPPORT)
- MethodHandleNatives.init(self);
- }
-
- /// Factory methods to create method handles:
-
- private static final MemberName.Factory LOOKUP = MemberName.Factory.INSTANCE;
-
- static private Lookup IMPL_LOOKUP_INIT;
-
- public static void initLookup(Access token, Lookup lookup) {
- Access.check(token);
- if (IMPL_LOOKUP_INIT != null)
- throw new InternalError();
- IMPL_LOOKUP_INIT = lookup;
- }
-
- public static Lookup getLookup(Access token) {
- Access.check(token);
- return IMPL_LOOKUP;
- }
-
- static {
- if (!MethodHandleNatives.JVM_SUPPORT) // force init of native API
- throw new InternalError("No JVM support for JSR 292");
- // Force initialization of Lookup, so it calls us back as initLookup:
- MethodHandles.publicLookup();
- if (IMPL_LOOKUP_INIT == null)
- throw new InternalError();
- }
-
- public static void initStatics() {
- // Trigger preceding sequence.
- }
-
- /** Shared secret with MethodHandles.Lookup, a copy of Lookup.IMPL_LOOKUP. */
- static final Lookup IMPL_LOOKUP = IMPL_LOOKUP_INIT;
-
-
- /** Look up a given method.
- * Callable only from java.dyn and related packages.
- * <p>
- * The resulting method handle type will be of the given type,
- * with a receiver type {@code rcvc} prepended if the member is not static.
- * <p>
- * Access checks are made as of the given lookup class.
- * In particular, if the method is protected and {@code defc} is in a
- * different package from the lookup class, then {@code rcvc} must be
- * the lookup class or a subclass.
- * @param token Proof that the lookup class has access to this package.
- * @param member Resolved method or constructor to call.
- * @param name Name of the desired method.
- * @param rcvc Receiver type of desired non-static method (else null)
- * @param doDispatch whether the method handle will test the receiver type
- * @param lookupClass access-check relative to this class
- * @return a direct handle to the matching method
- * @throws IllegalAccessException if the given method cannot be accessed by the lookup class
- */
- public static
- MethodHandle findMethod(Access token, MemberName method,
- boolean doDispatch, Class<?> lookupClass) throws IllegalAccessException {
- Access.check(token); // only trusted calls
- MethodType mtype = method.getMethodType();
- if (!method.isStatic()) {
- // adjust the advertised receiver type to be exactly the one requested
- // (in the case of invokespecial, this will be the calling class)
- Class<?> recvType = method.getDeclaringClass();
- mtype = mtype.insertParameterTypes(0, recvType);
- }
- DirectMethodHandle mh = new DirectMethodHandle(mtype, method, doDispatch, lookupClass);
- if (!mh.isValid())
- throw newNoAccessException(method, lookupClass);
- assert(mh.type() == mtype);
- if (!method.isVarargs())
- return mh;
- else
- return mh.asVarargsCollector(mtype.parameterType(mtype.parameterCount()-1));
- }
-
- public static
- MethodHandle makeAllocator(Access token, MethodHandle rawConstructor) {
- Access.check(token);
- MethodType rawConType = rawConstructor.type();
- // Wrap the raw (unsafe) constructor with the allocation of a suitable object.
- MethodHandle allocator
- = AllocateObject.make(token, rawConType.parameterType(0), rawConstructor);
- assert(allocator.type()
- .equals(rawConType.dropParameterTypes(0, 1).changeReturnType(rawConType.parameterType(0))));
- return allocator;
- }
-
- static final class AllocateObject<C> extends BoundMethodHandle {
- private static final Unsafe unsafe = Unsafe.getUnsafe();
-
- private final Class<C> allocateClass;
- private final MethodHandle rawConstructor;
-
- private AllocateObject(MethodHandle invoker,
- Class<C> allocateClass, MethodHandle rawConstructor) {
- super(Access.TOKEN, invoker);
- this.allocateClass = allocateClass;
- this.rawConstructor = rawConstructor;
- }
- static MethodHandle make(Access token,
- Class<?> allocateClass, MethodHandle rawConstructor) {
- Access.check(token);
- MethodType rawConType = rawConstructor.type();
- assert(rawConType.parameterType(0) == allocateClass);
- MethodType newType = rawConType.dropParameterTypes(0, 1).changeReturnType(allocateClass);
- int nargs = rawConType.parameterCount() - 1;
- if (nargs < INVOKES.length) {
- MethodHandle invoke = INVOKES[nargs];
- MethodType conType = CON_TYPES[nargs];
- MethodHandle gcon = convertArguments(token, rawConstructor, conType, rawConType, null);
- if (gcon == null) return null;
- MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);
- assert(galloc.type() == newType.generic());
- return convertArguments(token, galloc, newType, galloc.type(), null);
- } else {
- MethodHandle invoke = VARARGS_INVOKE;
- MethodType conType = CON_TYPES[nargs];
- MethodHandle gcon = spreadArguments(token, rawConstructor, conType, 1);
- if (gcon == null) return null;
- MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);
- return collectArguments(token, galloc, newType, 1, null);
- }
- }
- @Override
- public String toString() {
- return addTypeString(allocateClass.getSimpleName(), this);
- }
- @SuppressWarnings("unchecked")
- private C allocate() throws InstantiationException {
- return (C) unsafe.allocateInstance(allocateClass);
- }
- private C invoke_V(Object... av) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, av);
- return obj;
- }
- private C invoke_L0() throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj);
- return obj;
- }
- private C invoke_L1(Object a0) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0);
- return obj;
- }
- private C invoke_L2(Object a0, Object a1) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0, a1);
- return obj;
- }
- private C invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0, a1, a2);
- return obj;
- }
- private C invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3);
- return obj;
- }
- private C invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4);
- return obj;
- }
- private C invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5);
- return obj;
- }
- private C invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6);
- return obj;
- }
- private C invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
- C obj = allocate();
- rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6, a7);
- return obj;
- }
- static MethodHandle[] makeInvokes() {
- ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
- MethodHandles.Lookup lookup = IMPL_LOOKUP;
- for (;;) {
- int nargs = invokes.size();
- String name = "invoke_L"+nargs;
- MethodHandle invoke = null;
- try {
- invoke = lookup.findVirtual(AllocateObject.class, name, MethodType.genericMethodType(nargs));
- } catch (ReflectiveOperationException ex) {
- }
- if (invoke == null) break;
- invokes.add(invoke);
- }
- assert(invokes.size() == 9); // current number of methods
- return invokes.toArray(new MethodHandle[0]);
- };
- static final MethodHandle[] INVOKES = makeInvokes();
- // For testing use this:
- //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
- static final MethodHandle VARARGS_INVOKE;
- static {
- try {
- VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(AllocateObject.class, "invoke_V", MethodType.genericMethodType(0, true));
- } catch (ReflectiveOperationException ex) {
- throw uncaughtException(ex);
- }
- }
- // Corresponding generic constructor types:
- static final MethodType[] CON_TYPES = new MethodType[INVOKES.length];
- static {
- for (int i = 0; i < INVOKES.length; i++)
- CON_TYPES[i] = makeConType(INVOKES[i]);
- }
- static final MethodType VARARGS_CON_TYPE = makeConType(VARARGS_INVOKE);
- static MethodType makeConType(MethodHandle invoke) {
- MethodType invType = invoke.type();
- return invType.changeParameterType(0, Object.class).changeReturnType(void.class);
- }
- }
-
- public static
- MethodHandle accessField(Access token,
- MemberName member, boolean isSetter,
- Class<?> lookupClass) {
- Access.check(token);
- // Use sun. misc.Unsafe to dig up the dirt on the field.
- MethodHandle mh = new FieldAccessor(token, member, isSetter);
- return mh;
- }
-
- public static
- MethodHandle accessArrayElement(Access token,
- Class<?> arrayClass, boolean isSetter) {
- Access.check(token);
- if (!arrayClass.isArray())
- throw newIllegalArgumentException("not an array: "+arrayClass);
- Class<?> elemClass = arrayClass.getComponentType();
- MethodHandle[] mhs = FieldAccessor.ARRAY_CACHE.get(elemClass);
- if (mhs == null) {
- if (!FieldAccessor.doCache(elemClass))
- return FieldAccessor.ahandle(arrayClass, isSetter);
- mhs = new MethodHandle[] {
- FieldAccessor.ahandle(arrayClass, false),
- FieldAccessor.ahandle(arrayClass, true)
- };
- if (mhs[0].type().parameterType(0) == Class.class) {
- mhs[0] = MethodHandles.insertArguments(mhs[0], 0, elemClass);
- mhs[1] = MethodHandles.insertArguments(mhs[1], 0, elemClass);
- }
- synchronized (FieldAccessor.ARRAY_CACHE) {} // memory barrier
- FieldAccessor.ARRAY_CACHE.put(elemClass, mhs);
- }
- return mhs[isSetter ? 1 : 0];
- }
-
- static final class FieldAccessor<C,V> extends BoundMethodHandle {
- private static final Unsafe unsafe = Unsafe.getUnsafe();
- final Object base; // for static refs only
- final long offset;
- final String name;
-
- public FieldAccessor(Access token, MemberName field, boolean isSetter) {
- super(Access.TOKEN, fhandle(field.getDeclaringClass(), field.getFieldType(), isSetter, field.isStatic()));
- this.offset = (long) field.getVMIndex(token);
- this.name = field.getName();
- this.base = staticBase(field);
- }
- public String toString() { return addTypeString(name, this); }
-
- int getFieldI(C obj) { return unsafe.getInt(obj, offset); }
- void setFieldI(C obj, int x) { unsafe.putInt(obj, offset, x); }
- long getFieldJ(C obj) { return unsafe.getLong(obj, offset); }
- void setFieldJ(C obj, long x) { unsafe.putLong(obj, offset, x); }
- float getFieldF(C obj) { return unsafe.getFloat(obj, offset); }
- void setFieldF(C obj, float x) { unsafe.putFloat(obj, offset, x); }
- double getFieldD(C obj) { return unsafe.getDouble(obj, offset); }
- void setFieldD(C obj, double x) { unsafe.putDouble(obj, offset, x); }
- boolean getFieldZ(C obj) { return unsafe.getBoolean(obj, offset); }
- void setFieldZ(C obj, boolean x) { unsafe.putBoolean(obj, offset, x); }
- byte getFieldB(C obj) { return unsafe.getByte(obj, offset); }
- void setFieldB(C obj, byte x) { unsafe.putByte(obj, offset, x); }
- short getFieldS(C obj) { return unsafe.getShort(obj, offset); }
- void setFieldS(C obj, short x) { unsafe.putShort(obj, offset, x); }
- char getFieldC(C obj) { return unsafe.getChar(obj, offset); }
- void setFieldC(C obj, char x) { unsafe.putChar(obj, offset, x); }
- @SuppressWarnings("unchecked")
- V getFieldL(C obj) { return (V) unsafe.getObject(obj, offset); }
- @SuppressWarnings("unchecked")
- void setFieldL(C obj, V x) { unsafe.putObject(obj, offset, x); }
- // cast (V) is OK here, since we wrap convertArguments around the MH.
-
- static Object staticBase(MemberName field) {
- if (!field.isStatic()) return null;
- Class c = field.getDeclaringClass();
- java.lang.reflect.Field f;
- try {
- // FIXME: Should not have to create 'f' to get this value.
- f = c.getDeclaredField(field.getName());
- return unsafe.staticFieldBase(f);
- } catch (Exception ee) {
- throw uncaughtException(ee);
- }
- }
-
- int getStaticI() { return unsafe.getInt(base, offset); }
- void setStaticI(int x) { unsafe.putInt(base, offset, x); }
- long getStaticJ() { return unsafe.getLong(base, offset); }
- void setStaticJ(long x) { unsafe.putLong(base, offset, x); }
- float getStaticF() { return unsafe.getFloat(base, offset); }
- void setStaticF(float x) { unsafe.putFloat(base, offset, x); }
- double getStaticD() { return unsafe.getDouble(base, offset); }
- void setStaticD(double x) { unsafe.putDouble(base, offset, x); }
- boolean getStaticZ() { return unsafe.getBoolean(base, offset); }
- void setStaticZ(boolean x) { unsafe.putBoolean(base, offset, x); }
- byte getStaticB() { return unsafe.getByte(base, offset); }
- void setStaticB(byte x) { unsafe.putByte(base, offset, x); }
- short getStaticS() { return unsafe.getShort(base, offset); }
- void setStaticS(short x) { unsafe.putShort(base, offset, x); }
- char getStaticC() { return unsafe.getChar(base, offset); }
- void setStaticC(char x) { unsafe.putChar(base, offset, x); }
- V getStaticL() { return (V) unsafe.getObject(base, offset); }
- void setStaticL(V x) { unsafe.putObject(base, offset, x); }
-
- static String fname(Class<?> vclass, boolean isSetter, boolean isStatic) {
- String stem;
- if (!isStatic)
- stem = (!isSetter ? "getField" : "setField");
- else
- stem = (!isSetter ? "getStatic" : "setStatic");
- return stem + Wrapper.basicTypeChar(vclass);
- }
- static MethodType ftype(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {
- MethodType type;
- if (!isStatic) {
- if (!isSetter)
- return MethodType.methodType(vclass, cclass);
- else
- return MethodType.methodType(void.class, cclass, vclass);
- } else {
- if (!isSetter)
- return MethodType.methodType(vclass);
- else
- return MethodType.methodType(void.class, vclass);
- }
- }
- static MethodHandle fhandle(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {
- String name = FieldAccessor.fname(vclass, isSetter, isStatic);
- if (cclass.isPrimitive()) throw newIllegalArgumentException("primitive "+cclass);
- Class<?> ecclass = Object.class; //erase this type
- Class<?> evclass = vclass;
- if (!evclass.isPrimitive()) evclass = Object.class;
- MethodType type = FieldAccessor.ftype(ecclass, evclass, isSetter, isStatic);
- MethodHandle mh;
- try {
- mh = IMPL_LOOKUP.findVirtual(FieldAccessor.class, name, type);
- } catch (ReflectiveOperationException ex) {
- throw uncaughtException(ex);
- }
- if (evclass != vclass || (!isStatic && ecclass != cclass)) {
- MethodType strongType = FieldAccessor.ftype(cclass, vclass, isSetter, isStatic);
- strongType = strongType.insertParameterTypes(0, FieldAccessor.class);
- mh = MethodHandles.convertArguments(mh, strongType);
- }
- return mh;
- }
-
- /// Support for array element access
- static final HashMap<Class<?>, MethodHandle[]> ARRAY_CACHE =
- new HashMap<Class<?>, MethodHandle[]>();
- // FIXME: Cache on the classes themselves, not here.
- static boolean doCache(Class<?> elemClass) {
- if (elemClass.isPrimitive()) return true;
- ClassLoader cl = elemClass.getClassLoader();
- return cl == null || cl == ClassLoader.getSystemClassLoader();
- }
- static int getElementI(int[] a, int i) { return a[i]; }
- static void setElementI(int[] a, int i, int x) { a[i] = x; }
- static long getElementJ(long[] a, int i) { return a[i]; }
- static void setElementJ(long[] a, int i, long x) { a[i] = x; }
- static float getElementF(float[] a, int i) { return a[i]; }
- static void setElementF(float[] a, int i, float x) { a[i] = x; }
- static double getElementD(double[] a, int i) { return a[i]; }
- static void setElementD(double[] a, int i, double x) { a[i] = x; }
- static boolean getElementZ(boolean[] a, int i) { return a[i]; }
- static void setElementZ(boolean[] a, int i, boolean x) { a[i] = x; }
- static byte getElementB(byte[] a, int i) { return a[i]; }
- static void setElementB(byte[] a, int i, byte x) { a[i] = x; }
- static short getElementS(short[] a, int i) { return a[i]; }
- static void setElementS(short[] a, int i, short x) { a[i] = x; }
- static char getElementC(char[] a, int i) { return a[i]; }
- static void setElementC(char[] a, int i, char x) { a[i] = x; }
- static Object getElementL(Object[] a, int i) { return a[i]; }
- static void setElementL(Object[] a, int i, Object x) { a[i] = x; }
- static <V> V getElementL(Class<V[]> aclass, V[] a, int i) { return aclass.cast(a)[i]; }
- static <V> void setElementL(Class<V[]> aclass, V[] a, int i, V x) { aclass.cast(a)[i] = x; }
-
- static String aname(Class<?> aclass, boolean isSetter) {
- Class<?> vclass = aclass.getComponentType();
- if (vclass == null) throw new IllegalArgumentException();
- return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(vclass);
- }
- static MethodType atype(Class<?> aclass, boolean isSetter) {
- Class<?> vclass = aclass.getComponentType();
- if (!isSetter)
- return MethodType.methodType(vclass, aclass, int.class);
- else
- return MethodType.methodType(void.class, aclass, int.class, vclass);
- }
- static MethodHandle ahandle(Class<?> aclass, boolean isSetter) {
- Class<?> vclass = aclass.getComponentType();
- String name = FieldAccessor.aname(aclass, isSetter);
- Class<?> caclass = null;
- if (!vclass.isPrimitive() && vclass != Object.class) {
- caclass = aclass;
- aclass = Object[].class;
- vclass = Object.class;
- }
- MethodType type = FieldAccessor.atype(aclass, isSetter);
- if (caclass != null)
- type = type.insertParameterTypes(0, Class.class);
- MethodHandle mh;
- try {
- mh = IMPL_LOOKUP.findStatic(FieldAccessor.class, name, type);
- } catch (ReflectiveOperationException ex) {
- throw uncaughtException(ex);
- }
- if (caclass != null) {
- MethodType strongType = FieldAccessor.atype(caclass, isSetter);
- mh = MethodHandles.insertArguments(mh, 0, caclass);
- mh = MethodHandles.convertArguments(mh, strongType);
- }
- return mh;
- }
- }
-
- /** Bind a predetermined first argument to the given direct method handle.
- * Callable only from MethodHandles.
- * @param token Proof that the caller has access to this package.
- * @param target Any direct method handle.
- * @param receiver Receiver (or first static method argument) to pre-bind.
- * @return a BoundMethodHandle for the given DirectMethodHandle, or null if it does not exist
- */
- public static
- MethodHandle bindReceiver(Access token,
- MethodHandle target, Object receiver) {
- Access.check(token);
- if (target instanceof AdapterMethodHandle &&
- ((AdapterMethodHandle)target).conversionOp() == MethodHandleNatives.Constants.OP_RETYPE_ONLY
- ) {
- Object info = MethodHandleNatives.getTargetInfo(target);
- if (info instanceof DirectMethodHandle) {
- DirectMethodHandle dmh = (DirectMethodHandle) info;
- if (receiver == null ||
- dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) {
- MethodHandle bmh = new BoundMethodHandle(dmh, receiver, 0);
- MethodType newType = target.type().dropParameterTypes(0, 1);
- return convertArguments(token, bmh, newType, bmh.type(), null);
- }
- }
- }
- if (target instanceof DirectMethodHandle)
- return new BoundMethodHandle((DirectMethodHandle)target, receiver, 0);
- return null; // let caller try something else
- }
-
- /** Bind a predetermined argument to the given arbitrary method handle.
- * Callable only from MethodHandles.
- * @param token Proof that the caller has access to this package.
- * @param target Any method handle.
- * @param receiver Argument (which can be a boxed primitive) to pre-bind.
- * @return a suitable BoundMethodHandle
- */
- public static
- MethodHandle bindArgument(Access token,
- MethodHandle target, int argnum, Object receiver) {
- Access.check(token);
- return new BoundMethodHandle(target, receiver, argnum);
- }
-
- public static MethodHandle convertArguments(Access token,
- MethodHandle target,
- MethodType newType,
- MethodType oldType,
- int[] permutationOrNull) {
- Access.check(token);
- assert(oldType.parameterCount() == target.type().parameterCount());
- if (permutationOrNull != null) {
- int outargs = oldType.parameterCount(), inargs = newType.parameterCount();
- if (permutationOrNull.length != outargs)
- throw newIllegalArgumentException("wrong number of arguments in permutation");
- // Make the individual outgoing argument types match up first.
- Class<?>[] callTypeArgs = new Class<?>[outargs];
- for (int i = 0; i < outargs; i++)
- callTypeArgs[i] = newType.parameterType(permutationOrNull[i]);
- MethodType callType = MethodType.methodType(oldType.returnType(), callTypeArgs);
- target = convertArguments(token, target, callType, oldType, null);
- assert(target != null);
- oldType = target.type();
- List<Integer> goal = new ArrayList<Integer>(); // i*TOKEN
- List<Integer> state = new ArrayList<Integer>(); // i*TOKEN
- List<Integer> drops = new ArrayList<Integer>(); // not tokens
- List<Integer> dups = new ArrayList<Integer>(); // not tokens
- final int TOKEN = 10; // to mark items which are symbolic only
- // state represents the argument values coming into target
- for (int i = 0; i < outargs; i++) {
- state.add(permutationOrNull[i] * TOKEN);
- }
- // goal represents the desired state
- for (int i = 0; i < inargs; i++) {
- if (state.contains(i * TOKEN)) {
- goal.add(i * TOKEN);
- } else {
- // adapter must initially drop all unused arguments
- drops.add(i);
- }
- }
- // detect duplications
- while (state.size() > goal.size()) {
- for (int i2 = 0; i2 < state.size(); i2++) {
- int arg1 = state.get(i2);
- int i1 = state.indexOf(arg1);
- if (i1 != i2) {
- // found duplicate occurrence at i2
- int arg2 = (inargs++) * TOKEN;
- state.set(i2, arg2);
- dups.add(goal.indexOf(arg1));
- goal.add(arg2);
- }
- }
- }
- assert(state.size() == goal.size());
- int size = goal.size();
- while (!state.equals(goal)) {
- // Look for a maximal sequence of adjacent misplaced arguments,
- // and try to rotate them into place.
- int bestRotArg = -10 * TOKEN, bestRotLen = 0;
- int thisRotArg = -10 * TOKEN, thisRotLen = 0;
- for (int i = 0; i < size; i++) {
- int arg = state.get(i);
- // Does this argument match the current run?
- if (arg == thisRotArg + TOKEN) {
- thisRotArg = arg;
- thisRotLen += 1;
- if (bestRotLen < thisRotLen) {
- bestRotLen = thisRotLen;
- bestRotArg = thisRotArg;
- }
- } else {
- // The old sequence (if any) stops here.
- thisRotLen = 0;
- thisRotArg = -10 * TOKEN;
- // But maybe a new one starts here also.
- int wantArg = goal.get(i);
- final int MAX_ARG_ROTATION = AdapterMethodHandle.MAX_ARG_ROTATION;
- if (arg != wantArg &&
- arg >= wantArg - TOKEN * MAX_ARG_ROTATION &&
- arg <= wantArg + TOKEN * MAX_ARG_ROTATION) {
- thisRotArg = arg;
- thisRotLen = 1;
- }
- }
- }
- if (bestRotLen >= 2) {
- // Do a rotation if it can improve argument positioning
- // by at least 2 arguments. This is not always optimal,
- // but it seems to catch common cases.
- int dstEnd = state.indexOf(bestRotArg);
- int srcEnd = goal.indexOf(bestRotArg);
- int rotBy = dstEnd - srcEnd;
- int dstBeg = dstEnd - (bestRotLen - 1);
- int srcBeg = srcEnd - (bestRotLen - 1);
- assert((dstEnd | dstBeg | srcEnd | srcBeg) >= 0); // no negs
- // Make a span which covers both source and destination.
- int rotBeg = Math.min(dstBeg, srcBeg);
- int rotEnd = Math.max(dstEnd, srcEnd);
- int score = 0;
- for (int i = rotBeg; i <= rotEnd; i++) {
- if ((int)state.get(i) != (int)goal.get(i))
- score += 1;
- }
- List<Integer> rotSpan = state.subList(rotBeg, rotEnd+1);
- Collections.rotate(rotSpan, -rotBy); // reverse direction
- for (int i = rotBeg; i <= rotEnd; i++) {
- if ((int)state.get(i) != (int)goal.get(i))
- score -= 1;
- }
- if (score >= 2) {
- // Improved at least two argument positions. Do it.
- List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
- Collections.rotate(ptypes.subList(rotBeg, rotEnd+1), -rotBy);
- MethodType rotType = MethodType.methodType(oldType.returnType(), ptypes);
- MethodHandle nextTarget
- = AdapterMethodHandle.makeRotateArguments(token, rotType, target,
- rotBeg, rotSpan.size(), rotBy);
- if (nextTarget != null) {
- //System.out.println("Rot: "+rotSpan+" by "+rotBy);
- target = nextTarget;
- oldType = rotType;
- continue;
- }
- }
- // Else de-rotate, and drop through to the swap-fest.
- Collections.rotate(rotSpan, rotBy);
- }
-
- // Now swap like the wind!
- List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
- for (int i = 0; i < size; i++) {
- // What argument do I want here?
- int arg = goal.get(i);
- if (arg != state.get(i)) {
- // Where is it now?
- int j = state.indexOf(arg);
- Collections.swap(ptypes, i, j);
- MethodType swapType = MethodType.methodType(oldType.returnType(), ptypes);
- target = AdapterMethodHandle.makeSwapArguments(token, swapType, target, i, j);
- if (target == null) throw newIllegalArgumentException("cannot swap");
- assert(target.type() == swapType);
- oldType = swapType;
- Collections.swap(state, i, j);
- }
- }
- // One pass of swapping must finish the job.
- assert(state.equals(goal));
- }
- while (!dups.isEmpty()) {
- // Grab a contiguous trailing sequence of dups.
- int grab = dups.size() - 1;
- int dupArgPos = dups.get(grab), dupArgCount = 1;
- while (grab - 1 >= 0) {
- int dup0 = dups.get(grab - 1);
- if (dup0 != dupArgPos - 1) break;
- dupArgPos -= 1;
- dupArgCount += 1;
- grab -= 1;
- }
- //if (dupArgCount > 1) System.out.println("Dup: "+dups.subList(grab, dups.size()));
- dups.subList(grab, dups.size()).clear();
- // In the new target type drop that many args from the tail:
- List<Class<?>> ptypes = oldType.parameterList();
- ptypes = ptypes.subList(0, ptypes.size() - dupArgCount);
- MethodType dupType = MethodType.methodType(oldType.returnType(), ptypes);
- target = AdapterMethodHandle.makeDupArguments(token, dupType, target, dupArgPos, dupArgCount);
- if (target == null)
- throw newIllegalArgumentException("cannot dup");
- oldType = target.type();
- }
- while (!drops.isEmpty()) {
- // Grab a contiguous initial sequence of drops.
- int dropArgPos = drops.get(0), dropArgCount = 1;
- while (dropArgCount < drops.size()) {
- int drop1 = drops.get(dropArgCount);
- if (drop1 != dropArgPos + dropArgCount) break;
- dropArgCount += 1;
- }
- //if (dropArgCount > 1) System.out.println("Drop: "+drops.subList(0, dropArgCount));
- drops.subList(0, dropArgCount).clear();
- List<Class<?>> dropTypes = newType.parameterList()
- .subList(dropArgPos, dropArgPos + dropArgCount);
- MethodType dropType = oldType.insertParameterTypes(dropArgPos, dropTypes);
- target = AdapterMethodHandle.makeDropArguments(token, dropType, target, dropArgPos, dropArgCount);
- if (target == null) throw newIllegalArgumentException("cannot drop");
- oldType = target.type();
- }
- }
- if (newType == oldType)
- return target;
- if (oldType.parameterCount() != newType.parameterCount())
- throw newIllegalArgumentException("mismatched parameter count");
- MethodHandle res = AdapterMethodHandle.makePairwiseConvert(token, newType, target);
- if (res != null)
- return res;
- int argc = oldType.parameterCount();
- // The JVM can't do it directly, so fill in the gap with a Java adapter.
- // TO DO: figure out what to put here from case-by-case experience
- // Use a heavier method: Convert all the arguments to Object,
- // then back to the desired types. We might have to use Java-based
- // method handles to do this.
- MethodType objType = MethodType.genericMethodType(argc);
- MethodHandle objTarget = AdapterMethodHandle.makePairwiseConvert(token, objType, target);
- if (objTarget == null)
- objTarget = FromGeneric.make(target);
- res = AdapterMethodHandle.makePairwiseConvert(token, newType, objTarget);
- if (res != null)
- return res;
- return ToGeneric.make(newType, objTarget);
- }
-
- public static MethodHandle spreadArguments(Access token,
- MethodHandle target,
- MethodType newType,
- int spreadArg) {
- Access.check(token);
- // TO DO: maybe allow the restarg to be Object and implicitly cast to Object[]
- MethodType oldType = target.type();
- // spread the last argument of newType to oldType
- int spreadCount = oldType.parameterCount() - spreadArg;
- Class<Object[]> spreadArgType = Object[].class;
- MethodHandle res = AdapterMethodHandle.makeSpreadArguments(token, newType, target, spreadArgType, spreadArg, spreadCount);
- if (res != null)
- return res;
- // try an intermediate adapter
- Class<?> spreadType = null;
- if (spreadArg < 0 || spreadArg >= newType.parameterCount()
- || !VerifyType.isSpreadArgType(spreadType = newType.parameterType(spreadArg)))
- throw newIllegalArgumentException("no restarg in "+newType);
- Class<?>[] ptypes = oldType.parameterArray();
- for (int i = 0; i < spreadCount; i++)
- ptypes[spreadArg + i] = VerifyType.spreadArgElementType(spreadType, i);
- MethodType midType = MethodType.methodType(newType.returnType(), ptypes);
- // after spreading, some arguments may need further conversion
- MethodHandle target2 = convertArguments(token, target, midType, oldType, null);
- if (target2 == null)
- throw new UnsupportedOperationException("NYI: convert "+midType+" =calls=> "+oldType);
- res = AdapterMethodHandle.makeSpreadArguments(token, newType, target2, spreadArgType, spreadArg, spreadCount);
- if (res != null)
- return res;
- res = SpreadGeneric.make(target2, spreadCount);
- if (res != null)
- res = convertArguments(token, res, newType, res.type(), null);
- return res;
- }
-
- public static MethodHandle collectArguments(Access token,
- MethodHandle target,
- MethodType newType,
- int collectArg,
- MethodHandle collector) {
- MethodType oldType = target.type(); // (a...,c)=>r
- if (collector == null) {
- int numCollect = newType.parameterCount() - oldType.parameterCount() + 1;
- collector = ValueConversions.varargsArray(numCollect);
- }
- // newType // (a..., b...)=>r
- MethodType colType = collector.type(); // (b...)=>c
- // oldType // (a..., b...)=>r
- assert(newType.parameterCount() == collectArg + colType.parameterCount());
- assert(oldType.parameterCount() == collectArg + 1);
- MethodHandle gtarget = convertArguments(token, target, oldType.generic(), oldType, null);
- MethodHandle gcollector = convertArguments(token, collector, colType.generic(), colType, null);
- if (gtarget == null || gcollector == null) return null;
- MethodHandle gresult = FilterGeneric.makeArgumentCollector(gcollector, gtarget);
- MethodHandle result = convertArguments(token, gresult, newType, gresult.type(), null);
- return result;
- }
-
- public static MethodHandle filterArgument(Access token,
- MethodHandle target,
- int pos,
- MethodHandle filter) {
- Access.check(token);
- MethodType ttype = target.type(), gttype = ttype.generic();
- if (ttype != gttype) {
- target = convertArguments(token, target, gttype, ttype, null);
- ttype = gttype;
- }
- MethodType ftype = filter.type(), gftype = ftype.generic();
- if (ftype.parameterCount() != 1)
- throw new InternalError();
- if (ftype != gftype) {
- filter = convertArguments(token, filter, gftype, ftype, null);
- ftype = gftype;
- }
- if (ftype == ttype) {
- // simple unary case
- return FilterOneArgument.make(filter, target);
- }
- return FilterGeneric.makeArgumentFilter(pos, filter, target);
- }
-
- public static MethodHandle foldArguments(Access token,
- MethodHandle target,
- MethodType newType,
- MethodHandle combiner) {
- Access.check(token);
- MethodType oldType = target.type();
- MethodType ctype = combiner.type();
- MethodHandle gtarget = convertArguments(token, target, oldType.generic(), oldType, null);
- MethodHandle gcombiner = convertArguments(token, combiner, ctype.generic(), ctype, null);
- if (gtarget == null || gcombiner == null) return null;
- MethodHandle gresult = FilterGeneric.makeArgumentFolder(gcombiner, gtarget);
- MethodHandle result = convertArguments(token, gresult, newType, gresult.type(), null);
- return result;
- }
-
- public static
- MethodHandle dropArguments(Access token, MethodHandle target,
- MethodType newType, int argnum) {
- Access.check(token);
- int drops = newType.parameterCount() - target.type().parameterCount();
- MethodHandle res = AdapterMethodHandle.makeDropArguments(token, newType, target, argnum, drops);
- if (res != null)
- return res;
- throw new UnsupportedOperationException("NYI");
- }
-
- private static class GuardWithTest extends BoundMethodHandle {
- private final MethodHandle test, target, fallback;
- private GuardWithTest(MethodHandle invoker,
- MethodHandle test, MethodHandle target, MethodHandle fallback) {
- super(Access.TOKEN, invoker);
- this.test = test;
- this.target = target;
- this.fallback = fallback;
- }
- static MethodHandle make(Access token,
- MethodHandle test, MethodHandle target, MethodHandle fallback) {
- Access.check(token);
- MethodType type = target.type();
- int nargs = type.parameterCount();
- if (nargs < INVOKES.length) {
- MethodHandle invoke = INVOKES[nargs];
- MethodType gtype = type.generic();
- assert(invoke.type().dropParameterTypes(0,1) == gtype);
- MethodHandle gtest = convertArguments(token, test, gtype.changeReturnType(boolean.class), test.type(), null);
- MethodHandle gtarget = convertArguments(token, target, gtype, type, null);
- MethodHandle gfallback = convertArguments(token, fallback, gtype, type, null);
- if (gtest == null || gtarget == null || gfallback == null) return null;
- MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback);
- return convertArguments(token, gguard, type, gtype, null);
- } else {
- MethodHandle invoke = VARARGS_INVOKE;
- MethodType gtype = MethodType.genericMethodType(1);
- assert(invoke.type().dropParameterTypes(0,1) == gtype);
- MethodHandle gtest = spreadArguments(token, test, gtype.changeReturnType(boolean.class), 0);
- MethodHandle gtarget = spreadArguments(token, target, gtype, 0);
- MethodHandle gfallback = spreadArguments(token, fallback, gtype, 0);
- MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback);
- if (gtest == null || gtarget == null || gfallback == null) return null;
- return collectArguments(token, gguard, type, 0, null);
- }
- }
- @Override
- public String toString() {
- return addTypeString(target, this);
- }
- private Object invoke_V(Object... av) throws Throwable {
- if ((boolean) test.invokeExact(av))
- return target.invokeExact(av);
- return fallback.invokeExact(av);
- }
- private Object invoke_L0() throws Throwable {
- if ((boolean) test.invokeExact())
- return target.invokeExact();
- return fallback.invokeExact();
- }
- private Object invoke_L1(Object a0) throws Throwable {
- if ((boolean) test.invokeExact(a0))
- return target.invokeExact(a0);
- return fallback.invokeExact(a0);
- }
- private Object invoke_L2(Object a0, Object a1) throws Throwable {
- if ((boolean) test.invokeExact(a0, a1))
- return target.invokeExact(a0, a1);
- return fallback.invokeExact(a0, a1);
- }
- private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
- if ((boolean) test.invokeExact(a0, a1, a2))
- return target.invokeExact(a0, a1, a2);
- return fallback.invokeExact(a0, a1, a2);
- }
- private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- if ((boolean) test.invokeExact(a0, a1, a2, a3))
- return target.invokeExact(a0, a1, a2, a3);
- return fallback.invokeExact(a0, a1, a2, a3);
- }
- private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
- if ((boolean) test.invokeExact(a0, a1, a2, a3, a4))
- return target.invokeExact(a0, a1, a2, a3, a4);
- return fallback.invokeExact(a0, a1, a2, a3, a4);
- }
- private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
- if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5))
- return target.invokeExact(a0, a1, a2, a3, a4, a5);
- return fallback.invokeExact(a0, a1, a2, a3, a4, a5);
- }
- private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
- if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6))
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
- return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6);
- }
- private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
- if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7))
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
- return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
- }
- static MethodHandle[] makeInvokes() {
- ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
- MethodHandles.Lookup lookup = IMPL_LOOKUP;
- for (;;) {
- int nargs = invokes.size();
- String name = "invoke_L"+nargs;
- MethodHandle invoke = null;
- try {
- invoke = lookup.findVirtual(GuardWithTest.class, name, MethodType.genericMethodType(nargs));
- } catch (ReflectiveOperationException ex) {
- }
- if (invoke == null) break;
- invokes.add(invoke);
- }
- assert(invokes.size() == 9); // current number of methods
- return invokes.toArray(new MethodHandle[0]);
- };
- static final MethodHandle[] INVOKES = makeInvokes();
- // For testing use this:
- //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
- static final MethodHandle VARARGS_INVOKE;
- static {
- try {
- VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(GuardWithTest.class, "invoke_V", MethodType.genericMethodType(0, true));
- } catch (ReflectiveOperationException ex) {
- throw uncaughtException(ex);
- }
- }
- }
-
- public static
- MethodHandle makeGuardWithTest(Access token,
- MethodHandle test,
- MethodHandle target,
- MethodHandle fallback) {
- return GuardWithTest.make(token, test, target, fallback);
- }
-
- private static class GuardWithCatch extends BoundMethodHandle {
- private final MethodHandle target;
- private final Class<? extends Throwable> exType;
- private final MethodHandle catcher;
- public GuardWithCatch(MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
- this(INVOKES[target.type().parameterCount()], target, exType, catcher);
- }
- public GuardWithCatch(MethodHandle invoker,
- MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
- super(Access.TOKEN, invoker);
- this.target = target;
- this.exType = exType;
- this.catcher = catcher;
- }
- @Override
- public String toString() {
- return addTypeString(target, this);
- }
- private Object invoke_V(Object... av) throws Throwable {
- try {
- return target.invokeExact(av);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, av);
- }
- }
- private Object invoke_L0() throws Throwable {
- try {
- return target.invokeExact();
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t);
- }
- }
- private Object invoke_L1(Object a0) throws Throwable {
- try {
- return target.invokeExact(a0);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0);
- }
- }
- private Object invoke_L2(Object a0, Object a1) throws Throwable {
- try {
- return target.invokeExact(a0, a1);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0, a1);
- }
- }
- private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
- try {
- return target.invokeExact(a0, a1, a2);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0, a1, a2);
- }
- }
- private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
- try {
- return target.invokeExact(a0, a1, a2, a3);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0, a1, a2, a3);
- }
- }
- private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
- try {
- return target.invokeExact(a0, a1, a2, a3, a4);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0, a1, a2, a3, a4);
- }
- }
- private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
- try {
- return target.invokeExact(a0, a1, a2, a3, a4, a5);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5);
- }
- }
- private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
- try {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6);
- }
- }
- private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
- try {
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
- } catch (Throwable t) {
- if (!exType.isInstance(t)) throw t;
- return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6, a7);
- }
- }
- static MethodHandle[] makeInvokes() {
- ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
- MethodHandles.Lookup lookup = IMPL_LOOKUP;
- for (;;) {
- int nargs = invokes.size();
- String name = "invoke_L"+nargs;
- MethodHandle invoke = null;
- try {
- invoke = lookup.findVirtual(GuardWithCatch.class, name, MethodType.genericMethodType(nargs));
- } catch (ReflectiveOperationException ex) {
- }
- if (invoke == null) break;
- invokes.add(invoke);
- }
- assert(invokes.size() == 9); // current number of methods
- return invokes.toArray(new MethodHandle[0]);
- };
- static final MethodHandle[] INVOKES = makeInvokes();
- // For testing use this:
- //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
- static final MethodHandle VARARGS_INVOKE;
- static {
- try {
- VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(GuardWithCatch.class, "invoke_V", MethodType.genericMethodType(0, true));
- } catch (ReflectiveOperationException ex) {
- throw uncaughtException(ex);
- }
- }
- }
-
-
- public static
- MethodHandle makeGuardWithCatch(Access token,
- MethodHandle target,
- Class<? extends Throwable> exType,
- MethodHandle catcher) {
- Access.check(token);
- MethodType type = target.type();
- MethodType ctype = catcher.type();
- int nargs = type.parameterCount();
- if (nargs < GuardWithCatch.INVOKES.length) {
- MethodType gtype = type.generic();
- MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
- MethodHandle gtarget = convertArguments(token, target, gtype, type, null);
- MethodHandle gcatcher = convertArguments(token, catcher, gcatchType, ctype, null);
- MethodHandle gguard = new GuardWithCatch(gtarget, exType, gcatcher);
- if (gtarget == null || gcatcher == null || gguard == null) return null;
- return convertArguments(token, gguard, type, gtype, null);
- } else {
- MethodType gtype = MethodType.genericMethodType(0, true);
- MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
- MethodHandle gtarget = spreadArguments(token, target, gtype, 0);
- MethodHandle gcatcher = spreadArguments(token, catcher, gcatchType, 1);
- MethodHandle gguard = new GuardWithCatch(GuardWithCatch.VARARGS_INVOKE, gtarget, exType, gcatcher);
- if (gtarget == null || gcatcher == null || gguard == null) return null;
- return collectArguments(token, gguard, type, 0, null);
- }
- }
-
- public static
- MethodHandle throwException(Access token, MethodType type) {
- Access.check(token);
- return AdapterMethodHandle.makeRetypeRaw(token, type, THROW_EXCEPTION);
- }
-
- static final MethodHandle THROW_EXCEPTION;
- static {
- try {
- THROW_EXCEPTION
- = IMPL_LOOKUP.findStatic(MethodHandleImpl.class, "throwException",
- MethodType.methodType(Empty.class, Throwable.class));
- } catch (ReflectiveOperationException ex) {
- throw new RuntimeException(ex);
- }
- }
- static <T extends Throwable> Empty throwException(T t) throws T { throw t; }
-
- public static String getNameString(Access token, MethodHandle target, Object type) {
- Access.check(token);
- if (!(type instanceof MethodType)) {
- if (type == null)
- type = target.type();
- else if (type instanceof MethodHandle)
- type = ((MethodHandle)type).type();
- }
- MemberName name = null;
- if (target != null)
- name = MethodHandleNatives.getMethodName(target);
- if (name == null)
- return "invoke" + type;
- return name.getName() + type;
- }
-
- public static String getNameString(Access token, MethodHandle target) {
- return getNameString(token, target, null);
- }
-
- static String addTypeString(Object obj, MethodHandle target) {
- String str = String.valueOf(obj);
- if (target == null) return str;
- int paren = str.indexOf('(');
- if (paren >= 0) str = str.substring(0, paren);
- return str + target.type();
- }
-
- static void checkSpreadArgument(Object av, int n) {
- if (av == null ? n != 0 : ((Object[])av).length != n)
- throw newIllegalArgumentException("Array is not of length "+n);
- }
-
- static void raiseException(int code, Object actual, Object required) {
- String message;
- // disregard the identity of the actual object, if it is not a class:
- if (!(actual instanceof Class) && !(actual instanceof MethodType))
- actual = actual.getClass();
- if (actual != null)
- message = "required "+required+" but encountered "+actual;
- else
- message = "required "+required;
- switch (code) {
- case 192: // checkcast
- throw new ClassCastException(message);
- default:
- throw new InternalError("unexpected code "+code+": "+message);
- }
- }
-
- // Linkage support:
- public static void registerBootstrap(Access token, Class<?> callerClass, MethodHandle bootstrapMethod) {
- Access.check(token);
- MethodHandleNatives.registerBootstrap(callerClass, bootstrapMethod);
- }
- public static MethodHandle getBootstrap(Access token, Class<?> callerClass) {
- Access.check(token);
- return MethodHandleNatives.getBootstrap(callerClass);
- }
-
- public static MethodHandle asVarargsCollector(Access token, MethodHandle target, Class<?> arrayType) {
- Access.check(token);
- return AdapterMethodHandle.makeVarargsCollector(token, target, arrayType);
- }
-}
--- a/jdk/src/share/classes/sun/dyn/MethodHandleNatives.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,359 +0,0 @@
-/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import java.dyn.MethodHandles.Lookup;
-import java.lang.reflect.AccessibleObject;
-import java.lang.reflect.Field;
-import static sun.dyn.MethodHandleNatives.Constants.*;
-import static sun.dyn.MethodHandleImpl.IMPL_LOOKUP;
-
-/**
- * The JVM interface for the method handles package is all here.
- * This is an interface internal and private to an implemetantion of JSR 292.
- * <em>This class is not part of the JSR 292 standard.</em>
- * @author jrose
- */
-class MethodHandleNatives {
-
- private MethodHandleNatives() { } // static only
-
- /// MethodName support
-
- static native void init(MemberName self, Object ref);
- static native void expand(MemberName self);
- static native void resolve(MemberName self, Class<?> caller);
- static native int getMembers(Class<?> defc, String matchName, String matchSig,
- int matchFlags, Class<?> caller, int skip, MemberName[] results);
-
- /// MethodHandle support
-
- /** Initialize the method handle to adapt the call. */
- static native void init(AdapterMethodHandle self, MethodHandle target, int argnum);
- /** Initialize the method handle to call the correct method, directly. */
- static native void init(BoundMethodHandle self, Object target, int argnum);
- /** Initialize the method handle to call as if by an invoke* instruction. */
- static native void init(DirectMethodHandle self, Object ref, boolean doDispatch, Class<?> caller);
-
- /** Initialize a method type, once per form. */
- static native void init(MethodType self);
-
- /** Tell the JVM about a class's bootstrap method. */
- static native void registerBootstrap(Class<?> caller, MethodHandle bootstrapMethod);
-
- /** Ask the JVM about a class's bootstrap method. */
- static native MethodHandle getBootstrap(Class<?> caller);
-
- /** Tell the JVM that we need to change the target of an invokedynamic. */
- static native void setCallSiteTarget(CallSite site, MethodHandle target);
-
- /** Fetch the vmtarget field.
- * It will be sanitized as necessary to avoid exposing non-Java references.
- * This routine is for debugging and reflection.
- */
- static native Object getTarget(MethodHandle self, int format);
-
- /** Fetch the name of the handled method, if available.
- * This routine is for debugging and reflection.
- */
- static MemberName getMethodName(MethodHandle self) {
- if (!JVM_SUPPORT) return null;
- return (MemberName) getTarget(self, ETF_METHOD_NAME);
- }
-
- /** Fetch the reflective version of the handled method, if available.
- */
- static AccessibleObject getTargetMethod(MethodHandle self) {
- if (!JVM_SUPPORT) return null;
- return (AccessibleObject) getTarget(self, ETF_REFLECT_METHOD);
- }
-
- /** Fetch the target of this method handle.
- * If it directly targets a method, return a MemberName for the method.
- * If it is chained to another method handle, return that handle.
- */
- static Object getTargetInfo(MethodHandle self) {
- if (!JVM_SUPPORT) return null;
- return getTarget(self, ETF_HANDLE_OR_METHOD_NAME);
- }
-
- static Object[] makeTarget(Class<?> defc, String name, String sig, int mods, Class<?> refc) {
- return new Object[] { defc, name, sig, mods, refc };
- }
-
- /** Fetch MH-related JVM parameter.
- * which=0 retrieves MethodHandlePushLimit
- * which=1 retrieves stack slot push size (in address units)
- */
- static native int getConstant(int which);
-
- /** True iff this HotSpot JVM has built-in support for method handles.
- * If false, some test cases might run, but functionality will be missing.
- */
- public static final boolean JVM_SUPPORT;
-
- /** Java copy of MethodHandlePushLimit in range 2..255. */
- static final int JVM_PUSH_LIMIT;
- /** JVM stack motion (in words) after one slot is pushed, usually -1.
- */
- static final int JVM_STACK_MOVE_UNIT;
-
- /** Which conv-ops are implemented by the JVM? */
- static final int CONV_OP_IMPLEMENTED_MASK;
-
- private static native void registerNatives();
- static {
- boolean JVM_SUPPORT_;
- int JVM_PUSH_LIMIT_;
- int JVM_STACK_MOVE_UNIT_;
- int CONV_OP_IMPLEMENTED_MASK_;
- try {
- registerNatives();
- JVM_SUPPORT_ = true;
- JVM_PUSH_LIMIT_ = getConstant(Constants.GC_JVM_PUSH_LIMIT);
- JVM_STACK_MOVE_UNIT_ = getConstant(Constants.GC_JVM_STACK_MOVE_UNIT);
- CONV_OP_IMPLEMENTED_MASK_ = getConstant(Constants.GC_CONV_OP_IMPLEMENTED_MASK);
- //sun.reflect.Reflection.registerMethodsToFilter(MethodHandleImpl.class, "init");
- } catch (UnsatisfiedLinkError ee) {
- // ignore; if we use init() methods later we'll see linkage errors
- JVM_SUPPORT_ = false;
- JVM_PUSH_LIMIT_ = 3; // arbitrary
- JVM_STACK_MOVE_UNIT_ = -1; // arbitrary
- CONV_OP_IMPLEMENTED_MASK_ = 0;
- //System.out.println("Warning: Running with JVM_SUPPORT=false");
- //System.out.println(ee);
- JVM_SUPPORT = JVM_SUPPORT_;
- JVM_PUSH_LIMIT = JVM_PUSH_LIMIT_;
- JVM_STACK_MOVE_UNIT = JVM_STACK_MOVE_UNIT_;
- throw ee; // just die; hopeless to try to run with an older JVM
- }
- JVM_SUPPORT = JVM_SUPPORT_;
- JVM_PUSH_LIMIT = JVM_PUSH_LIMIT_;
- JVM_STACK_MOVE_UNIT = JVM_STACK_MOVE_UNIT_;
- if (CONV_OP_IMPLEMENTED_MASK_ == 0)
- CONV_OP_IMPLEMENTED_MASK_ = DEFAULT_CONV_OP_IMPLEMENTED_MASK;
- CONV_OP_IMPLEMENTED_MASK = CONV_OP_IMPLEMENTED_MASK_;
- }
-
- // All compile-time constants go here.
- // There is an opportunity to check them against the JVM's idea of them.
- static class Constants {
- Constants() { } // static only
- // MethodHandleImpl
- static final int // for getConstant
- GC_JVM_PUSH_LIMIT = 0,
- GC_JVM_STACK_MOVE_UNIT = 1,
- GC_CONV_OP_IMPLEMENTED_MASK = 2;
- static final int
- ETF_HANDLE_OR_METHOD_NAME = 0, // all available data (immediate MH or method)
- ETF_DIRECT_HANDLE = 1, // ultimate method handle (will be a DMH, may be self)
- ETF_METHOD_NAME = 2, // ultimate method as MemberName
- ETF_REFLECT_METHOD = 3; // ultimate method as java.lang.reflect object (sans refClass)
-
- // MemberName
- // The JVM uses values of -2 and above for vtable indexes.
- // Field values are simple positive offsets.
- // Ref: src/share/vm/oops/methodOop.hpp
- // This value is negative enough to avoid such numbers,
- // but not too negative.
- static final int
- MN_IS_METHOD = 0x00010000, // method (not constructor)
- MN_IS_CONSTRUCTOR = 0x00020000, // constructor
- MN_IS_FIELD = 0x00040000, // field
- MN_IS_TYPE = 0x00080000, // nested type
- MN_SEARCH_SUPERCLASSES = 0x00100000, // for MHN.getMembers
- MN_SEARCH_INTERFACES = 0x00200000, // for MHN.getMembers
- VM_INDEX_UNINITIALIZED = -99;
-
- // AdapterMethodHandle
- /** Conversions recognized by the JVM.
- * They must align with the constants in sun.dyn_AdapterMethodHandle,
- * in the JVM file hotspot/src/share/vm/classfile/javaClasses.hpp.
- */
- static final int
- OP_RETYPE_ONLY = 0x0, // no argument changes; straight retype
- OP_RETYPE_RAW = 0x1, // no argument changes; straight retype
- OP_CHECK_CAST = 0x2, // ref-to-ref conversion; requires a Class argument
- OP_PRIM_TO_PRIM = 0x3, // converts from one primitive to another
- OP_REF_TO_PRIM = 0x4, // unboxes a wrapper to produce a primitive
- OP_PRIM_TO_REF = 0x5, // boxes a primitive into a wrapper (NYI)
- OP_SWAP_ARGS = 0x6, // swap arguments (vminfo is 2nd arg)
- OP_ROT_ARGS = 0x7, // rotate arguments (vminfo is displaced arg)
- OP_DUP_ARGS = 0x8, // duplicates one or more arguments (at TOS)
- OP_DROP_ARGS = 0x9, // remove one or more argument slots
- OP_COLLECT_ARGS = 0xA, // combine one or more arguments into a varargs (NYI)
- OP_SPREAD_ARGS = 0xB, // expand in place a varargs array (of known size)
- OP_FLYBY = 0xC, // operate first on reified argument list (NYI)
- OP_RICOCHET = 0xD, // run an adapter chain on the return value (NYI)
- CONV_OP_LIMIT = 0xE; // limit of CONV_OP enumeration
- /** Shift and mask values for decoding the AMH.conversion field.
- * These numbers are shared with the JVM for creating AMHs.
- */
- static final int
- CONV_OP_MASK = 0xF00, // this nybble contains the conversion op field
- CONV_VMINFO_MASK = 0x0FF, // LSB is reserved for JVM use
- CONV_VMINFO_SHIFT = 0, // position of bits in CONV_VMINFO_MASK
- CONV_OP_SHIFT = 8, // position of bits in CONV_OP_MASK
- CONV_DEST_TYPE_SHIFT = 12, // byte 2 has the adapter BasicType (if needed)
- CONV_SRC_TYPE_SHIFT = 16, // byte 2 has the source BasicType (if needed)
- CONV_STACK_MOVE_SHIFT = 20, // high 12 bits give signed SP change
- CONV_STACK_MOVE_MASK = (1 << (32 - CONV_STACK_MOVE_SHIFT)) - 1;
-
- /** Which conv-ops are implemented by the JVM? */
- static final int DEFAULT_CONV_OP_IMPLEMENTED_MASK =
- // Value to use if the corresponding JVM query fails.
- ((1<<OP_RETYPE_ONLY)
- |(1<<OP_RETYPE_RAW)
- |(1<<OP_CHECK_CAST)
- |(1<<OP_PRIM_TO_PRIM)
- |(1<<OP_REF_TO_PRIM)
- |(1<<OP_SWAP_ARGS)
- |(1<<OP_ROT_ARGS)
- |(1<<OP_DUP_ARGS)
- |(1<<OP_DROP_ARGS)
- //|(1<<OP_SPREAD_ARGS)
- );
-
- /**
- * Basic types as encoded in the JVM. These code values are not
- * intended for use outside this class. They are used as part of
- * a private interface between the JVM and this class.
- */
- static final int
- T_BOOLEAN = 4,
- T_CHAR = 5,
- T_FLOAT = 6,
- T_DOUBLE = 7,
- T_BYTE = 8,
- T_SHORT = 9,
- T_INT = 10,
- T_LONG = 11,
- T_OBJECT = 12,
- //T_ARRAY = 13
- T_VOID = 14;
- //T_ADDRESS = 15
-
- /**
- * Constant pool reference-kind codes, as used by CONSTANT_MethodHandle CP entries.
- */
- static final int
- REF_getField = 1,
- REF_getStatic = 2,
- REF_putField = 3,
- REF_putStatic = 4,
- REF_invokeVirtual = 5,
- REF_invokeStatic = 6,
- REF_invokeSpecial = 7,
- REF_newInvokeSpecial = 8,
- REF_invokeInterface = 9;
- }
-
- private static native int getNamedCon(int which, Object[] name);
- static boolean verifyConstants() {
- Object[] box = { null };
- for (int i = 0; ; i++) {
- box[0] = null;
- int vmval = getNamedCon(i, box);
- if (box[0] == null) break;
- String name = (String) box[0];
- try {
- Field con = Constants.class.getDeclaredField(name);
- int jval = con.getInt(null);
- if (jval != vmval)
- throw new InternalError(name+": JVM has "+vmval+" while Java has "+jval);
- } catch (Exception ex) {
- throw new InternalError(name+": access failed, got "+ex);
- }
- }
- return true;
- }
- static {
- if (JVM_SUPPORT) verifyConstants();
- }
-
- // Up-calls from the JVM.
- // These must NOT be public.
-
- /**
- * The JVM is linking an invokedynamic instruction. Create a reified call site for it.
- */
- static CallSite makeDynamicCallSite(MethodHandle bootstrapMethod,
- String name, MethodType type,
- Object info,
- MemberName callerMethod, int callerBCI) {
- return CallSiteImpl.makeSite(bootstrapMethod, name, type, info, callerMethod, callerBCI);
- }
-
- /**
- * The JVM wants a pointer to a MethodType. Oblige it by finding or creating one.
- */
- static MethodType findMethodHandleType(Class<?> rtype, Class<?>[] ptypes) {
- MethodType.genericMethodType(0); // trigger initialization
- return MethodTypeImpl.makeImpl(Access.TOKEN, rtype, ptypes, true);
- }
-
- /**
- * The JVM wants to use a MethodType with invokeGeneric. Give the runtime fair warning.
- */
- static void notifyGenericMethodType(MethodType type) {
- try {
- // Trigger adapter creation.
- InvokeGeneric.genericInvokerOf(type);
- } catch (Exception ex) {
- Error err = new InternalError("Exception while resolving invokeGeneric");
- err.initCause(ex);
- throw err;
- }
- }
-
- /**
- * The JVM is resolving a CONSTANT_MethodHandle CP entry. And it wants our help.
- * It will make an up-call to this method. (Do not change the name or signature.)
- */
- static MethodHandle linkMethodHandleConstant(Class<?> callerClass, int refKind,
- Class<?> defc, String name, Object type) {
- try {
- Lookup lookup = IMPL_LOOKUP.in(callerClass);
- switch (refKind) {
- case REF_getField: return lookup.findGetter( defc, name, (Class<?>) type );
- case REF_getStatic: return lookup.findStaticGetter( defc, name, (Class<?>) type );
- case REF_putField: return lookup.findSetter( defc, name, (Class<?>) type );
- case REF_putStatic: return lookup.findStaticSetter( defc, name, (Class<?>) type );
- case REF_invokeVirtual: return lookup.findVirtual( defc, name, (MethodType) type );
- case REF_invokeStatic: return lookup.findStatic( defc, name, (MethodType) type );
- case REF_invokeSpecial: return lookup.findSpecial( defc, name, (MethodType) type, callerClass );
- case REF_newInvokeSpecial: return lookup.findConstructor( defc, (MethodType) type );
- case REF_invokeInterface: return lookup.findVirtual( defc, name, (MethodType) type );
- }
- throw new IllegalArgumentException("bad MethodHandle constant "+name+" : "+type);
- } catch (ReflectiveOperationException ex) {
- Error err = new IncompatibleClassChangeError();
- err.initCause(ex);
- throw err;
- }
- }
-}
--- a/jdk/src/share/classes/sun/dyn/MethodTypeImpl.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,516 +0,0 @@
-/*
- * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import sun.dyn.util.Wrapper;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-
-/**
- * Shared information for a group of method types, which differ
- * only by reference types, and therefore share a common erasure
- * and wrapping.
- * <p>
- * For an empirical discussion of the structure of method types,
- * see <a href="http://groups.google.com/group/jvm-languages/browse_thread/thread/ac9308ae74da9b7e/">
- * the thread "Avoiding Boxing" on jvm-languages</a>.
- * There are approximately 2000 distinct erased method types in the JDK.
- * There are a little over 10 times that number of unerased types.
- * No more than half of these are likely to be loaded at once.
- * @author John Rose
- */
-public class MethodTypeImpl {
- final int[] argToSlotTable, slotToArgTable;
- final long argCounts; // packed slot & value counts
- final long primCounts; // packed prim & double counts
- final int vmslots; // total number of parameter slots
- final MethodType erasedType; // the canonical erasure
-
- /*lazy*/ MethodType primsAsBoxes; // replace prims by wrappers
- /*lazy*/ MethodType primArgsAsBoxes; // wrap args only; make raw return
- /*lazy*/ MethodType primsAsInts; // replace prims by int/long
- /*lazy*/ MethodType primsAsLongs; // replace prims by long
- /*lazy*/ MethodType primsAtEnd; // reorder primitives to the end
-
- // Cached adapter information:
- /*lazy*/ ToGeneric toGeneric; // convert cs. with prims to w/o
- /*lazy*/ FromGeneric fromGeneric; // convert cs. w/o prims to with
- /*lazy*/ SpreadGeneric[] spreadGeneric; // expand one argument to many
- /*lazy*/ FilterGeneric filterGeneric; // convert argument(s) on the fly
- /*lazy*/ MethodHandle genericInvoker; // hook for invokeGeneric
-
- public MethodType erasedType() {
- return erasedType;
- }
-
- public static MethodTypeImpl of(MethodType type) {
- return METHOD_TYPE_FRIEND.form(type);
- }
-
- /** Access methods for the internals of MethodType, supplied to
- * MethodTypeImpl as a trusted agent.
- */
- static public interface MethodTypeFriend {
- Class<?>[] ptypes(MethodType mt);
- MethodTypeImpl form(MethodType mt);
- void setForm(MethodType mt, MethodTypeImpl form);
- MethodType makeImpl(Class<?> rtype, Class<?>[] ptypes, boolean trusted);
- MethodTypeImpl newMethodTypeForm(MethodType mt);
- Invokers getInvokers(MethodType mt);
- void setInvokers(MethodType mt, Invokers inv);
- }
- public static void setMethodTypeFriend(Access token, MethodTypeFriend am) {
- Access.check(token);
- if (METHOD_TYPE_FRIEND != null)
- throw new InternalError(); // just once
- METHOD_TYPE_FRIEND = am;
- }
- static private MethodTypeFriend METHOD_TYPE_FRIEND;
-
- static MethodType makeImpl(Access token, Class<?> rtype, Class<?>[] ptypes, boolean trusted) {
- Access.check(token);
- return METHOD_TYPE_FRIEND.makeImpl(rtype, ptypes, trusted);
- }
-
- protected MethodTypeImpl(MethodType erasedType) {
- this.erasedType = erasedType;
-
- Class<?>[] ptypes = METHOD_TYPE_FRIEND.ptypes(erasedType);
- int ptypeCount = ptypes.length;
- int pslotCount = ptypeCount; // temp. estimate
- int rtypeCount = 1; // temp. estimate
- int rslotCount = 1; // temp. estimate
-
- int[] argToSlotTab = null, slotToArgTab = null;
-
- // Walk the argument types, looking for primitives.
- int pac = 0, lac = 0, prc = 0, lrc = 0;
- Class<?> epts[] = ptypes;
- for (int i = 0; i < epts.length; i++) {
- Class<?> pt = epts[i];
- if (pt != Object.class) {
- assert(pt.isPrimitive());
- ++pac;
- if (hasTwoArgSlots(pt)) ++lac;
- }
- }
- pslotCount += lac; // #slots = #args + #longs
- Class<?> rt = erasedType.returnType();
- if (rt != Object.class) {
- ++prc; // even void.class counts as a prim here
- if (hasTwoArgSlots(rt)) ++lrc;
- // adjust #slots, #args
- if (rt == void.class)
- rtypeCount = rslotCount = 0;
- else
- rslotCount += lrc;
- }
- if (lac != 0) {
- int slot = ptypeCount + lac;
- slotToArgTab = new int[slot+1];
- argToSlotTab = new int[1+ptypeCount];
- argToSlotTab[0] = slot; // argument "-1" is past end of slots
- for (int i = 0; i < epts.length; i++) {
- Class<?> pt = epts[i];
- if (hasTwoArgSlots(pt)) --slot;
- --slot;
- slotToArgTab[slot] = i+1; // "+1" see argSlotToParameter note
- argToSlotTab[1+i] = slot;
- }
- assert(slot == 0); // filled the table
- }
- this.primCounts = pack(lrc, prc, lac, pac);
- this.argCounts = pack(rslotCount, rtypeCount, pslotCount, ptypeCount);
- if (slotToArgTab == null) {
- int slot = ptypeCount; // first arg is deepest in stack
- slotToArgTab = new int[slot+1];
- argToSlotTab = new int[1+ptypeCount];
- argToSlotTab[0] = slot; // argument "-1" is past end of slots
- for (int i = 0; i < ptypeCount; i++) {
- --slot;
- slotToArgTab[slot] = i+1; // "+1" see argSlotToParameter note
- argToSlotTab[1+i] = slot;
- }
- }
- this.argToSlotTable = argToSlotTab;
- this.slotToArgTable = slotToArgTab;
-
- if (pslotCount >= 256) throw newIllegalArgumentException("too many arguments");
-
- // send a few bits down to the JVM:
- this.vmslots = parameterSlotCount();
-
- // short circuit some no-op canonicalizations:
- if (!hasPrimitives()) {
- primsAsBoxes = erasedType;
- primArgsAsBoxes = erasedType;
- primsAsInts = erasedType;
- primsAsLongs = erasedType;
- primsAtEnd = erasedType;
- }
- }
-
- /** Turn all primitive types to corresponding wrapper types.
- */
- public MethodType primsAsBoxes() {
- MethodType ct = primsAsBoxes;
- if (ct != null) return ct;
- MethodType t = erasedType;
- ct = canonicalize(erasedType, WRAP, WRAP);
- if (ct == null) ct = t; // no prims to box
- return primsAsBoxes = ct;
- }
-
- /** Turn all primitive argument types to corresponding wrapper types.
- * Subword and void return types are promoted to int.
- */
- public MethodType primArgsAsBoxes() {
- MethodType ct = primArgsAsBoxes;
- if (ct != null) return ct;
- MethodType t = erasedType;
- ct = canonicalize(erasedType, RAW_RETURN, WRAP);
- if (ct == null) ct = t; // no prims to box
- return primArgsAsBoxes = ct;
- }
-
- /** Turn all primitive types to either int or long.
- * Floating point return types are not changed, because
- * they may require special calling sequences.
- * A void return value is turned to int.
- */
- public MethodType primsAsInts() {
- MethodType ct = primsAsInts;
- if (ct != null) return ct;
- MethodType t = erasedType;
- ct = canonicalize(t, RAW_RETURN, INTS);
- if (ct == null) ct = t; // no prims to int-ify
- return primsAsInts = ct;
- }
-
- /** Turn all primitive types to either int or long.
- * Floating point return types are not changed, because
- * they may require special calling sequences.
- * A void return value is turned to int.
- */
- public MethodType primsAsLongs() {
- MethodType ct = primsAsLongs;
- if (ct != null) return ct;
- MethodType t = erasedType;
- ct = canonicalize(t, RAW_RETURN, LONGS);
- if (ct == null) ct = t; // no prims to int-ify
- return primsAsLongs = ct;
- }
-
- /** Stably sort parameters into 3 buckets: ref, int, long. */
- public MethodType primsAtEnd() {
- MethodType ct = primsAtEnd;
- if (ct != null) return ct;
- MethodType t = erasedType;
-
- int pac = primitiveParameterCount();
- if (pac == 0)
- return primsAtEnd = t;
-
- int argc = parameterCount();
- int lac = longPrimitiveParameterCount();
- if (pac == argc && (lac == 0 || lac == argc))
- return primsAtEnd = t;
-
- // known to have a mix of 2 or 3 of ref, int, long
- int[] reorder = primsAtEndOrder(t);
- ct = reorderParameters(t, reorder, null);
- //System.out.println("t="+t+" / reorder="+java.util.Arrays.toString(reorder)+" => "+ct);
- return primsAtEnd = ct;
- }
-
- /** Compute a new ordering of parameters so that all references
- * are before all ints or longs, and all ints are before all longs.
- * For this ordering, doubles count as longs, and all other primitive
- * values count as ints.
- * As a special case, if the parameters are already in the specified
- * order, this method returns a null reference, rather than an array
- * specifying a null permutation.
- * <p>
- * For example, the type {@code (int,boolean,int,Object,String)void}
- * produces the order {@code {3,4,0,1,2}}, the type
- * {@code (long,int,String)void} produces {@code {2,1,2}}, and
- * the type {@code (Object,int)Object} produces {@code null}.
- */
- public static int[] primsAtEndOrder(MethodType mt) {
- MethodTypeImpl form = METHOD_TYPE_FRIEND.form(mt);
- if (form.primsAtEnd == form.erasedType)
- // quick check shows no reordering is necessary
- return null;
-
- int argc = form.parameterCount();
- int[] paramOrder = new int[argc];
-
- // 3-way bucket sort:
- int pac = form.primitiveParameterCount();
- int lac = form.longPrimitiveParameterCount();
- int rfill = 0, ifill = argc - pac, lfill = argc - lac;
-
- Class<?>[] ptypes = METHOD_TYPE_FRIEND.ptypes(mt);
- boolean changed = false;
- for (int i = 0; i < ptypes.length; i++) {
- Class<?> pt = ptypes[i];
- int ord;
- if (!pt.isPrimitive()) ord = rfill++;
- else if (!hasTwoArgSlots(pt)) ord = ifill++;
- else ord = lfill++;
- if (ord != i) changed = true;
- assert(paramOrder[ord] == 0);
- paramOrder[ord] = i;
- }
- assert(rfill == argc - pac && ifill == argc - lac && lfill == argc);
- if (!changed) {
- form.primsAtEnd = form.erasedType;
- return null;
- }
- return paramOrder;
- }
-
- /** Put the existing parameters of mt into a new order, given by newParamOrder.
- * The third argument is logically appended to mt.parameterArray,
- * so that elements of newParamOrder can index either pre-existing or
- * new parameter types.
- */
- public static MethodType reorderParameters(MethodType mt, int[] newParamOrder, Class<?>[] moreParams) {
- if (newParamOrder == null) return mt; // no-op reordering
- Class<?>[] ptypes = METHOD_TYPE_FRIEND.ptypes(mt);
- Class<?>[] ntypes = new Class<?>[newParamOrder.length];
- int maxParam = ptypes.length + (moreParams == null ? 0 : moreParams.length);
- boolean changed = (ntypes.length != ptypes.length);
- for (int i = 0; i < newParamOrder.length; i++) {
- int param = newParamOrder[i];
- if (param != i) changed = true;
- Class<?> nt;
- if (param < ptypes.length) nt = ptypes[param];
- else if (param == maxParam) nt = mt.returnType();
- else nt = moreParams[param - ptypes.length];
- ntypes[i] = nt;
- }
- if (!changed) return mt;
- return METHOD_TYPE_FRIEND.makeImpl(mt.returnType(), ntypes, true);
- }
-
- private static boolean hasTwoArgSlots(Class<?> type) {
- return type == long.class || type == double.class;
- }
-
- private static long pack(int a, int b, int c, int d) {
- assert(((a|b|c|d) & ~0xFFFF) == 0);
- long hw = ((a << 16) | b), lw = ((c << 16) | d);
- return (hw << 32) | lw;
- }
- private static char unpack(long packed, int word) { // word==0 => return a, ==3 => return d
- assert(word <= 3);
- return (char)(packed >> ((3-word) * 16));
- }
-
- public int parameterCount() { // # outgoing values
- return unpack(argCounts, 3);
- }
- public int parameterSlotCount() { // # outgoing interpreter slots
- return unpack(argCounts, 2);
- }
- public int returnCount() { // = 0 (V), or 1
- return unpack(argCounts, 1);
- }
- public int returnSlotCount() { // = 0 (V), 2 (J/D), or 1
- return unpack(argCounts, 0);
- }
- public int primitiveParameterCount() {
- return unpack(primCounts, 3);
- }
- public int longPrimitiveParameterCount() {
- return unpack(primCounts, 2);
- }
- public int primitiveReturnCount() { // = 0 (obj), or 1
- return unpack(primCounts, 1);
- }
- public int longPrimitiveReturnCount() { // = 1 (J/D), or 0
- return unpack(primCounts, 0);
- }
- public boolean hasPrimitives() {
- return primCounts != 0;
- }
-// public boolean hasNonVoidPrimitives() {
-// if (primCounts == 0) return false;
-// if (primitiveParameterCount() != 0) return true;
-// return (primitiveReturnCount() != 0 && returnCount() != 0);
-// }
- public boolean hasLongPrimitives() {
- return (longPrimitiveParameterCount() | longPrimitiveReturnCount()) != 0;
- }
- public int parameterToArgSlot(int i) {
- return argToSlotTable[1+i];
- }
- public int argSlotToParameter(int argSlot) {
- // Note: Empty slots are represented by zero in this table.
- // Valid arguments slots contain incremented entries, so as to be non-zero.
- // We return -1 the caller to mean an empty slot.
- return slotToArgTable[argSlot] - 1;
- }
-
- public static void initForm(Access token, MethodType mt) {
- Access.check(token);
- MethodTypeImpl form = findForm(mt);
- METHOD_TYPE_FRIEND.setForm(mt, form);
- if (form.erasedType == mt) {
- // This is a principal (erased) type; show it to the JVM.
- MethodHandleImpl.init(token, mt);
- }
- }
-
- static MethodTypeImpl findForm(MethodType mt) {
- MethodType erased = canonicalize(mt, ERASE, ERASE);
- if (erased == null) {
- // It is already erased. Make a new MethodTypeImpl.
- return METHOD_TYPE_FRIEND.newMethodTypeForm(mt);
- } else {
- // Share the MethodTypeImpl with the erased version.
- return METHOD_TYPE_FRIEND.form(erased);
- }
- }
-
- /** Codes for {@link #canonicalize(java.lang.Class, int).
- * ERASE means change every reference to {@code Object}.
- * WRAP means convert primitives (including {@code void} to their
- * corresponding wrapper types. UNWRAP means the reverse of WRAP.
- * INTS means convert all non-void primitive types to int or long,
- * according to size. LONGS means convert all non-void primitives
- * to long, regardless of size. RAW_RETURN means convert a type
- * (assumed to be a return type) to int if it is smaller than an int,
- * or if it is void.
- */
- public static final int NO_CHANGE = 0, ERASE = 1, WRAP = 2, UNWRAP = 3, INTS = 4, LONGS = 5, RAW_RETURN = 6;
-
- /** Canonicalize the types in the given method type.
- * If any types change, intern the new type, and return it.
- * Otherwise return null.
- */
- public static MethodType canonicalize(MethodType mt, int howRet, int howArgs) {
- Class<?>[] ptypes = METHOD_TYPE_FRIEND.ptypes(mt);
- Class<?>[] ptc = MethodTypeImpl.canonicalizes(ptypes, howArgs);
- Class<?> rtype = mt.returnType();
- Class<?> rtc = MethodTypeImpl.canonicalize(rtype, howRet);
- if (ptc == null && rtc == null) {
- // It is already canonical.
- return null;
- }
- // Find the erased version of the method type:
- if (rtc == null) rtc = rtype;
- if (ptc == null) ptc = ptypes;
- return METHOD_TYPE_FRIEND.makeImpl(rtc, ptc, true);
- }
-
- /** Canonicalize the given return or param type.
- * Return null if the type is already canonicalized.
- */
- static Class<?> canonicalize(Class<?> t, int how) {
- Class<?> ct;
- if (t == Object.class) {
- // no change, ever
- } else if (!t.isPrimitive()) {
- switch (how) {
- case UNWRAP:
- ct = Wrapper.asPrimitiveType(t);
- if (ct != t) return ct;
- break;
- case RAW_RETURN:
- case ERASE:
- return Object.class;
- }
- } else if (t == void.class) {
- // no change, usually
- switch (how) {
- case RAW_RETURN:
- return int.class;
- case WRAP:
- return Void.class;
- }
- } else {
- // non-void primitive
- switch (how) {
- case WRAP:
- return Wrapper.asWrapperType(t);
- case INTS:
- if (t == int.class || t == long.class)
- return null; // no change
- if (t == double.class)
- return long.class;
- return int.class;
- case LONGS:
- if (t == long.class)
- return null; // no change
- return long.class;
- case RAW_RETURN:
- if (t == int.class || t == long.class ||
- t == float.class || t == double.class)
- return null; // no change
- // everything else returns as an int
- return int.class;
- }
- }
- // no change; return null to signify
- return null;
- }
-
- /** Canonicalize each param type in the given array.
- * Return null if all types are already canonicalized.
- */
- static Class<?>[] canonicalizes(Class<?>[] ts, int how) {
- Class<?>[] cs = null;
- for (int imax = ts.length, i = 0; i < imax; i++) {
- Class<?> c = canonicalize(ts[i], how);
- if (c != null) {
- if (cs == null)
- cs = ts.clone();
- cs[i] = c;
- }
- }
- return cs;
- }
-
- public static Invokers invokers(Access token, MethodType type) {
- Access.check(token);
- return invokers(type);
- }
- /*non-public*/ static Invokers invokers(MethodType type) {
- Invokers inv = METHOD_TYPE_FRIEND.getInvokers(type);
- if (inv != null) return inv;
- inv = new Invokers(type);
- METHOD_TYPE_FRIEND.setInvokers(type, inv);
- return inv;
- }
-
- @Override
- public String toString() {
- return "Form"+erasedType;
- }
-
-}
--- a/jdk/src/share/classes/sun/dyn/SpreadGeneric.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,678 +0,0 @@
-/*
- * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
-import sun.dyn.util.ValueConversions;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-
-/**
- * Generic spread adapter.
- * Expands a final argument into multiple (zero or more) arguments, keeping the others the same.
- * @author jrose
- */
-class SpreadGeneric {
- // type for the outgoing call
- private final MethodType targetType;
- // number of arguments to spread
- private final int spreadCount;
- // prototype adapter (clone and customize for each new target!)
- private final Adapter adapter;
- // entry point for adapter (Adapter mh, a...) => ...
- private final MethodHandle entryPoint;
-
- /** Compute and cache information common to all spreading adapters
- * that accept calls of the given (generic) type.
- */
- private SpreadGeneric(MethodType targetType, int spreadCount) {
- assert(targetType == targetType.generic());
- this.targetType = targetType;
- this.spreadCount = spreadCount;
- // the target invoker will generally need casts on reference arguments
- MethodHandle[] ep = { null };
- Adapter ad = findAdapter(this, ep);
- if (ad != null) {
- this.adapter = ad;
- this.entryPoint = ep[0];
- return;
- }
- this.adapter = buildAdapterFromBytecodes(targetType, spreadCount, ep);
- this.entryPoint = ep[0];
- }
-
- /** From targetType remove the last spreadCount arguments, and instead
- * append a simple Object argument.
- */
- static MethodType preSpreadType(MethodType targetType, int spreadCount) {
- @SuppressWarnings("unchecked")
- ArrayList<Class<?>> params = new ArrayList(targetType.parameterList());
- int outargs = params.size();
- params.subList(outargs - spreadCount, outargs).clear();
- params.add(Object.class);
- return MethodType.methodType(targetType.returnType(), params);
- }
-
- MethodHandle makeInstance(MethodHandle target) {
- MethodType type = target.type();
- if (type != targetType) {
- throw new UnsupportedOperationException("NYI type="+type);
- }
- return adapter.makeInstance(this, target);
- }
-
- /** Build an adapter of the given generic type, which invokes typedTarget
- * on the incoming arguments, after unboxing as necessary.
- * The return value is boxed if necessary.
- * @param genericType the required type of the result
- * @param typedTarget the target
- * @return an adapter method handle
- */
- public static MethodHandle make(MethodHandle target, int spreadCount) {
- MethodType type = target.type();
- MethodType gtype = type.generic();
- if (type == gtype) {
- return SpreadGeneric.of(type, spreadCount).makeInstance(target);
- } else {
- MethodHandle gtarget = FromGeneric.make(target);
- assert(gtarget.type() == gtype);
- MethodHandle gspread = SpreadGeneric.of(gtype, spreadCount).makeInstance(gtarget);
- return ToGeneric.make(preSpreadType(type, spreadCount), gspread);
- }
- }
-
- /** Return the adapter information for this type's erasure. */
- static SpreadGeneric of(MethodType targetType, int spreadCount) {
- if (targetType != targetType.generic())
- throw new UnsupportedOperationException("NYI type="+targetType);
- MethodTypeImpl form = MethodTypeImpl.of(targetType);
- int outcount = form.parameterCount();
- assert(spreadCount <= outcount);
- SpreadGeneric[] spreadGens = form.spreadGeneric;
- if (spreadGens == null)
- form.spreadGeneric = spreadGens = new SpreadGeneric[outcount+1];
- SpreadGeneric spreadGen = spreadGens[spreadCount];
- if (spreadGen == null)
- spreadGens[spreadCount] = spreadGen = new SpreadGeneric(form.erasedType(), spreadCount);
- return spreadGen;
- }
-
- public String toString() {
- return getClass().getSimpleName()+targetType+"["+spreadCount+"]";
- }
-
- // This mini-api is called from an Adapter to manage the spread.
- /** A check/coercion that happens once before any selections. */
- protected Object check(Object av, int n) {
- MethodHandleImpl.checkSpreadArgument(av, n);
- return av;
- }
-
- /** The selection operator for spreading; note that it takes Object not Object[]. */
- protected Object select(Object av, int n) {
- return ((Object[])av)[n];
- }
- /*
- protected int select_I(Object av, int n) {
- // maybe return ((int[])select)[n]
- throw new UnsupportedOperationException("subclass resp.");
- }
- protected int select_J(Object av, int n) {
- // maybe return ((long[])select)[n]
- throw new UnsupportedOperationException("subclass resp.");
- }
- // */
-
- /* Create an adapter that handles spreading calls for the given type. */
- static Adapter findAdapter(SpreadGeneric outer, MethodHandle[] ep) {
- MethodType targetType = outer.targetType;
- int spreadCount = outer.spreadCount;
- int outargs = targetType.parameterCount();
- int inargs = outargs - spreadCount;
- if (inargs < 0) return null;
- MethodType entryType = MethodType.genericMethodType(inargs + 1); // 1 for av
- String cname1 = "S" + outargs;
- String[] cnames = { cname1 };
- String iname = "invoke_S"+spreadCount;
- // e.g., D5I2, D5, L5I2, L5; invoke_D5
- for (String cname : cnames) {
- Class<? extends Adapter> acls = Adapter.findSubClass(cname);
- if (acls == null) continue;
- // see if it has the required invoke method
- MethodHandle entryPoint = null;
- try {
- entryPoint = MethodHandleImpl.IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
- } catch (ReflectiveOperationException ex) {
- }
- if (entryPoint == null) continue;
- Constructor<? extends Adapter> ctor = null;
- try {
- ctor = acls.getDeclaredConstructor(SpreadGeneric.class);
- } catch (NoSuchMethodException ex) {
- } catch (SecurityException ex) {
- }
- if (ctor == null) continue;
- try {
- // Produce an instance configured as a prototype.
- Adapter ad = ctor.newInstance(outer);
- ep[0] = entryPoint;
- return ad;
- } catch (IllegalArgumentException ex) {
- } catch (InvocationTargetException wex) {
- Throwable ex = wex.getTargetException();
- if (ex instanceof Error) throw (Error)ex;
- if (ex instanceof RuntimeException) throw (RuntimeException)ex;
- } catch (InstantiationException ex) {
- } catch (IllegalAccessException ex) {
- }
- }
- return null;
- }
-
- static Adapter buildAdapterFromBytecodes(MethodType targetType,
- int spreadCount, MethodHandle[] ep) {
- throw new UnsupportedOperationException("NYI");
- }
-
- /**
- * This adapter takes some untyped arguments, and returns an untyped result.
- * Internally, it applies the invoker to the target, which causes the
- * objects to be unboxed; the result is a raw type in L/I/J/F/D.
- * This result is passed to convert, which is responsible for
- * converting the raw result into a boxed object.
- * The invoker is kept separate from the target because it can be
- * generated once per type erasure family, and reused across adapters.
- */
- static abstract class Adapter extends BoundMethodHandle {
- /*
- * class X<<R,int M,int N>> extends Adapter {
- * (Object**N)=>R target;
- * static int S = N-M;
- * Object invoke(Object**M a, Object v) = target(a..., v[0]...v[S-1]);
- * }
- */
- protected final SpreadGeneric outer;
- protected final MethodHandle target; // (any**N) => R
-
- @Override
- public String toString() {
- return MethodHandleImpl.addTypeString(target, this);
- }
-
- static final MethodHandle NO_ENTRY = ValueConversions.identity();
-
- protected boolean isPrototype() { return target == null; }
- protected Adapter(SpreadGeneric outer) {
- super(Access.TOKEN, NO_ENTRY);
- this.outer = outer;
- this.target = null;
- assert(isPrototype());
- }
-
- protected Adapter(SpreadGeneric outer, MethodHandle target) {
- super(Access.TOKEN, outer.entryPoint);
- this.outer = outer;
- this.target = target;
- }
-
- /** Make a copy of self, with new fields. */
- protected abstract Adapter makeInstance(SpreadGeneric outer, MethodHandle target);
- // { return new ThisType(outer, target); }
-
- protected Object check(Object av, int n) {
- return outer.check(av, n);
- }
- protected Object select(Object av, int n) {
- return outer.select(av, n);
- }
-
- static private final String CLASS_PREFIX; // "sun.dyn.SpreadGeneric$"
- static {
- String aname = Adapter.class.getName();
- String sname = Adapter.class.getSimpleName();
- if (!aname.endsWith(sname)) throw new InternalError();
- CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
- }
- /** Find a sibing class of Adapter. */
- static Class<? extends Adapter> findSubClass(String name) {
- String cname = Adapter.CLASS_PREFIX + name;
- try {
- return Class.forName(cname).asSubclass(Adapter.class);
- } catch (ClassNotFoundException ex) {
- return null;
- } catch (ClassCastException ex) {
- return null;
- }
- }
- }
-
- /* generated classes follow this pattern:
- static class xS2 extends Adapter {
- protected xS2(SpreadGeneric outer) { super(outer); } // to build prototype
- protected xS2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected xS2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new xS2(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av,0);
- return target.invokeExact(a0, a1)); }
- protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av,1);
- return target.invokeExact(a0,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av,1);
- return target.invokeExact(
- super.select(av,0), super.select(av,1)); }
- }
- // */
-
-/*
-: SHELL; n=SpreadGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
-//{{{
-import java.util.*;
-class genclasses {
- static String[][] TEMPLATES = { {
- "@for@ N=0..10",
- " //@each-cat@",
- " static class @cat@ extends Adapter {",
- " protected @cat@(SpreadGeneric outer) { super(outer); } // to build prototype",
- " protected @cat@(SpreadGeneric outer, MethodHandle t) { super(outer, t); }",
- " protected @cat@ makeInstance(SpreadGeneric outer, MethodHandle t) { return new @cat@(outer, t); }",
- " protected Object invoke_S0(@Tvav,@Object av) throws Throwable { av = super.check(av, 0);",
- " return target.invokeExact(@av@); }",
- " //@each-S@",
- " protected Object invoke_S@S@(@Tvav,@Object av) throws Throwable { av = super.check(av, @S@);",
- " return target.invokeExact(@av,@@sv@); }",
- " //@end-S@",
- " }",
- } };
- static final String NEWLINE_INDENT = "\n ";
- enum VAR {
- cat, N, S, av, av_, Tvav_, sv;
- public final String pattern = "@"+toString().replace('_','.')+"@";
- public String binding = toString();
- static void makeBindings(boolean topLevel, int outargs, int spread) {
- int inargs = outargs - spread;
- VAR.cat.binding = "S"+outargs;
- VAR.N.binding = String.valueOf(outargs); // outgoing arg count
- VAR.S.binding = String.valueOf(spread); // spread count
- String[] av = new String[inargs];
- String[] Tvav = new String[inargs];
- for (int i = 0; i < inargs; i++) {
- av[i] = arg(i);
- Tvav[i] = param("Object", av[i]);
- }
- VAR.av.binding = comma(av);
- VAR.av_.binding = comma(av, ", ");
- VAR.Tvav_.binding = comma(Tvav, ", ");
- String[] sv = new String[spread];
- for (int i = 0; i < spread; i++) {
- String spc = "";
- if (i % 4 == 0) spc = NEWLINE_INDENT;
- sv[i] = spc+"super.select(av,"+i+")";
- }
- VAR.sv.binding = comma(sv);
- }
- static String arg(int i) { return "a"+i; }
- static String param(String t, String a) { return t+" "+a; }
- static String comma(String[] v) { return comma(v, ""); }
- static String comma(String[] v, String sep) {
- if (v.length == 0) return "";
- String res = v[0];
- for (int i = 1; i < v.length; i++) res += ", "+v[i];
- return res + sep;
- }
- static String transform(String string) {
- for (VAR var : values())
- string = string.replaceAll(var.pattern, var.binding);
- return string;
- }
- }
- static String[] stringsIn(String[] strings, int beg, int end) {
- return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
- }
- static String[] stringsBefore(String[] strings, int pos) {
- return stringsIn(strings, 0, pos);
- }
- static String[] stringsAfter(String[] strings, int pos) {
- return stringsIn(strings, pos, strings.length);
- }
- static int indexAfter(String[] strings, int pos, String tag) {
- return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
- }
- static int indexBefore(String[] strings, int pos, String tag) {
- for (int i = pos, end = strings.length; ; i++) {
- if (i == end || strings[i].endsWith(tag)) return i;
- }
- }
- static int MIN_ARITY, MAX_ARITY;
- public static void main(String... av) {
- for (String[] template : TEMPLATES) {
- int forLinesLimit = indexBefore(template, 0, "@each-cat@");
- String[] forLines = stringsBefore(template, forLinesLimit);
- template = stringsAfter(template, forLinesLimit);
- for (String forLine : forLines)
- expandTemplate(forLine, template);
- }
- }
- static void expandTemplate(String forLine, String[] template) {
- String[] params = forLine.split("[^0-9]+");
- if (params[0].length() == 0) params = stringsAfter(params, 1);
- System.out.println("//params="+Arrays.asList(params));
- int pcur = 0;
- MIN_ARITY = Integer.valueOf(params[pcur++]);
- MAX_ARITY = Integer.valueOf(params[pcur++]);
- if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
- for (int outargs = MIN_ARITY; outargs <= MAX_ARITY; outargs++) {
- expandTemplate(template, true, outargs, 0);
- }
- }
- static void expandTemplate(String[] template, boolean topLevel, int outargs, int spread) {
- VAR.makeBindings(topLevel, outargs, spread);
- for (int i = 0; i < template.length; i++) {
- String line = template[i];
- if (line.endsWith("@each-cat@")) {
- // ignore
- } else if (line.endsWith("@each-S@")) {
- int blockEnd = indexAfter(template, i, "@end-S@");
- String[] block = stringsIn(template, i+1, blockEnd-1);
- for (int spread1 = spread+1; spread1 <= outargs; spread1++)
- expandTemplate(block, false, outargs, spread1);
- VAR.makeBindings(topLevel, outargs, spread);
- i = blockEnd-1; continue;
- } else {
- System.out.println(VAR.transform(line));
- }
- }
- }
-}
-//}}} */
-//params=[0, 10]
- static class S0 extends Adapter {
- protected S0(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S0(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S0 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S0(outer, t); }
- protected Object invoke_S0(Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(); }
- }
- static class S1 extends Adapter {
- protected S1(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S1(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S1 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S1(outer, t); }
- protected Object invoke_S0(Object a0, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0); }
- protected Object invoke_S1(Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(
- super.select(av,0)); }
- }
- static class S2 extends Adapter {
- protected S2(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S2(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1); }
- protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0,
- super.select(av,0)); }
- protected Object invoke_S2(Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(
- super.select(av,0), super.select(av,1)); }
- }
- static class S3 extends Adapter {
- protected S3(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S3(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S3 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S3(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2); }
- protected Object invoke_S1(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- }
- static class S4 extends Adapter {
- protected S4(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S4(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S4 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S4(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2, a3); }
- protected Object invoke_S1(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1, a2,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0, a1,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object a0, Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- protected Object invoke_S4(Object av) throws Throwable { av = super.check(av, 4);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
- }
- static class S5 extends Adapter {
- protected S5(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S5(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S5 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S5(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2, a3, a4); }
- protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1, a2, a3,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0, a1, a2,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(a0, a1,
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- protected Object invoke_S4(Object a0, Object av) throws Throwable { av = super.check(av, 4);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
- protected Object invoke_S5(Object av) throws Throwable { av = super.check(av, 5);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4)); }
- }
- static class S6 extends Adapter {
- protected S6(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S6(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S6 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S6(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2, a3, a4, a5); }
- protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1, a2, a3, a4,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0, a1, a2, a3,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(a0, a1, a2,
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- protected Object invoke_S4(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 4);
- return target.invokeExact(a0, a1,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
- protected Object invoke_S5(Object a0, Object av) throws Throwable { av = super.check(av, 5);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4)); }
- protected Object invoke_S6(Object av) throws Throwable { av = super.check(av, 6);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5)); }
- }
- static class S7 extends Adapter {
- protected S7(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S7(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S7 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S7(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1, a2, a3, a4, a5,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0, a1, a2, a3, a4,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(a0, a1, a2, a3,
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- protected Object invoke_S4(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 4);
- return target.invokeExact(a0, a1, a2,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
- protected Object invoke_S5(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 5);
- return target.invokeExact(a0, a1,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4)); }
- protected Object invoke_S6(Object a0, Object av) throws Throwable { av = super.check(av, 6);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5)); }
- protected Object invoke_S7(Object av) throws Throwable { av = super.check(av, 7);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6)); }
- }
- static class S8 extends Adapter {
- protected S8(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S8(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S8 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S8(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0, a1, a2, a3, a4, a5,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(a0, a1, a2, a3, a4,
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 4);
- return target.invokeExact(a0, a1, a2, a3,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
- protected Object invoke_S5(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 5);
- return target.invokeExact(a0, a1, a2,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4)); }
- protected Object invoke_S6(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 6);
- return target.invokeExact(a0, a1,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5)); }
- protected Object invoke_S7(Object a0, Object av) throws Throwable { av = super.check(av, 7);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6)); }
- protected Object invoke_S8(Object av) throws Throwable { av = super.check(av, 8);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
- }
- static class S9 extends Adapter {
- protected S9(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S9(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S9 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S9(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(a0, a1, a2, a3, a4, a5,
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 4);
- return target.invokeExact(a0, a1, a2, a3, a4,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
- protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 5);
- return target.invokeExact(a0, a1, a2, a3,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4)); }
- protected Object invoke_S6(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 6);
- return target.invokeExact(a0, a1, a2,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5)); }
- protected Object invoke_S7(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 7);
- return target.invokeExact(a0, a1,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6)); }
- protected Object invoke_S8(Object a0, Object av) throws Throwable { av = super.check(av, 8);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
- protected Object invoke_S9(Object av) throws Throwable { av = super.check(av, 9);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
- super.select(av,8)); }
- }
- static class S10 extends Adapter {
- protected S10(SpreadGeneric outer) { super(outer); } // to build prototype
- protected S10(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
- protected S10 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S10(outer, t); }
- protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9, Object av) throws Throwable { av = super.check(av, 0);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object av) throws Throwable { av = super.check(av, 1);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7, a8,
- super.select(av,0)); }
- protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object av) throws Throwable { av = super.check(av, 2);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7,
- super.select(av,0), super.select(av,1)); }
- protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object av) throws Throwable { av = super.check(av, 3);
- return target.invokeExact(a0, a1, a2, a3, a4, a5, a6,
- super.select(av,0), super.select(av,1), super.select(av,2)); }
- protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object av) throws Throwable { av = super.check(av, 4);
- return target.invokeExact(a0, a1, a2, a3, a4, a5,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
- protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 5);
- return target.invokeExact(a0, a1, a2, a3, a4,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4)); }
- protected Object invoke_S6(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 6);
- return target.invokeExact(a0, a1, a2, a3,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5)); }
- protected Object invoke_S7(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 7);
- return target.invokeExact(a0, a1, a2,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6)); }
- protected Object invoke_S8(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 8);
- return target.invokeExact(a0, a1,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
- protected Object invoke_S9(Object a0, Object av) throws Throwable { av = super.check(av, 9);
- return target.invokeExact(a0,
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
- super.select(av,8)); }
- protected Object invoke_S10(Object av) throws Throwable { av = super.check(av, 10);
- return target.invokeExact(
- super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
- super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
- super.select(av,8), super.select(av,9)); }
- }
-}
--- a/jdk/src/share/classes/sun/dyn/ToGeneric.java Thu Mar 17 14:33:00 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1042 +0,0 @@
-/*
- * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package sun.dyn;
-
-import java.dyn.*;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import sun.dyn.util.ValueConversions;
-import sun.dyn.util.Wrapper;
-import static sun.dyn.MemberName.newIllegalArgumentException;
-import static sun.dyn.MethodTypeImpl.invokers;
-
-/**
- * Adapters which mediate between incoming calls which are not generic
- * and outgoing calls which are. Any call can be represented generically
- * boxing up its arguments, and (on return) unboxing the return value.
- * <p>
- * A call is "generic" (in MethodHandle terms) if its MethodType features
- * only Object arguments. A non-generic call therefore features
- * primitives and/or reference types other than Object.
- * An adapter has types for its incoming and outgoing calls.
- * The incoming call type is simply determined by the adapter's type
- * (the MethodType it presents to callers). The outgoing call type
- * is determined by the adapter's target (a MethodHandle that the adapter
- * either binds internally or else takes as a leading argument).
- * (To stretch the term, adapter-like method handles may have multiple
- * targets or be polymorphic across multiple call types.)
- * @author jrose
- */
-class ToGeneric {
- // type for the incoming call (may be erased)
- private final MethodType entryType;
- // incoming type with primitives moved to the end and turned to int/long
- private final MethodType rawEntryType;
- // adapter for the erased type
- private final Adapter adapter;
- // entry point for adapter (Adapter mh, a...) => ...
- private final MethodHandle entryPoint;
- // permutation of arguments for primsAtEndType
- private final int[] primsAtEndOrder;
- // optional final argument list conversions (at least, invokes the target)
- private final MethodHandle invoker;
- // conversion which unboxes a primitive return value
- private final MethodHandle returnConversion;
-
- /** Compute and cache information common to all generifying (boxing) adapters
- * that implement members of the erasure-family of the given erased type.
- */
- private ToGeneric(MethodType entryType) {
- assert(entryType.erase() == entryType); // for now
- // incoming call will first "forget" all reference types except Object
- this.entryType = entryType;
- MethodHandle invoker0 = invokers(entryType.generic()).exactInvoker();
- MethodType rawEntryTypeInit;
- Adapter ad = findAdapter(rawEntryTypeInit = entryType);
- if (ad != null) {
- // Immediate hit to exactly the adapter we want,
- // with no monkeying around with primitive types.
- this.returnConversion = computeReturnConversion(entryType, rawEntryTypeInit, false);
- this.rawEntryType = rawEntryTypeInit;
- this.adapter = ad;
- this.entryPoint = ad.prototypeEntryPoint();
- this.primsAtEndOrder = null;
- this.invoker = invoker0;
- return;
- }
-
- // next, it will reorder primitives after references
- MethodType primsAtEnd = MethodTypeImpl.of(entryType).primsAtEnd();
- // at the same time, it will "forget" all primitive types except int/long
- this.primsAtEndOrder = MethodTypeImpl.primsAtEndOrder(entryType);
- if (primsAtEndOrder != null) {
- // reordering is required; build on top of a simpler ToGeneric
- ToGeneric va2 = ToGeneric.of(primsAtEnd);
- this.adapter = va2.adapter;
- if (true) throw new UnsupportedOperationException("NYI: primitive parameters must follow references; entryType = "+entryType);
- this.entryPoint = MethodHandleImpl.convertArguments(Access.TOKEN,
- va2.entryPoint, primsAtEnd, entryType, primsAtEndOrder);
- // example: for entryType of (int,Object,Object), the reordered
- // type is (Object,Object,int) and the order is {1,2,0},
- // and putPAE is (mh,int0,obj1,obj2) => mh.invokeExact(obj1,obj2,int0)
- return;
- }
-
- // after any needed argument reordering, it will reinterpret
- // primitive arguments according to their "raw" types int/long
- MethodType intsAtEnd = MethodTypeImpl.of(primsAtEnd).primsAsInts();
- ad = findAdapter(rawEntryTypeInit = intsAtEnd);
- MethodHandle rawEntryPoint;
- if (ad != null) {
- rawEntryPoint = ad.prototypeEntryPoint();
- } else {
- // Perhaps the adapter is available only for longs.
- // If so, we can use it, but there will have to be a little
- // more stack motion on each call.
- MethodType longsAtEnd = MethodTypeImpl.of(primsAtEnd).primsAsLongs();
- ad = findAdapter(rawEntryTypeInit = longsAtEnd);
- if (ad != null) {
- MethodType eptWithLongs = longsAtEnd.insertParameterTypes(0, ad.getClass());
- MethodType eptWithInts = intsAtEnd.insertParameterTypes(0, ad.getClass());
- rawEntryPoint = ad.prototypeEntryPoint();
- MethodType midType = eptWithLongs; // will change longs to ints
- for (int i = 0, nargs = midType.parameterCount(); i < nargs; i++) {
- if (midType.parameterType(i) != eptWithInts.parameterType(i)) {
- assert(midType.parameterType(i) == long.class);
- assert(eptWithInts.parameterType(i) == int.class);
- MethodType nextType = midType.changeParameterType(i, int.class);
- rawEntryPoint = MethodHandle.convertArguments(Access.TOKEN,
- rawEntryPoint, nextType, midType, null);
- midType = nextType;
- }
- }
- assert(midType == eptWithInts);
- } else {
- // If there is no statically compiled adapter,
- // build one by means of dynamic bytecode generation.
- ad = buildAdapterFromBytecodes(rawEntryTypeInit = intsAtEnd);
- rawEntryPoint = ad.prototypeEntryPoint();
- }
- }
- MethodType tepType = entryType.insertParameterTypes(0, ad.getClass());
- this.entryPoint =
- AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, tepType, rawEntryPoint);
- if (this.entryPoint == null)
- throw new UnsupportedOperationException("cannot retype to "+entryType
- +" from "+rawEntryPoint.type().dropParameterTypes(0, 1));
- this.returnConversion = computeReturnConversion(entryType, rawEntryTypeInit, false);
- this.rawEntryType = rawEntryTypeInit;
- this.adapter = ad;
- this.invoker = makeRawArgumentFilter(invoker0, rawEntryTypeInit, entryType);
- }
-
- /** A generic argument list will be created by a call of type 'raw'.
- * The values need to be reboxed for to match 'cooked'.
- * Do this on the fly.
- */
- // TO DO: Use a generic argument converter in a different file
- static MethodHandle makeRawArgumentFilter(MethodHandle invoker,
- MethodType raw, MethodType cooked) {
- MethodHandle filteredInvoker = null;
- for (int i = 0, nargs = raw.parameterCount(); i < nargs; i++) {
- Class<?> src = raw.parameterType(i);
- Class<?> dst = cooked.parameterType(i);
- if (src == dst) continue;
- assert(src.isPrimitive() && dst.isPrimitive());
- if (filteredInvoker == null) {
- filteredInvoker =
- AdapterMethodHandle.makeCheckCast(Access.TOKEN,
- invoker.type().generic(), invoker, 0, MethodHandle.class);
- if (filteredInvoker == null) throw new UnsupportedOperationException("NYI");
- }
- MethodHandle reboxer = ValueConversions.rebox(dst, false);
- filteredInvoker = FilterGeneric.makeArgumentFilter(1+i, reboxer, filteredInvoker);
- if (filteredInvoker == null) throw new InternalError();
- }
- if (filteredInvoker == null) return invoker;
- return AdapterMethodHandle.makeRetypeOnly(Access.TOKEN, invoker.type(), filteredInvoker);
- }
-
- /**
- * Caller will be expecting a result from a call to {@code type},
- * while the internal adapter entry point is rawEntryType.
- * Also, the internal target method will be returning a boxed value,
- * as an untyped object.
- * <p>
- * Produce a value converter which will be typed to convert from
- * {@code Object} to the return value of {@code rawEntryType}, and will
- * in fact ensure that the value is compatible with the return type of
- * {@code type}.
- */
- private static MethodHandle computeReturnConversion(
- MethodType type, MethodType rawEntryType, boolean mustCast) {
- Class<?> tret = type.returnType();
- Class<?> rret = rawEntryType.returnType();
- if (mustCast || !tret.isPrimitive()) {
- assert(!tret.isPrimitive());
- assert(!rret.isPrimitive());
- if (rret == Object.class && !mustCast)
- return null;
- return ValueConversions.cast(tret, false);
- } else if (tret == rret) {
- return ValueConversions.unbox(tret, false);
- } else {
- assert(rret.isPrimitive());
- assert(tret == double.class ? rret == long.class : rret == int.class);
- return ValueConversions.unboxRaw(tret, false);
- }
- }
-
- Adapter makeInstance(MethodType type, MethodHandle genericTarget) {
- genericTarget.getClass(); // check for NPE
- MethodHandle convert = returnConversion;
- if (primsAtEndOrder != null)
- // reorder arguments passed to genericTarget, if primsAtEndOrder
- throw new UnsupportedOperationException("NYI");
- if (type == entryType) {
- if (convert == null) convert = ValueConversions.identity();
- return adapter.makeInstance(entryPoint, invoker, convert, genericTarget);
- }
- // my erased-type is not exactly the same as the desired type
- assert(type.erase() == entryType); // else we are busted
- if (convert == null)
- convert = computeReturnConversion(type, rawEntryType, true);
- // retype erased reference arguments (the cast makes it safe to do this)
- MethodType tepType = type.insertParameterTypes(0, adapter.getClass());
- MethodHandle typedEntryPoint =
- AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, tepType, entryPoint);
- return adapter.makeInstance(typedEntryPoint, invoker, convert, genericTarget);
- }
-
- /** Build an adapter of the given type, which invokes genericTarget
- * on the incoming arguments, after boxing as necessary.
- * The return value is unboxed if necessary.
- * @param type the required type of the
- * @param genericTarget the target, which must accept and return only Object values
- * @return an adapter method handle
- */
- public static MethodHandle make(MethodType type, MethodHandle genericTarget) {
- MethodType gtype = genericTarget.type();
- if (type.generic() != gtype)
- throw newIllegalArgumentException("type must be generic");
- if (type == gtype) return genericTarget;
- return ToGeneric.of(type).makeInstance(type, genericTarget);
- }
-
- /** Return the adapter information for this type's erasure. */
- static ToGeneric of(MethodType type) {
- MethodTypeImpl form = MethodTypeImpl.of(type);
- ToGeneric toGen = form.toGeneric;
- if (toGen == null)
- form.toGeneric = toGen = new ToGeneric(form.erasedType());
- return toGen;
- }
-
- public String toString() {
- return "ToGeneric"+entryType
- +(primsAtEndOrder!=null?"[reorder]":"");
- }
-
- /* Create an adapter for the given incoming call type. */
- static Adapter findAdapter(MethodType entryPointType) {
- MethodTypeImpl form = MethodTypeImpl.of(entryPointType);
- Class<?> rtype = entryPointType.returnType();
- int argc = form.parameterCount();
- int lac = form.longPrimitiveParameterCount();
- int iac = form.primitiveParameterCount() - lac;
- String intsAndLongs = (iac > 0 ? "I"+iac : "")+(lac > 0 ? "J"+lac : "");
- String rawReturn = String.valueOf(Wrapper.forPrimitiveType(rtype).basicTypeChar());
- String iname0 = "invoke_"+rawReturn;
- String iname1 = "invoke";
- String[] inames = { iname0, iname1 };
- String cname0 = rawReturn + argc;
- String cname1 = "A" + argc;
- String[] cnames = { cname1, cname1+intsAndLongs, cname0, cname0+intsAndLongs };
- // e.g., D5I2, D5, L5I2, L5
- for (String cname : cnames) {
- Class<? extends Adapter> acls = Adapter.findSubClass(cname);
- if (acls == null) continue;
- // see if it has the required invoke method
- for (String iname : inames) {
- MethodHandle entryPoint = null;
- try {
- entryPoint = MethodHandleImpl.IMPL_LOOKUP.
- findSpecial(acls, iname, entryPointType, acls);
- } catch (ReflectiveOperationException ex) {
- }
- if (entryPoint == null) continue;
- Constructor<? extends Adapter> ctor = null;
- try {
- // Prototype builder:
- ctor = acls.getDeclaredConstructor(MethodHandle.class);
- } catch (NoSuchMethodException ex) {
- } catch (SecurityException ex) {
- }
- if (ctor == null) continue;
- try {
- return ctor.newInstance(entryPoint);
- } catch (IllegalArgumentException ex) {
- } catch (InvocationTargetException wex) {
- Throwable ex = wex.getTargetException();
- if (ex instanceof Error) throw (Error)ex;
- if (ex instanceof RuntimeException) throw (RuntimeException)ex;
- } catch (InstantiationException ex) {
- } catch (IllegalAccessException ex) {
- }
- }
- }
- return null;
- }
-
- static Adapter buildAdapterFromBytecodes(MethodType entryPointType) {
- throw new UnsupportedOperationException("NYI");
- }
-
- /**
- * The invoke method takes some particular but unconstrained spread
- * of raw argument types, and returns a raw return type (in L/I/J/F/D).
- * Internally, it converts the incoming arguments uniformly into objects.
- * This series of objects is then passed to the {@code target} method,
- * which returns a result object. This result is finally converted,
- * via another method handle {@code convert}, which is responsible for
- * converting the object result into the raw return value.
- */
- static abstract class Adapter extends BoundMethodHandle {
- /*
- * class X<<R,A...>> extends Adapter {
- * Object...=>Object target;
- * Object=>R convert;
- * R invoke(A... a...) = convert(invoker(target, a...)))
- * }
- */
- protected final MethodHandle invoker; // (MH, Object...) -> Object
- protected final MethodHandle target; // Object... -> Object
- protected final MethodHandle convert; // Object -> R
-
- @Override
- public String toString() {
- return target == null ? "prototype:"+convert : MethodHandleImpl.addTypeString(target, this);
- }
-
- protected boolean isPrototype() { return target == null; }
- /* Prototype constructor. */
- protected Adapter(MethodHandle entryPoint) {
- super(Access.TOKEN, entryPoint);
- this.invoker = null;
- this.convert = entryPoint;
- this.target = null;
- assert(isPrototype());
- }
- protected MethodHandle prototypeEntryPoint() {
- if (!isPrototype()) throw new InternalError();
- return convert;
- }
-
- protected Adapter(MethodHandle entryPoint, MethodHandle invoker, MethodHandle convert, MethodHandle target) {
- super(Access.TOKEN, entryPoint);
- this.invoker = invoker;
- this.convert = convert;
- this.target = target;
- }
-
- /** Make a copy of self, with new fields. */
- protected abstract Adapter makeInstance(MethodHandle entryPoint,
- MethodHandle invoker, MethodHandle convert, MethodHandle target);
- // { return new ThisType(entryPoint, convert, target); }
-
- // Code to run when the arguments (<= 4) have all been boxed.
- protected Object target() throws Throwable { return invoker.invokeExact(target); }
- protected Object target(Object a0) throws Throwable { return invoker.invokeExact(target, a0); }
- protected Object target(Object a0, Object a1)
- throws Throwable { return invoker.invokeExact(target, a0, a1); }
- protected Object target(Object a0, Object a1, Object a2)
- throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
- protected Object target(Object a0, Object a1, Object a2, Object a3)
- throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
- /*
- protected Object target_0(Object... av) throws Throwable { return invoker.invokeExact(target, av); }
- protected Object target_1(Object a0, Object... av)
- throws Throwable { return invoker.invokeExact(target, a0, (Object)av); }
- protected Object target_2(Object a0, Object a1, Object... av)
- throws Throwable { return invoker.invokeExact(target, a0, a1, (Object)av); }
- protected Object target_3(Object a0, Object a1, Object a2, Object... av)
- throws Throwable { return invoker.invokeExact(target, a0, a1, a2, (Object)av); }
- protected Object target_4(Object a0, Object a1, Object a2, Object a3, Object... av)
- throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, (Object)av); }
- // */
- // (For more than 4 arguments, generate the code in the adapter itself.)
-
- // Code to run when the generic target has finished and produced a value.
- protected Object return_L(Object res) throws Throwable { return (Object)convert.invokeExact(res); }
- protected int return_I(Object res) throws Throwable { return (int) convert.invokeExact(res); }
- protected long return_J(Object res) throws Throwable { return (long) convert.invokeExact(res); }
- protected float return_F(Object res) throws Throwable { return (float) convert.invokeExact(res); }
- protected double return_D(Object res) throws Throwable { return (double)convert.invokeExact(res); }
-
- static private final String CLASS_PREFIX; // "sun.dyn.ToGeneric$"
- static {
- String aname = Adapter.class.getName();
- String sname = Adapter.class.getSimpleName();
- if (!aname.endsWith(sname)) throw new InternalError();
- CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
- }
- /** Find a sibing class of Adapter. */
- static Class<? extends Adapter> findSubClass(String name) {
- String cname = Adapter.CLASS_PREFIX + name;
- try {
- return Class.forName(cname).asSubclass(Adapter.class);
- } catch (ClassNotFoundException ex) {
- return null;
- } catch (ClassCastException ex) {
- return null;
- }
- }
- }
-
- /* generated classes follow this pattern:
- static class A1 extends Adapter {
- protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
- protected Object target(Object a0) throws Throwable { return invoker.invokeExact(target, a0); }
- protected Object targetA1(Object a0) throws Throwable { return target(a0); }
- protected Object targetA1(int a0) throws Throwable { return target(a0); }
- protected Object targetA1(long a0) throws Throwable { return target(a0); }
- protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
- protected int invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
- protected long invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
- protected float invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
- protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
- protected Object invoke_L(int a0) throws Throwable { return return_L(targetA1(a0)); }
- protected int invoke_I(int a0) throws Throwable { return return_I(targetA1(a0)); }
- protected long invoke_J(int a0) throws Throwable { return return_J(targetA1(a0)); }
- protected float invoke_F(int a0) throws Throwable { return return_F(targetA1(a0)); }
- protected double invoke_D(int a0) throws Throwable { return return_D(targetA1(a0)); }
- protected Object invoke_L(long a0) throws Throwable { return return_L(targetA1(a0)); }
- protected int invoke_I(long a0) throws Throwable { return return_I(targetA1(a0)); }
- protected long invoke_J(long a0) throws Throwable { return return_J(targetA1(a0)); }
- protected float invoke_F(long a0) throws Throwable { return return_F(targetA1(a0)); }
- protected double invoke_D(long a0) throws Throwable { return return_D(targetA1(a0)); }
- }
- // */
-
-/*
-: SHELL; n=ToGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
-//{{{
-import java.util.*;
-class genclasses {
- static String[] TYPES = { "Object", "int ", "long ", "float ", "double" };
- static String[] TCHARS = { "L", "I", "J", "F", "D", "A" };
- static String[][] TEMPLATES = { {
- "@for@ arity=0..3 rcat<=4 nrefs<=99 nints<=99 nlongs<=99",
- "@for@ arity=4..5 rcat<=2 nrefs<=99 nints<=99 nlongs<=99",
- "@for@ arity=6..10 rcat<=2 nrefs<=99 nints=0 nlongs<=99",
- " //@each-cat@",
- " static class @cat@ extends Adapter {",
- " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
- " protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }",
- " protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new @cat@(e, i, c, t); }",
- " protected Object target(@Ovav@) throws Throwable { return invoker.invokeExact(target, @av@); }",
- " //@each-Tv@",
- " protected Object target@cat@(@Tvav@) throws Throwable { return target(@av@); }",
- " //@end-Tv@",
- " //@each-Tv@",
- " //@each-R@",
- " protected @R@ invoke_@Rc@(@Tvav@) throws Throwable { return return_@Rc@(target@cat@(@av@)); }",
- " //@end-R@",
- " //@end-Tv@",
- " }",
- } };
- enum VAR {
- cat, R, Rc, Tv, av, Tvav, Ovav;
- public final String pattern = "@"+toString().replace('_','.')+"@";
- public String binding;
- static void makeBindings(boolean topLevel, int rcat, int nrefs, int nints, int nlongs) {
- int nargs = nrefs + nints + nlongs;
- if (topLevel)
- VAR.cat.binding = catstr(ALL_RETURN_TYPES ? TYPES.length : rcat, nrefs, nints, nlongs);
- VAR.R.binding = TYPES[rcat];
- VAR.Rc.binding = TCHARS[rcat];
- String[] Tv = new String[nargs];
- String[] av = new String[nargs];
- String[] Tvav = new String[nargs];
- String[] Ovav = new String[nargs];
- for (int i = 0; i < nargs; i++) {
- int tcat = (i < nrefs) ? 0 : (i < nrefs + nints) ? 1 : 2;
- Tv[i] = TYPES[tcat];
- av[i] = arg(i);
- Tvav[i] = param(Tv[i], av[i]);
- Ovav[i] = param("Object", av[i]);
- }
- VAR.Tv.binding = comma(Tv);
- VAR.av.binding = comma(av);
- VAR.Tvav.binding = comma(Tvav);
- VAR.Ovav.binding = comma(Ovav);
- }
- static String arg(int i) { return "a"+i; }
- static String param(String t, String a) { return t+" "+a; }
- static String comma(String[] v) { return comma(v, ""); }
- static String comma(String sep, String[] v) {
- if (v.length == 0) return "";
- String res = sep+v[0];
- for (int i = 1; i < v.length; i++) res += ", "+v[i];
- return res;
- }
- static String transform(String string) {
- for (VAR var : values())
- string = string.replaceAll(var.pattern, var.binding);
- return string;
- }
- }
- static String[] stringsIn(String[] strings, int beg, int end) {
- return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
- }
- static String[] stringsBefore(String[] strings, int pos) {
- return stringsIn(strings, 0, pos);
- }
- static String[] stringsAfter(String[] strings, int pos) {
- return stringsIn(strings, pos, strings.length);
- }
- static int indexAfter(String[] strings, int pos, String tag) {
- return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
- }
- static int indexBefore(String[] strings, int pos, String tag) {
- for (int i = pos, end = strings.length; ; i++) {
- if (i == end || strings[i].endsWith(tag)) return i;
- }
- }
- static int MIN_ARITY, MAX_ARITY, MAX_RCAT, MAX_REFS, MAX_INTS, MAX_LONGS;
- static boolean ALL_ARG_TYPES, ALL_RETURN_TYPES;
- static HashSet<String> done = new HashSet<String>();
- public static void main(String... av) {
- for (String[] template : TEMPLATES) {
- int forLinesLimit = indexBefore(template, 0, "@each-cat@");
- String[] forLines = stringsBefore(template, forLinesLimit);
- template = stringsAfter(template, forLinesLimit);
- for (String forLine : forLines)
- expandTemplate(forLine, template);
- }
- }
- static void expandTemplate(String forLine, String[] template) {
- String[] params = forLine.split("[^0-9]+");
- if (params[0].length() == 0) params = stringsAfter(params, 1);
- System.out.println("//params="+Arrays.asList(params));
- int pcur = 0;
- MIN_ARITY = Integer.valueOf(params[pcur++]);
- MAX_ARITY = Integer.valueOf(params[pcur++]);
- MAX_RCAT = Integer.valueOf(params[pcur++]);
- MAX_REFS = Integer.valueOf(params[pcur++]);
- MAX_INTS = Integer.valueOf(params[pcur++]);
- MAX_LONGS = Integer.valueOf(params[pcur++]);
- if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
- if (MAX_RCAT >= TYPES.length) MAX_RCAT = TYPES.length - 1;
- ALL_ARG_TYPES = (indexBefore(template, 0, "@each-Tv@") < template.length);
- ALL_RETURN_TYPES = (indexBefore(template, 0, "@each-R@") < template.length);
- for (int nargs = MIN_ARITY; nargs <= MAX_ARITY; nargs++) {
- for (int rcat = 0; rcat <= MAX_RCAT; rcat++) {
- expandTemplate(template, true, rcat, nargs, 0, 0);
- if (ALL_ARG_TYPES) break;
- expandTemplateForPrims(template, true, rcat, nargs, 1, 1);
- if (ALL_RETURN_TYPES) break;
- }
- }
- }
- static String catstr(int rcat, int nrefs, int nints, int nlongs) {
- int nargs = nrefs + nints + nlongs;
- String cat = TCHARS[rcat] + nargs;
- if (!ALL_ARG_TYPES) cat += (nints==0?"":"I"+nints)+(nlongs==0?"":"J"+nlongs);
- return cat;
- }
- static void expandTemplateForPrims(String[] template, boolean topLevel, int rcat, int nargs, int minints, int minlongs) {
- for (int isLong = 0; isLong <= 1; isLong++) {
- for (int nprims = 1; nprims <= nargs; nprims++) {
- int nrefs = nargs - nprims;
- int nints = ((1-isLong) * nprims);
- int nlongs = (isLong * nprims);
- expandTemplate(template, topLevel, rcat, nrefs, nints, nlongs);
- }
- }
- }
- static void expandTemplate(String[] template, boolean topLevel,
- int rcat, int nrefs, int nints, int nlongs) {
- int nargs = nrefs + nints + nlongs;
- if (nrefs > MAX_REFS || nints > MAX_INTS || nlongs > MAX_LONGS) return;
- VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
- if (topLevel && !done.add(VAR.cat.binding)) {
- System.out.println(" //repeat "+VAR.cat.binding);
- return;
- }
- for (int i = 0; i < template.length; i++) {
- String line = template[i];
- if (line.endsWith("@each-cat@")) {
- // ignore
- } else if (line.endsWith("@each-R@")) {
- int blockEnd = indexAfter(template, i, "@end-R@");
- String[] block = stringsIn(template, i+1, blockEnd-1);
- for (int rcat1 = rcat; rcat1 <= MAX_RCAT; rcat1++)
- expandTemplate(block, false, rcat1, nrefs, nints, nlongs);
- VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
- i = blockEnd-1; continue;
- } else if (line.endsWith("@each-Tv@")) {
- int blockEnd = indexAfter(template, i, "@end-Tv@");
- String[] block = stringsIn(template, i+1, blockEnd-1);
- expandTemplate(block, false, rcat, nrefs, nints, nlongs);
- expandTemplateForPrims(block, false, rcat, nargs, nints+1, nlongs+1);
- VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
- i = blockEnd-1; continue;
- } else {
- System.out.println(VAR.transform(line));
- }
- }
- }
-}
-//}}} */
-//params=[0, 3, 4, 99, 99, 99]
- static class A0 extends Adapter {
- protected A0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A0(e, i, c, t); }
- protected Object target() throws Throwable { return invoker.invokeExact(target); }
- protected Object targetA0() throws Throwable { return target(); }
- protected Object invoke_L() throws Throwable { return return_L(targetA0()); }
- protected int invoke_I() throws Throwable { return return_I(targetA0()); }
- protected long invoke_J() throws Throwable { return return_J(targetA0()); }
- protected float invoke_F() throws Throwable { return return_F(targetA0()); }
- protected double invoke_D() throws Throwable { return return_D(targetA0()); }
- }
- static class A1 extends Adapter {
- protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
- protected Object target(Object a0) throws Throwable { return invoker.invokeExact(target, a0); }
- protected Object targetA1(Object a0) throws Throwable { return target(a0); }
- protected Object targetA1(int a0) throws Throwable { return target(a0); }
- protected Object targetA1(long a0) throws Throwable { return target(a0); }
- protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
- protected int invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
- protected long invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
- protected float invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
- protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
- protected Object invoke_L(int a0) throws Throwable { return return_L(targetA1(a0)); }
- protected int invoke_I(int a0) throws Throwable { return return_I(targetA1(a0)); }
- protected long invoke_J(int a0) throws Throwable { return return_J(targetA1(a0)); }
- protected float invoke_F(int a0) throws Throwable { return return_F(targetA1(a0)); }
- protected double invoke_D(int a0) throws Throwable { return return_D(targetA1(a0)); }
- protected Object invoke_L(long a0) throws Throwable { return return_L(targetA1(a0)); }
- protected int invoke_I(long a0) throws Throwable { return return_I(targetA1(a0)); }
- protected long invoke_J(long a0) throws Throwable { return return_J(targetA1(a0)); }
- protected float invoke_F(long a0) throws Throwable { return return_F(targetA1(a0)); }
- protected double invoke_D(long a0) throws Throwable { return return_D(targetA1(a0)); }
- }
- static class A2 extends Adapter {
- protected A2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A2(e, i, c, t); }
- protected Object target(Object a0, Object a1) throws Throwable { return invoker.invokeExact(target, a0, a1); }
- protected Object targetA2(Object a0, Object a1) throws Throwable { return target(a0, a1); }
- protected Object targetA2(Object a0, int a1) throws Throwable { return target(a0, a1); }
- protected Object targetA2(int a0, int a1) throws Throwable { return target(a0, a1); }
- protected Object targetA2(Object a0, long a1) throws Throwable { return target(a0, a1); }
- protected Object targetA2(long a0, long a1) throws Throwable { return target(a0, a1); }
- protected Object invoke_L(Object a0, Object a1) throws Throwable { return return_L(targetA2(a0, a1)); }
- protected int invoke_I(Object a0, Object a1) throws Throwable { return return_I(targetA2(a0, a1)); }
- protected long invoke_J(Object a0, Object a1) throws Throwable { return return_J(targetA2(a0, a1)); }
- protected float invoke_F(Object a0, Object a1) throws Throwable { return return_F(targetA2(a0, a1)); }
- protected double invoke_D(Object a0, Object a1) throws Throwable { return return_D(targetA2(a0, a1)); }
- protected Object invoke_L(Object a0, int a1) throws Throwable { return return_L(targetA2(a0, a1)); }
- protected int invoke_I(Object a0, int a1) throws Throwable { return return_I(targetA2(a0, a1)); }
- protected long invoke_J(Object a0, int a1) throws Throwable { return return_J(targetA2(a0, a1)); }
- protected float invoke_F(Object a0, int a1) throws Throwable { return return_F(targetA2(a0, a1)); }
- protected double invoke_D(Object a0, int a1) throws Throwable { return return_D(targetA2(a0, a1)); }
- protected Object invoke_L(int a0, int a1) throws Throwable { return return_L(targetA2(a0, a1)); }
- protected int invoke_I(int a0, int a1) throws Throwable { return return_I(targetA2(a0, a1)); }
- protected long invoke_J(int a0, int a1) throws Throwable { return return_J(targetA2(a0, a1)); }
- protected float invoke_F(int a0, int a1) throws Throwable { return return_F(targetA2(a0, a1)); }
- protected double invoke_D(int a0, int a1) throws Throwable { return return_D(targetA2(a0, a1)); }
- protected Object invoke_L(Object a0, long a1) throws Throwable { return return_L(targetA2(a0, a1)); }
- protected int invoke_I(Object a0, long a1) throws Throwable { return return_I(targetA2(a0, a1)); }
- protected long invoke_J(Object a0, long a1) throws Throwable { return return_J(targetA2(a0, a1)); }
- protected float invoke_F(Object a0, long a1) throws Throwable { return return_F(targetA2(a0, a1)); }
- protected double invoke_D(Object a0, long a1) throws Throwable { return return_D(targetA2(a0, a1)); }
- protected Object invoke_L(long a0, long a1) throws Throwable { return return_L(targetA2(a0, a1)); }
- protected int invoke_I(long a0, long a1) throws Throwable { return return_I(targetA2(a0, a1)); }
- protected long invoke_J(long a0, long a1) throws Throwable { return return_J(targetA2(a0, a1)); }
- protected float invoke_F(long a0, long a1) throws Throwable { return return_F(targetA2(a0, a1)); }
- protected double invoke_D(long a0, long a1) throws Throwable { return return_D(targetA2(a0, a1)); }
- }
- static class A3 extends Adapter {
- protected A3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A3(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2) throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
- protected Object targetA3(Object a0, Object a1, Object a2) throws Throwable { return target(a0, a1, a2); }
- protected Object targetA3(Object a0, Object a1, int a2) throws Throwable { return target(a0, a1, a2); }
- protected Object targetA3(Object a0, int a1, int a2) throws Throwable { return target(a0, a1, a2); }
- protected Object targetA3(int a0, int a1, int a2) throws Throwable { return target(a0, a1, a2); }
- protected Object targetA3(Object a0, Object a1, long a2) throws Throwable { return target(a0, a1, a2); }
- protected Object targetA3(Object a0, long a1, long a2) throws Throwable { return target(a0, a1, a2); }
- protected Object targetA3(long a0, long a1, long a2) throws Throwable { return target(a0, a1, a2); }
- protected Object invoke_L(Object a0, Object a1, Object a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
- protected int invoke_I(Object a0, Object a1, Object a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
- protected long invoke_J(Object a0, Object a1, Object a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
- protected float invoke_F(Object a0, Object a1, Object a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
- protected double invoke_D(Object a0, Object a1, Object a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
- protected Object invoke_L(Object a0, Object a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
- protected int invoke_I(Object a0, Object a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
- protected long invoke_J(Object a0, Object a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
- protected float invoke_F(Object a0, Object a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
- protected double invoke_D(Object a0, Object a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
- protected Object invoke_L(Object a0, int a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
- protected int invoke_I(Object a0, int a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
- protected long invoke_J(Object a0, int a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
- protected float invoke_F(Object a0, int a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
- protected double invoke_D(Object a0, int a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
- protected Object invoke_L(int a0, int a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
- protected int invoke_I(int a0, int a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
- protected long invoke_J(int a0, int a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
- protected float invoke_F(int a0, int a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
- protected double invoke_D(int a0, int a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
- protected Object invoke_L(Object a0, Object a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
- protected int invoke_I(Object a0, Object a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
- protected long invoke_J(Object a0, Object a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
- protected float invoke_F(Object a0, Object a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
- protected double invoke_D(Object a0, Object a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
- protected Object invoke_L(Object a0, long a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
- protected int invoke_I(Object a0, long a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
- protected long invoke_J(Object a0, long a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
- protected float invoke_F(Object a0, long a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
- protected double invoke_D(Object a0, long a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
- protected Object invoke_L(long a0, long a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
- protected int invoke_I(long a0, long a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
- protected long invoke_J(long a0, long a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
- protected float invoke_F(long a0, long a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
- protected double invoke_D(long a0, long a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
- }
-//params=[4, 5, 2, 99, 99, 99]
- static class A4 extends Adapter {
- protected A4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A4(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2, Object a3) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
- protected Object targetA4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(Object a0, Object a1, Object a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(Object a0, Object a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(Object a0, int a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(int a0, int a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(Object a0, Object a1, Object a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(Object a0, Object a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(Object a0, long a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object targetA4(long a0, long a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(Object a0, Object a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(Object a0, Object a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(Object a0, Object a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(Object a0, int a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(Object a0, int a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(Object a0, int a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(int a0, int a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(int a0, int a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(int a0, int a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(Object a0, Object a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(Object a0, Object a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(Object a0, Object a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(Object a0, long a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(Object a0, long a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(Object a0, long a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- protected Object invoke_L(long a0, long a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
- protected int invoke_I(long a0, long a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
- protected long invoke_J(long a0, long a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
- }
- static class A5 extends Adapter {
- protected A5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A5(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(int a0, int a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object targetA5(long a0, long a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(int a0, int a1, int a2, int a3, int a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(int a0, int a1, int a2, int a3, int a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(int a0, int a1, int a2, int a3, int a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- protected Object invoke_L(long a0, long a1, long a2, long a3, long a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
- protected int invoke_I(long a0, long a1, long a2, long a3, long a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
- protected long invoke_J(long a0, long a1, long a2, long a3, long a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
- }
-//params=[6, 10, 2, 99, 0, 99]
- static class A6 extends Adapter {
- protected A6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A6(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5); }
- protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
- protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
- protected Object targetA6(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
- protected Object targetA6(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
- protected Object targetA6(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
- protected Object targetA6(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
- protected Object targetA6(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
- protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
- }
- static class A7 extends Adapter {
- protected A7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A7(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object targetA7(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
- }
- static class A8 extends Adapter {
- protected A8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A8(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object targetA8(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
- }
- static class A9 extends Adapter {
- protected A9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A9(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object targetA9(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
- }
- static class A10 extends Adapter {
- protected A10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
- protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
- protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A10(e, i, c, t); }
- protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object targetA10(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
- }
-}
--- a/jdk/src/share/classes/sun/dyn/util/ValueConversions.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/sun/dyn/util/ValueConversions.java Fri Mar 18 00:03:24 2011 -0700
@@ -25,20 +25,17 @@
package sun.dyn.util;
-import java.dyn.*;
+import java.dyn.MethodHandle;
+import java.dyn.MethodHandles;
import java.dyn.MethodHandles.Lookup;
+import java.dyn.MethodType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.List;
-import sun.dyn.Access;
-import sun.dyn.AdapterMethodHandle;
-import sun.dyn.MethodHandleImpl;
-import static sun.dyn.MemberName.uncaughtException;
public class ValueConversions {
- private static final Access IMPL_TOKEN = Access.getToken();
- private static final Lookup IMPL_LOOKUP = MethodHandleImpl.getLookup(IMPL_TOKEN);
+ private static final Lookup IMPL_LOOKUP = MethodHandles.lookup();
private static EnumMap<Wrapper, MethodHandle>[] newWrapperCaches(int n) {
@SuppressWarnings("unchecked")
@@ -157,7 +154,7 @@
mh = null;
}
} else {
- mh = retype(type, unbox(wrap, !exact, raw));
+ mh = unbox(wrap, !exact, raw).asType(type);
}
if (mh != null) {
cache.put(wrap, mh);
@@ -293,7 +290,7 @@
mh = null;
}
} else {
- mh = retype(type.erase(), box(wrap, !exact, raw));
+ mh = box(wrap, !exact, raw).asType(type.erase());
}
if (mh != null) {
cache.put(wrap, mh);
@@ -412,7 +409,7 @@
mh = null;
}
} else {
- mh = retype(IDENTITY.type(), rebox(wrap, !exact));
+ mh = rebox(wrap, !exact).asType(IDENTITY.type());
}
if (mh != null) {
cache.put(wrap, mh);
@@ -504,8 +501,8 @@
// use the raw method
Wrapper rawWrap = wrap.rawPrimitive();
- if (rawWrap != wrap) {
- mh = retype(type, zeroConstantFunction(rawWrap));
+ if (mh == null && rawWrap != wrap) {
+ mh = MethodHandles.explicitCastArguments(zeroConstantFunction(rawWrap), type);
}
if (mh != null) {
cache.put(wrap, mh);
@@ -552,6 +549,22 @@
return x;
}
+ static byte identity(byte x) {
+ return x;
+ }
+
+ static short identity(short x) {
+ return x;
+ }
+
+ static boolean identity(boolean x) {
+ return x;
+ }
+
+ static char identity(char x) {
+ return x;
+ }
+
/**
* Identity function on longs.
* @param x an arbitrary long value
@@ -561,6 +574,14 @@
return x;
}
+ static float identity(float x) {
+ return x;
+ }
+
+ static double identity(double x) {
+ return x;
+ }
+
/**
* Identity function, with reference cast.
* @param t an arbitrary reference type
@@ -590,7 +611,9 @@
IGNORE = IMPL_LOOKUP.findStatic(ValueConversions.class, "ignore", ignoreType);
EMPTY = IMPL_LOOKUP.findStatic(ValueConversions.class, "empty", ignoreType.dropParameterTypes(0, 1));
} catch (Exception ex) {
- throw uncaughtException(ex);
+ Error err = new InternalError("uncaught exception");
+ err.initCause(ex);
+ throw err;
}
}
@@ -622,7 +645,8 @@
mh = MethodHandles.insertArguments(CAST_REFERENCE, 0, type);
if (exact) {
MethodType xmt = MethodType.methodType(type, Object.class);
- mh = AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, xmt, mh);
+ mh = MethodHandles.explicitCastArguments(mh, xmt);
+ //mh = AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, xmt, mh);
}
if (cache != null)
cache.put(wrap, mh);
@@ -634,15 +658,11 @@
}
public static MethodHandle identity(Class<?> type) {
- if (type == Object.class)
- return IDENTITY;
- else if (!type.isPrimitive())
- return retype(MethodType.methodType(type, type), IDENTITY);
- else
- return identity(Wrapper.forPrimitiveType(type));
+ // This stuff has been moved into MethodHandles:
+ return MethodHandles.identity(type);
}
- static MethodHandle identity(Wrapper wrap) {
+ public static MethodHandle identity(Wrapper wrap) {
EnumMap<Wrapper, MethodHandle> cache = CONSTANT_FUNCTIONS[1];
MethodHandle mh = cache.get(wrap);
if (mh != null) {
@@ -665,12 +685,6 @@
return mh;
}
- // use a raw conversion
- if (wrap.isSingleWord() && wrap != Wrapper.INT) {
- mh = retype(type, identity(Wrapper.INT));
- } else if (wrap.isDoubleWord() && wrap != Wrapper.LONG) {
- mh = retype(type, identity(Wrapper.LONG));
- }
if (mh != null) {
cache.put(wrap, mh);
return mh;
@@ -678,10 +692,6 @@
throw new IllegalArgumentException("cannot find identity for " + wrap);
}
- private static MethodHandle retype(MethodType type, MethodHandle mh) {
- return AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, type, mh);
- }
-
private static final Object[] NO_ARGS_ARRAY = {};
private static Object[] makeArray(Object... args) { return args; }
private static Object[] array() { return NO_ARGS_ARRAY; }
--- a/jdk/src/share/classes/sun/dyn/util/VerifyAccess.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/src/share/classes/sun/dyn/util/VerifyAccess.java Fri Mar 18 00:03:24 2011 -0700
@@ -26,9 +26,6 @@
package sun.dyn.util;
import java.lang.reflect.Modifier;
-import sun.dyn.MemberName;
-import sun.dyn.MethodHandleImpl;
-import sun.dyn.empty.Empty;
import static java.lang.reflect.Modifier.*;
/**
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/dyn/6987555/Test6987555.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+/**
+ * @test
+ * @bug 6987555
+ * @summary JSR 292 unboxing to a boolean value fails on big-endian SPARC
+ *
+ * @run main/othervm -Xint -ea -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles -XX:+EnableInvokeDynamic -XX:+UnlockDiagnosticVMOptions -XX:+VerifyMethodHandles Test6987555
+ */
+
+import java.dyn.*;
+
+public class Test6987555 {
+ private static final Class CLASS = Test6987555.class;
+ private static final String NAME = "foo";
+ private static final boolean DEBUG = false;
+
+ public static void main(String[] args) throws Throwable {
+ testboolean();
+ testbyte();
+ testchar();
+ testshort();
+ testint();
+ }
+
+ // boolean
+ static void testboolean() throws Throwable {
+ doboolean(false);
+ doboolean(true);
+ }
+ static void doboolean(boolean x) throws Throwable {
+ if (DEBUG) System.out.println("boolean=" + x);
+ MethodHandle mh1 = MethodHandles.lookup().findStatic(CLASS, NAME, MethodType.methodType(boolean.class, boolean.class));
+ MethodHandle mh2 = mh1.asType(MethodType.methodType(boolean.class, Boolean.class));
+ boolean a = (boolean) mh1.invokeExact(x);
+ boolean b = (boolean) mh2.invokeExact(Boolean.valueOf(x));
+ assert a == b : a + " != " + b;
+ }
+
+ // byte
+ static void testbyte() throws Throwable {
+ byte[] a = new byte[] {
+ Byte.MIN_VALUE,
+ Byte.MIN_VALUE + 1,
+ -0x0F,
+ -1,
+ 0,
+ 1,
+ 0x0F,
+ Byte.MAX_VALUE - 1,
+ Byte.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ dobyte(a[i]);
+ }
+ }
+ static void dobyte(byte x) throws Throwable {
+ if (DEBUG) System.out.println("byte=" + x);
+ MethodHandle mh1 = MethodHandles.lookup().findStatic(CLASS, NAME, MethodType.methodType(byte.class, byte.class));
+ MethodHandle mh2 = mh1.asType(MethodType.methodType(byte.class, Byte.class));
+ byte a = (byte) mh1.invokeExact(x);
+ byte b = (byte) mh2.invokeExact(Byte.valueOf(x));
+ assert a == b : a + " != " + b;
+ }
+
+ // char
+ static void testchar() throws Throwable {
+ char[] a = new char[] {
+ Character.MIN_VALUE,
+ Character.MIN_VALUE + 1,
+ 0x000F,
+ 0x00FF,
+ 0x0FFF,
+ Character.MAX_VALUE - 1,
+ Character.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ dochar(a[i]);
+ }
+ }
+ static void dochar(char x) throws Throwable {
+ if (DEBUG) System.out.println("char=" + x);
+ MethodHandle mh1 = MethodHandles.lookup().findStatic(CLASS, NAME, MethodType.methodType(char.class, char.class));
+ MethodHandle mh2 = mh1.asType(MethodType.methodType(char.class, Character.class));
+ char a = (char) mh1.invokeExact(x);
+ char b = (char) mh2.invokeExact(Character.valueOf(x));
+ assert a == b : a + " != " + b;
+ }
+
+ // short
+ static void testshort() throws Throwable {
+ short[] a = new short[] {
+ Short.MIN_VALUE,
+ Short.MIN_VALUE + 1,
+ -0x0FFF,
+ -0x00FF,
+ -0x000F,
+ -1,
+ 0,
+ 1,
+ 0x000F,
+ 0x00FF,
+ 0x0FFF,
+ Short.MAX_VALUE - 1,
+ Short.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ doshort(a[i]);
+ }
+ }
+ static void doshort(short x) throws Throwable {
+ if (DEBUG) System.out.println("short=" + x);
+ MethodHandle mh1 = MethodHandles.lookup().findStatic(CLASS, NAME, MethodType.methodType(short.class, short.class));
+ MethodHandle mh2 = mh1.asType(MethodType.methodType(short.class, Short.class));
+ short a = (short) mh1.invokeExact(x);
+ short b = (short) mh2.invokeExact(Short.valueOf(x));
+ assert a == b : a + " != " + b;
+ }
+
+ // int
+ static void testint() throws Throwable {
+ int[] a = new int[] {
+ Integer.MIN_VALUE,
+ Integer.MIN_VALUE + 1,
+ -0x00000FFF,
+ -0x000000FF,
+ -0x0000000F,
+ -1,
+ 0,
+ 1,
+ 0x0000000F,
+ 0x000000FF,
+ 0x00000FFF,
+ Integer.MAX_VALUE - 1,
+ Integer.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ doint(a[i]);
+ }
+ }
+ static void doint(int x) throws Throwable {
+ if (DEBUG) System.out.println("int=" + x);
+ MethodHandle mh1 = MethodHandles.lookup().findStatic(CLASS, NAME, MethodType.methodType(int.class, int.class));
+ MethodHandle mh2 = mh1.asType(MethodType.methodType(int.class, Integer.class));
+ int a = (int) mh1.invokeExact(x);
+ int b = (int) mh2.invokeExact(Integer.valueOf(x));
+ assert a == b : a + " != " + b;
+ }
+
+ public static boolean foo(boolean i) { return i; }
+ public static byte foo(byte i) { return i; }
+ public static char foo(char i) { return i; }
+ public static short foo(short i) { return i; }
+ public static int foo(int i) { return i; }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/dyn/6991596/Test6991596.java Fri Mar 18 00:03:24 2011 -0700
@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+/**
+ * @test
+ * @bug 6991596
+ * @summary JSR 292 unimplemented adapter_opt_i2i and adapter_opt_l2i on SPARC
+ *
+ * @run main/othervm -ea -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles -XX:+EnableInvokeDynamic -XX:+UnlockDiagnosticVMOptions -XX:+VerifyMethodHandles Test6991596
+ */
+
+import java.dyn.*;
+
+public class Test6991596 {
+ private static final Class CLASS = Test6991596.class;
+ private static final String NAME = "foo";
+ private static final boolean DEBUG = System.getProperty("DEBUG", "false").equals("true");
+
+ public static void main(String[] args) throws Throwable {
+ testboolean();
+ testbyte();
+ testchar();
+ testshort();
+ testint();
+ testlong();
+ }
+
+ // Helpers to get various methods.
+ static MethodHandle getmh1(Class ret, Class arg) throws ReflectiveOperationException {
+ return MethodHandles.lookup().findStatic(CLASS, NAME, MethodType.methodType(ret, arg));
+ }
+ static MethodHandle getmh2(MethodHandle mh1, Class ret, Class arg) {
+ return MethodHandles.convertArguments(mh1, MethodType.methodType(ret, arg));
+ }
+ static MethodHandle getmh3(MethodHandle mh1, Class ret, Class arg) {
+ return MethodHandles.convertArguments(mh1, MethodType.methodType(ret, arg));
+ }
+
+ // test adapter_opt_i2i
+ static void testboolean() throws Throwable {
+ boolean[] a = new boolean[] {
+ true,
+ false
+ };
+ for (int i = 0; i < a.length; i++) {
+ doboolean(a[i]);
+ }
+ }
+ static void doboolean(boolean x) throws Throwable {
+ if (DEBUG) System.out.println("boolean=" + x);
+
+ // boolean
+ {
+ MethodHandle mh1 = getmh1( boolean.class, boolean.class);
+ MethodHandle mh2 = getmh2(mh1, boolean.class, boolean.class);
+ // TODO add this for all cases when the bugs are fixed.
+ //MethodHandle mh3 = getmh3(mh1, boolean.class, boolean.class);
+ boolean a = (boolean) mh1.invokeExact((boolean) x);
+ boolean b = (boolean) mh2.invokeExact(x);
+ //boolean c = mh3.<boolean>invokeExact((boolean) x);
+ check(x, a, b);
+ //check(x, c, x);
+ }
+
+ // byte
+ {
+ MethodHandle mh1 = getmh1( byte.class, byte.class );
+ MethodHandle mh2 = getmh2(mh1, byte.class, boolean.class);
+ byte a = (byte) mh1.invokeExact((byte) (x ? 1 : 0));
+ byte b = (byte) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // char
+ {
+ MethodHandle mh1 = getmh1( char.class, char.class);
+ MethodHandle mh2 = getmh2(mh1, char.class, boolean.class);
+ char a = (char) mh1.invokeExact((char) (x ? 1 : 0));
+ char b = (char) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // short
+ {
+ MethodHandle mh1 = getmh1( short.class, short.class);
+ MethodHandle mh2 = getmh2(mh1, short.class, boolean.class);
+ short a = (short) mh1.invokeExact((short) (x ? 1 : 0));
+ short b = (short) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+ }
+
+ static void testbyte() throws Throwable {
+ byte[] a = new byte[] {
+ Byte.MIN_VALUE,
+ Byte.MIN_VALUE + 1,
+ -0x0F,
+ -1,
+ 0,
+ 1,
+ 0x0F,
+ Byte.MAX_VALUE - 1,
+ Byte.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ dobyte(a[i]);
+ }
+ }
+ static void dobyte(byte x) throws Throwable {
+ if (DEBUG) System.out.println("byte=" + x);
+
+ // boolean
+ {
+ MethodHandle mh1 = getmh1( boolean.class, boolean.class);
+ MethodHandle mh2 = getmh2(mh1, boolean.class, byte.class);
+ boolean a = (boolean) mh1.invokeExact((x & 1) == 1);
+ boolean b = (boolean) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // byte
+ {
+ MethodHandle mh1 = getmh1( byte.class, byte.class);
+ MethodHandle mh2 = getmh2(mh1, byte.class, byte.class);
+ byte a = (byte) mh1.invokeExact((byte) x);
+ byte b = (byte) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // char
+ {
+ MethodHandle mh1 = getmh1( char.class, char.class);
+ MethodHandle mh2 = getmh2(mh1, char.class, byte.class);
+ char a = (char) mh1.invokeExact((char) x);
+ char b = (char) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // short
+ {
+ MethodHandle mh1 = getmh1( short.class, short.class);
+ MethodHandle mh2 = getmh2(mh1, short.class, byte.class);
+ short a = (short) mh1.invokeExact((short) x);
+ short b = (short) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+ }
+
+ static void testchar() throws Throwable {
+ char[] a = new char[] {
+ Character.MIN_VALUE,
+ Character.MIN_VALUE + 1,
+ 0x000F,
+ 0x00FF,
+ 0x0FFF,
+ Character.MAX_VALUE - 1,
+ Character.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ dochar(a[i]);
+ }
+ }
+ static void dochar(char x) throws Throwable {
+ if (DEBUG) System.out.println("char=" + x);
+
+ // boolean
+ {
+ MethodHandle mh1 = getmh1( boolean.class, boolean.class);
+ MethodHandle mh2 = getmh2(mh1, boolean.class, char.class);
+ boolean a = (boolean) mh1.invokeExact((x & 1) == 1);
+ boolean b = (boolean) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // byte
+ {
+ MethodHandle mh1 = getmh1( byte.class, byte.class);
+ MethodHandle mh2 = getmh2(mh1, byte.class, char.class);
+ byte a = (byte) mh1.invokeExact((byte) x);
+ byte b = (byte) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // char
+ {
+ MethodHandle mh1 = getmh1( char.class, char.class);
+ MethodHandle mh2 = getmh2(mh1, char.class, char.class);
+ char a = (char) mh1.invokeExact((char) x);
+ char b = (char) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // short
+ {
+ MethodHandle mh1 = getmh1( short.class, short.class);
+ MethodHandle mh2 = getmh2(mh1, short.class, char.class);
+ short a = (short) mh1.invokeExact((short) x);
+ short b = (short) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+ }
+
+ static void testshort() throws Throwable {
+ short[] a = new short[] {
+ Short.MIN_VALUE,
+ Short.MIN_VALUE + 1,
+ -0x0FFF,
+ -0x00FF,
+ -0x000F,
+ -1,
+ 0,
+ 1,
+ 0x000F,
+ 0x00FF,
+ 0x0FFF,
+ Short.MAX_VALUE - 1,
+ Short.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ doshort(a[i]);
+ }
+ }
+ static void doshort(short x) throws Throwable {
+ if (DEBUG) System.out.println("short=" + x);
+
+ // boolean
+ {
+ MethodHandle mh1 = getmh1( boolean.class, boolean.class);
+ MethodHandle mh2 = getmh2(mh1, boolean.class, short.class);
+ boolean a = (boolean) mh1.invokeExact((x & 1) == 1);
+ boolean b = (boolean) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // byte
+ {
+ MethodHandle mh1 = getmh1( byte.class, byte.class);
+ MethodHandle mh2 = getmh2(mh1, byte.class, short.class);
+ byte a = (byte) mh1.invokeExact((byte) x);
+ byte b = (byte) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // char
+ {
+ MethodHandle mh1 = getmh1( char.class, char.class);
+ MethodHandle mh2 = getmh2(mh1, char.class, short.class);
+ char a = (char) mh1.invokeExact((char) x);
+ char b = (char) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // short
+ {
+ MethodHandle mh1 = getmh1( short.class, short.class);
+ MethodHandle mh2 = getmh2(mh1, short.class, short.class);
+ short a = (short) mh1.invokeExact((short) x);
+ short b = (short) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+ }
+
+ static void testint() throws Throwable {
+ int[] a = new int[] {
+ Integer.MIN_VALUE,
+ Integer.MIN_VALUE + 1,
+ -0x0FFFFFFF,
+ -0x00FFFFFF,
+ -0x000FFFFF,
+ -0x0000FFFF,
+ -0x00000FFF,
+ -0x000000FF,
+ -0x0000000F,
+ -1,
+ 0,
+ 1,
+ 0x0000000F,
+ 0x000000FF,
+ 0x00000FFF,
+ 0x0000FFFF,
+ 0x000FFFFF,
+ 0x00FFFFFF,
+ 0x0FFFFFFF,
+ Integer.MAX_VALUE - 1,
+ Integer.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ doint(a[i]);
+ }
+ }
+ static void doint(int x) throws Throwable {
+ if (DEBUG) System.out.println("int=" + x);
+
+ // boolean
+ {
+ MethodHandle mh1 = getmh1( boolean.class, boolean.class);
+ MethodHandle mh2 = getmh2(mh1, boolean.class, int.class);
+ boolean a = (boolean) mh1.invokeExact((x & 1) == 1);
+ boolean b = (boolean) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // byte
+ {
+ MethodHandle mh1 = getmh1( byte.class, byte.class);
+ MethodHandle mh2 = getmh2(mh1, byte.class, int.class);
+ byte a = (byte) mh1.invokeExact((byte) x);
+ byte b = (byte) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // char
+ {
+ MethodHandle mh1 = getmh1( char.class, char.class);
+ MethodHandle mh2 = getmh2(mh1, char.class, int.class);
+ char a = (char) mh1.invokeExact((char) x);
+ char b = (char) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // short
+ {
+ MethodHandle mh1 = getmh1( short.class, short.class);
+ MethodHandle mh2 = getmh2(mh1, short.class, int.class);
+ short a = (short) mh1.invokeExact((short) x);
+ short b = (short) mh2.invokeExact(x);
+ assert a == b : a + " != " + b;
+ check(x, a, b);
+ }
+
+ // int
+ {
+ MethodHandle mh1 = getmh1( int.class, int.class);
+ MethodHandle mh2 = getmh2(mh1, int.class, int.class);
+ int a = (int) mh1.invokeExact((int) x);
+ int b = (int) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+ }
+
+ // test adapter_opt_l2i
+ static void testlong() throws Throwable {
+ long[] a = new long[] {
+ Long.MIN_VALUE,
+ Long.MIN_VALUE + 1,
+ -0x000000000FFFFFFFL,
+ -0x0000000000FFFFFFL,
+ -0x00000000000FFFFFL,
+ -0x000000000000FFFFL,
+ -0x0000000000000FFFL,
+ -0x00000000000000FFL,
+ -0x000000000000000FL,
+ -1L,
+ 0L,
+ 1L,
+ 0x000000000000000FL,
+ 0x00000000000000FFL,
+ 0x0000000000000FFFL,
+ 0x0000000000000FFFL,
+ 0x000000000000FFFFL,
+ 0x00000000000FFFFFL,
+ 0x0000000000FFFFFFL,
+ 0x000000000FFFFFFFL,
+ Long.MAX_VALUE - 1,
+ Long.MAX_VALUE
+ };
+ for (int i = 0; i < a.length; i++) {
+ dolong(a[i]);
+ }
+ }
+ static void dolong(long x) throws Throwable {
+ if (DEBUG) System.out.println("long=" + x);
+
+ // boolean
+ {
+ MethodHandle mh1 = getmh1( boolean.class, boolean.class);
+ MethodHandle mh2 = getmh2(mh1, boolean.class, long.class);
+ boolean a = (boolean) mh1.invokeExact((x & 1L) == 1L);
+ boolean b = (boolean) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // byte
+ {
+ MethodHandle mh1 = getmh1( byte.class, byte.class);
+ MethodHandle mh2 = getmh2(mh1, byte.class, long.class);
+ byte a = (byte) mh1.invokeExact((byte) x);
+ byte b = (byte) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // char
+ {
+ MethodHandle mh1 = getmh1( char.class, char.class);
+ MethodHandle mh2 = getmh2(mh1, char.class, long.class);
+ char a = (char) mh1.invokeExact((char) x);
+ char b = (char) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // short
+ {
+ MethodHandle mh1 = getmh1( short.class, short.class);
+ MethodHandle mh2 = getmh2(mh1, short.class, long.class);
+ short a = (short) mh1.invokeExact((short) x);
+ short b = (short) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+
+ // int
+ {
+ MethodHandle mh1 = getmh1( int.class, int.class);
+ MethodHandle mh2 = getmh2(mh1, int.class, long.class);
+ int a = (int) mh1.invokeExact((int) x);
+ int b = (int) mh2.invokeExact(x);
+ check(x, a, b);
+ }
+ }
+
+ static void check(boolean x, boolean e, boolean a) { p(z2h(x), z2h(e), z2h(a)); assert e == a : z2h(x) + ": " + z2h(e) + " != " + z2h(a); }
+ static void check(boolean x, byte e, byte a) { p(z2h(x), i2h(e), i2h(a)); assert e == a : z2h(x) + ": " + i2h(e) + " != " + i2h(a); }
+ static void check(boolean x, int e, int a) { p(z2h(x), i2h(e), i2h(a)); assert e == a : z2h(x) + ": " + i2h(e) + " != " + i2h(a); }
+
+ static void check(int x, boolean e, boolean a) { p(i2h(x), z2h(e), z2h(a)); assert e == a : i2h(x) + ": " + z2h(e) + " != " + z2h(a); }
+ static void check(int x, byte e, byte a) { p(i2h(x), i2h(e), i2h(a)); assert e == a : i2h(x) + ": " + i2h(e) + " != " + i2h(a); }
+ static void check(int x, int e, int a) { p(i2h(x), i2h(e), i2h(a)); assert e == a : i2h(x) + ": " + i2h(e) + " != " + i2h(a); }
+
+ static void check(long x, boolean e, boolean a) { p(l2h(x), z2h(e), z2h(a)); assert e == a : l2h(x) + ": " + z2h(e) + " != " + z2h(a); }
+ static void check(long x, byte e, byte a) { p(l2h(x), i2h(e), i2h(a)); assert e == a : l2h(x) + ": " + i2h(e) + " != " + i2h(a); }
+ static void check(long x, int e, int a) { p(l2h(x), i2h(e), i2h(a)); assert e == a : l2h(x) + ": " + i2h(e) + " != " + i2h(a); }
+
+ static void p(String x, String e, String a) { if (DEBUG) System.out.println(x + ": expected: " + e + ", actual: " + a); }
+
+ static String z2h(boolean x) { return x ? "1" : "0"; }
+ static String i2h(int x) { return Integer.toHexString(x); }
+ static String l2h(long x) { return Long.toHexString(x); }
+
+ // to int
+ public static boolean foo(boolean i) { return i; }
+ public static byte foo(byte i) { return i; }
+ public static char foo(char i) { return i; }
+ public static short foo(short i) { return i; }
+ public static int foo(int i) { return i; }
+}
--- a/jdk/test/java/dyn/MethodTypeTest.java Thu Mar 17 14:33:00 2011 -0700
+++ b/jdk/test/java/dyn/MethodTypeTest.java Fri Mar 18 00:03:24 2011 -0700
@@ -31,7 +31,6 @@
package test.java.dyn;
-import sun.dyn.MemberName;
import java.dyn.MethodType;
import java.lang.reflect.Method;
@@ -167,18 +166,6 @@
* Test of make method, of class MethodType.
*/
@Test
- public void testMake_Method() {
- System.out.println("make (via MemberName.getMethodType)");
- MethodType expResult = MethodType.methodType(int.class, String.class);
- MemberName name = new MemberName(compareTo);
- MethodType result = name.getMethodType();
- assertSame(expResult, result);
- }
-
- /**
- * Test of make method, of class MethodType.
- */
- @Test
public void testMake_MethodType() {
System.out.println("make (from rtype, MethodType)");
MethodType expResult = mt_iO2;